ATNEL tech-forum 2014-09-24T11:35:45+01:00 https://forum.atnel.pl/feed.php?f=4&t=7793&mode 2014-09-24T11:35:45+01:00 2014-09-24T11:35:45+01:00 https://forum.atnel.pl/viewtopic.php?t=7793&p=96554#p96554 <![CDATA[Re: Rejestrator ADC Atmega 1284P - problem z zapisem na SD]]> while(ADCSRA & (1<<ADSC)); ?

czytales moj post w ogole?

zrob tak:
- wywal z ADC obsluge przerwan
- zrob timer 10 ms (czy co ile potrzebujesz odczytywac, dla bezpieczenstwa na poczatek proponuje wieksza wartosc, np 100ms)
- w timerze zrob:
1) wybierz bufor do ktorej zapisujesz
2) przelec przez wszystkie kanaly admuxa ktore chcesz odczytac uzywac recznego odczytywania*
3) zaznacz ze bufor jest gotowy do zapisywania.

flaguj tez sobie (moze robisz, nie wiem) czy dany bufor zostal juz zapisany na karte SD i dopiero wtedy go 'zwalniaj do zapisywania'.

*reczne odczytywanie:
ustawienie kanalu
start konwersji
while(czekaj_az_skonczy_sie_konwersja).

ps. disk_timerproc();//do obsługi karty SD - zalecane jest co 10ms a wedlug komentarza masz timer ustawiony na 1ms.

Statystyki: Napisane przez charsz — 24 wrz 2014, o 11:35

]]> 2014-09-24T08:49:22+01:00 2014-09-24T08:49:22+01:00 https://forum.atnel.pl/viewtopic.php?t=7793&p=96536#p96536 <![CDATA[Re: Rejestrator ADC Atmega 1284P - problem z zapisem na SD]]> Czy Timer 0 powinien więc być skonfigurowany więc w następujący sposób:?
[syntax=c]//////////////////////////TIMER0//////////CTC co 1ms///////////////////////

TCCR0A |= (1<<WGM01);
TCCR0B |= (1<<CS02)|(1<<CS00); //preskaler ustawiony na 1024//speed = F_CPU/1024

TIMSK0 |= (1<<OCIE0A); // włączone przerywanie od timera0 match a
OCR0A =16;// 1 ms przerywanie przy 16MHz[/syntax]

A inicjalizacje ADC konfigurować w taki sposób?:

[syntax=c]void init_adc(void)
{

ADCSRA |= ((1<<ADPS2)|(1<<ADPS1)|(1<<ADPS0)); //16Mhz/128 = 125Khz the ADC reference clock
ADCSRA |= (1 << ADEN); // Włączenie ADC
ADCSRA |= (1 << ADIE); // Załączenie przerywania
ADCSRA |= (1 << ADSC); // Rozpoczęcie konwersji A2D
ADMUX |= (1 << REFS0); // Ustawienie Napięcia referyncyjnego do AVCC
ADMUX |= (1 << ADLAR); // Justowanie do lewej
ADCSRB |= (1<<ADTS1) | (1<<ADTS0); //Wyzwalanie ADC przez timer0 compare match a

}[/syntax]

Czy w przerywaniu ISR(ADC_vect) wykonywać kopiowanie wyników konwersji do poszczególnych buforów?
[syntax=c]ISR(ADC_vect)
{

if (recflag==1)
{

if(zapiszdobuforanr==2)
{
adc_test=2;
////////////////////////////////////////zapis do bufora 2///////////////////////////////////////
if (adc_wskbuf2<=ADCBUFSIZE)
{
adc_bufor2[adc_wskbuf2++] = adc0;//0
adc_bufor2[adc_wskbuf2++] = adc1;//1
adc_bufor2[adc_wskbuf2++] = adc2;//2
adc_bufor2[adc_wskbuf2++] = adc4;//3
adc_bufor2[adc_wskbuf2++] = adc5;//4
adc_bufor2[adc_wskbuf2++] = adc6;//5
adc_bufor2[adc_wskbuf2++] = adc_test;//6

}
else
{
adc_ovfbuf2=1;
adc_wskbuf2=0;

}
}
if(zapiszdobuforanr==1)
{
adc_test=1;
////////////////////////////////////////zapis do bufora 1/////////////////////////////////////////
if (adc_wskbuf1<=ADCBUFSIZE)
{
adc_bufor1[adc_wskbuf1++] = adc0;//0
adc_bufor1[adc_wskbuf1++] = adc1;//1
adc_bufor1[adc_wskbuf1++] = adc2;//2
adc_bufor1[adc_wskbuf1++] = adc4;//3
adc_bufor1[adc_wskbuf1++] = adc5;//4
adc_bufor1[adc_wskbuf1++] = adc6;//5
adc_bufor1[adc_wskbuf1++] = adc_test;//6
}
else
{
adc_ovfbuf1=1;
adc_wskbuf1=0;

}

}
else if(zapiszdobuforanr==3)
{
adc_test=3;
////////////////////////////////////////zapis do bufora 3/////////////////////////////////////////
if (adc_wskbuf3<=ADCBUFSIZE)
{
adc_bufor3[adc_wskbuf3++] = adc0;//0
adc_bufor3[adc_wskbuf3++] = adc1;//1
adc_bufor3[adc_wskbuf3++] = adc2;//2
adc_bufor3[adc_wskbuf3++] = adc4;//3
adc_bufor3[adc_wskbuf3++] = adc5;//4
adc_bufor3[adc_wskbuf3++] = adc6;//5
adc_bufor3[adc_wskbuf3++] = adc_test;//6

}
else
{
adc_ovfbuf3=1;
adc_wskbuf3=0;

}


}
else if(zapiszdobuforanr==4)
{
adc_test=4;
////////////////////////////////////////zapis do bufora 4/////////////////////////////////////////
if (adc_wskbuf4<=ADCBUFSIZE)
{
adc_bufor4[adc_wskbuf4++] = adc0;//0
adc_bufor4[adc_wskbuf4++] = adc1;//1
adc_bufor4[adc_wskbuf4++] = adc2;//2
adc_bufor4[adc_wskbuf4++] = adc4;//3
adc_bufor4[adc_wskbuf4++] = adc5;//4
adc_bufor4[adc_wskbuf4++] = adc6;//5
adc_bufor4[adc_wskbuf4++] = adc_test;//6
}
else
{
adc_ovfbuf4=1;
adc_wskbuf4=0;

}


}
}
else if(recflag==0 & zapiszdobuforanr==0)
{
adc_test=0;
////////////////////////////////////////zapis do bufora 1/////////////////////////////////////////

if (adc_wskbuf1<=ADCBUFSIZE)
{
adc_bufor1[adc_wskbuf1++] = adc0;//0
adc_bufor1[adc_wskbuf1++] = adc1;//1
adc_bufor1[adc_wskbuf1++] = adc2;//2
adc_bufor1[adc_wskbuf1++] = adc4;//3
adc_bufor1[adc_wskbuf1++] = adc5;//4
adc_bufor1[adc_wskbuf1++] = adc6;//5
adc_bufor1[adc_wskbuf1++] = adc_test;//6

}
else
{
adc_ovfbuf1=1;
adc_wskbuf1=0;

}

}
}[/syntax]

Czy w przerywaniach od Timera0 powinna być funkcja switch przełączająca pomiędzy poszczególnymi kanałami ADC?
Czy ustawienie w rejestrach ADC powoduje automatyczne rozpoczęcie i zakończenie konwersji?

Czy ma o wyglądać tak?:
[syntax=c]ISR(TIMER0_COMPA_vect)
{ //przerywanie co 1ms

switch (channel) // wybór kanału do odczytu ADC
{

/////////////////////////////////////////////////////////////////////////////////////////////////////////////
case (1): // ADC0

ADMUX = (1<<ADLAR) |(1<<REFS0)| channel; //Ustawianie nowych wartości

do
{
adc0 = ADCH;
}
while(ADCSRA & (1<<ADSC)); // SPRAWDZENIE CZY JUŻ SIĘ SKOŃCZYŁO

break;
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
case (2): // ADC1

ADMUX = (1<<ADLAR) |(1<<REFS0)| channel; //Ustawianie nowych wartości
do
{
adc1 = ADCH;
}
while(ADCSRA & (1<<ADSC)); // SPRAWDZENIE CZY JUŻ SIĘ SKOŃCZYŁO


break;
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
case (3): // ADC2

ADMUX = (1<<ADLAR) |(1<<REFS0)| channel; //Ustawianie nowych wartości
do
{
adc2 = ADCH;
}
while(ADCSRA & (1<<ADSC)); // SPRAWDZENIE CZY JUŻ SIĘ SKOŃCZYŁO


break;
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

case (4): // ADC3

ADMUX = (1<<ADLAR) |(1<<REFS0)| channel; //Ustawianie nowych wartości

do
{
adc3 = ADCH;
}
while(ADCSRA & (1<<ADSC)); // SPRAWDZENIE CZY JUŻ SIĘ SKOŃCZYŁO


break;
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

case (5): // ADC4

ADMUX = (1<<ADLAR) |(1<<REFS0)| channel; //Ustawianie nowych wartości

do
{
adc4 = ADCH;
}
while(ADCSRA & (1<<ADSC)); // SPRAWDZENIE CZY JUŻ SIĘ SKOŃCZYŁO

break;
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

case (6): // ADC5

ADMUX = (1<<ADLAR) |(1<<REFS0)| channel; //Ustawianie nowych wartości

do
{
adc5 = ADCH;
}
while(ADCSRA & (1<<ADSC)); // SPRAWDZENIE CZY JUŻ SIĘ SKOŃCZYŁO

break;

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
case (0): // ADC6

ADMUX = (1<<ADLAR) |(1<<REFS0)| channel; //Ustawianie nowych wartości
do
{
adc6 = ADCH;
}
while(ADCSRA & (1<<ADSC)); // SPRAWDZENIE CZY JUŻ SIĘ SKOŃCZYŁO

break;
}

if(channel<6)
channel++;
else
channel=0;

ADCSRA |= _BV(ADSC); // start konwersji

Timer++;//do obsługi karty SD
disk_timerproc();//do obsługi karty SD
}[/syntax]

Statystyki: Napisane przez Payfer — 24 wrz 2014, o 08:49

]]> 2014-09-23T14:42:41+01:00 2014-09-23T14:42:41+01:00 https://forum.atnel.pl/viewtopic.php?t=7793&p=96453#p96453 <![CDATA[Re: Rejestrator ADC Atmega 1284P - problem z zapisem na SD]]>
ISR(ADC_vect) - zazwyczaj uzywane we free runing
while(ADCSRA & (1<<ADSC)) - zazwyczaj uzywane w single conversion

kolejna i chyba wazniejsza sprawa, w jaki sposob kontrolujesz zeby odczyt ADC do kolejnego bufora byl co 10ms?
Czytalem kod pobieznie (sorry, ale formatowanie kodu, ilosc zbednych funkcji, flag, nie ulatwia tego zadania) i nic nie wskazalo zebys pilnowal czasu odczytu.

Statystyki: Napisane przez charsz — 23 wrz 2014, o 14:42

]]> 2014-09-23T12:45:33+01:00 2014-09-23T12:45:33+01:00 https://forum.atnel.pl/viewtopic.php?t=7793&p=96446#p96446 <![CDATA[Re: Rejestrator ADC Atmega 1284P - problem z zapisem na SD]]> na części składowe i od początku zacząć testować poszczególne elementy.
A nie tak jak teraz chcesz zrobić, że cały program. I tłumaczenie, że Ty chcesz tylko
żeby Ci w tym kodzie malutkie fragmenciki sprawdzić :(
No niestety nie ma innej drogi ;)

Statystyki: Napisane przez MirkoT — 23 wrz 2014, o 12:45

]]> 2014-09-23T11:43:07+01:00 2014-09-23T11:43:07+01:00 https://forum.atnel.pl/viewtopic.php?t=7793&p=96445#p96445 <![CDATA[Re: Rejestrator ADC Atmega 1284P - problem z zapisem na SD]]> Jeśli próbuję tylko sam zapis na kartę SD (przy wyłączonym LCD i rejestrami przesuwnymi) sytuacja jest identyczna - skokowy zapis.
A co do podziału projektu na części...To w taki sposób budowałem ten program. Najpierw chciałem, żeby to odpaliło wszystko razem a później dopiero zauważyłem, że coś jest nie tak z płynnym zapisem, przełączaniem się buforów. Pisałem to na różne sposoby ale to nie przynosiło rezultatu...

Statystyki: Napisane przez Payfer — 23 wrz 2014, o 11:43

]]> 2014-09-23T10:11:44+01:00 2014-09-23T10:11:44+01:00 https://forum.atnel.pl/viewtopic.php?t=7793&p=96442#p96442 <![CDATA[Re: Rejestrator ADC Atmega 1284P - problem z zapisem na SD]]> Payfer napisał(a):

Jeśli SPI wykorzystuje jedynie na transmisję z kartą SD, problem dokładnie ten sam. Także mogę podejrzewać, że SPI jest dobrze skonfigurowane i problem może tkwić gdzieś indziej.

Wydawało mi się, że napisałeś gdzieś, że zapis na kartę uruchomiłeś i wszystko działa...
To jak to w końcu jest?
Dlatego właśnie sugerowałem, żebyś podzielił projekt i kod "na kawałki".
Najpierw sama komunikacja z kartą.
Potem dopiero cała reszta. I to też nie wszystko na raz. Tylko stopniowo coraz więcej.

Powtórzę jeszcze raz:
Trudno jest analizować czyjś liczący ponad 1000 linii kod.

Statystyki: Napisane przez MirkoT — 23 wrz 2014, o 10:11

]]> 2014-09-23T09:45:50+01:00 2014-09-23T09:45:50+01:00 https://forum.atnel.pl/viewtopic.php?t=7793&p=96440#p96440 <![CDATA[Re: Rejestrator ADC Atmega 1284P - problem z zapisem na SD]]>
------------------------ [ Dodano po: 4 minutach ]

Odnośnie programu, który zawarłem w poście powyżej to chodziło mi o sprawdzenie tylko paru funkcji odnośnie zapisu.

Czy mam poprawną konfigurację ADC?
Czy funkcje "adcinttostr_buf..." zapełniania poszczególnych buforów jest poprawna? Czy konwersja z int na string ma odbywać się tak często?
Czy funkcja "zapis" służąca do przełączania pomiędzy kolejno zapychającymi się buforami jest poprawnie napisana?
Czy funkcja "FatFS_Write" wywoływana jest w odpowiednim miejscu?
Czy funkcja switch do przełączenia się kanałów ADC w przerywaniu od ADC jest poprawna oraz czy warunek (while(ADCSRA & (1<<ADSC));) o zakończonej konwersji Analog Cyfra jest poprawny?
Czy konfiguracja timerów i innych peryferiów jest poprawna?

Między innymi na te pytania chciałem otrzymać odpowiedź....
A wkleiłem cały program żeby nie wklejać osobno poszczególnych funkcji.

Pozdrawiam

Statystyki: Napisane przez Payfer — 23 wrz 2014, o 09:45

]]> 2014-09-22T20:47:28+01:00 2014-09-22T20:47:28+01:00 https://forum.atnel.pl/viewtopic.php?t=7793&p=96412#p96412 <![CDATA[Re: Rejestrator ADC Atmega 1284P - problem z zapisem na SD]]> Statystyki: Napisane przez charsz — 22 wrz 2014, o 20:47

]]> 2014-09-22T12:22:07+01:00 2014-09-22T12:22:07+01:00 https://forum.atnel.pl/viewtopic.php?t=7793&p=96325#p96325 <![CDATA[Re: Rejestrator ADC Atmega 1284P - problem z zapisem na SD]]> Statystyki: Napisane przez Payfer — 22 wrz 2014, o 12:22

]]> 2014-09-16T18:40:17+01:00 2014-09-16T18:40:17+01:00 https://forum.atnel.pl/viewtopic.php?t=7793&p=95688#p95688 <![CDATA[Re: Rejestrator ADC Atmega 1284P - problem z zapisem na SD]]>
Główny problem najprawdopodobniej polega na traceniu się wyników pomiędzy przełączaniem się na kolejny bufor. Kolejnym problemem może być choć nie musi sposób wysyłania danych przez SPI. Na jednym sprzętowym SPI jest Karta SD + bufor 74LCV125D oraz 3 rejestry przesuwne 74HC595, do których podłączone są diody oraz wyświetlacz 4x40. Zatrzask dla rejestrów przesuwnych jest na pinie PA7 natomiast CS dla karty jest na pinie PB4.

W moim miasteczku nie ma raczej osoby, która interesowałaby się programowaniem mikrokontrolerów w C. Stąd moja ogromna prośba o zdalną pomoc.

Poniżej program główny:
[syntax=cpp]#define F_CPU 16000000UL
#include <avr/io.h>
#define __PROG_TYPES_COMPAT__
#include <avr/pgmspace.h>
#include <string.h>
#include <util/delay.h>
#include <avr/interrupt.h>
#include <inttypes.h>
#include <avr/signal.h>
#include <stdlib.h>

#define BUFFER_SIZE 64
#define BUFFER_MASK ( BUFFER_SIZE - 1)

//#include "uart.h"
#include "xitoa.h"
#include "ff.h"
#include "diskio.h"
#include "rtc.h"
#include "LCD4x40.h"

#define MOSI PB5
#define SCK PB7
#define CS PB4
#define LT PA7

//////////////////////////////////////ADC///////////////////////////////////////////////////////
volatile int adc0,adc1,adc2,adc3,adc4,adc5,adc6,adc7,adc_test;
volatile int channel;
volatile int wskbufrec;
volatile int adc_wskbuf1;
volatile int adc_wskbuf2;
volatile int adc_wskbuf3;
volatile int adc_wskbuf4;
volatile int adc_ovfbuf1;
volatile int adc_ovfbuf2;
volatile int adc_ovfbuf3;
volatile int adc_ovfbuf4;
/*volatile int adc_bufsize=ADCBUFSIZE*/
volatile int adc_bufor1[ADCBUFSIZE];
volatile int adc_bufor2[ADCBUFSIZE];
volatile int adc_bufor3[ADCBUFSIZE];
volatile int adc_bufor4[ADCBUFSIZE];

volatile int wskbuf1A;
volatile int wskbuf1B;
volatile int wskbuf1C;

volatile int wskbuf2A;
volatile int wskbuf2B;
volatile int wskbuf2C;

volatile int wskbuf3A;
volatile int wskbuf3B;
volatile int wskbuf3C;

volatile int wskbuf4A;
volatile int wskbuf4B;
volatile int wskbuf4C;

volatile int zapiszdobuforanr;

char tmpadc0[3];
char tmpadc1[3];
char tmpadc2[3];
//volatile char tmpadc3[3];
char tmpadc4[3];
char tmpadc5[3];
char tmpadc6[3];
char tmptest[3];

DWORD Wiersz; // Aktualny wiersz w pliku
int ovfbuf1; //wskaznik przepełnienia bufora 1
int ovfbuf2; //wskaznik przepełnienia bufora 2
int ovfbuf3; //wskaznik przepełnienia bufora 3
int ovfbuf4; //wskaznik przepełnienia bufora 4
int strbufsize;

volatile char bufor1[1024];
volatile char bufor2[1024];
volatile char bufor3[1024];
volatile char bufor4[1024];
volatile int bajtow=985;
volatile int recflag;
volatile int liczzap;

//////////////////////////////////////////Tekst dla WYSWIETLACZA//////////////////////////////////////////////////////
char adc0_char [1];//bufor tekstowy, adc0
char adc1_char [1];//bufor tekstowy, adc1
char adc2_char [1];//bufor tekstowy, adc2
char adc3_char [1];//bufor tekstowy, adc3
char adc4_char [1];//bufor tekstowy, adc4
char adc5_char [1];//bufor tekstowy, adc5
char adc6_char [1];//bufor tekstowy, adc6
char adc7_char [1];//bufor tekstowy, adc7

char wiersz_char [1];//bufor tekstowy
///////////////////////////////////////////////TIMERY///////////////////////////////////////////////////////////////
volatile int spi_ch;
volatile int lcdonoff;
volatile int test;
volatile int recstart;;
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////


#if _USE_LFN
char Lfname[_MAX_LFN+1];
#endif

DWORD AccSize;/* Work register for fs command */
WORD AccFiles, AccDirs;
FILINFO Finfo;
char Line[80];/* Console input buffer */
BYTE Buff[512];/* Working buffer */
FATFS FatFs[_VOLUMES];/* File system object for each logical drive */
DIR Dir;/* Directory object */
UINT bw;
BYTE RtcOk;/* RTC is available */
volatile UINT Timer;/* Performance timer (100Hz increment) */
FRESULT res;

FRESULT FatFS_Write(FIL *File, char *Nazwa, DWORD Przesuniecie,char *Data, UINT IleBajtow, uint8_t Mode);
void Przerywania(void)
{
//Przerywania
EIMSK|= _BV(INT0) | _BV(INT1) | _BV(INT2); //włącz INT0 INT1 i INT2
}
void adcinttostr_buf1(void)
{
wskbuf1B=0;
wskbuf1C=0;
do
{


itoa(adc_bufor1[wskbuf1C++],tmpadc0,10);

for(wskbuf1B=0; wskbuf1B<=2; wskbuf1B++)
{
bufor1[wskbuf1A++] = tmpadc0[wskbuf1B];
}
bufor1[wskbuf1A++] = ';';



itoa(adc_bufor1[wskbuf1C++],tmpadc1,10);

for(wskbuf1B=0; wskbuf1B<=2; wskbuf1B++)
{
bufor1[wskbuf1A++] = tmpadc0[wskbuf1B];
}
bufor1[wskbuf1A++] = ';';



itoa(adc_bufor1[wskbuf1C++],tmpadc2,10);

for(wskbuf1B=0; wskbuf1B<=2; wskbuf1B++)
{
bufor1[wskbuf1A++] = tmpadc2[wskbuf1B];
}
bufor1[wskbuf1A++] = ';';



itoa(adc_bufor1[wskbuf1C++],tmpadc4,10);

for(wskbuf1B=0; wskbuf1B<=2; wskbuf1B++)
{
bufor1[wskbuf1A++] = tmpadc4[wskbuf1B];
}
bufor1[wskbuf1A++] = ';';



itoa(adc_bufor1[wskbuf1C++],tmpadc5,10);

for(wskbuf1B=0; wskbuf1B<=2; wskbuf1B++)
{
bufor1[wskbuf1A++] = tmpadc5[wskbuf1B];
}
bufor1[wskbuf1A++] = ';';



itoa(adc_bufor1[wskbuf1C++],tmpadc6,10);

for(wskbuf1B=0; wskbuf1B<=2; wskbuf1B++)
{
bufor1[wskbuf1A++] = tmpadc6[wskbuf1B];
}
bufor1[wskbuf1A++] = ';';



itoa(adc_bufor1[wskbuf1C++],tmptest,10);

for(wskbuf1B=0; wskbuf1B<=2; wskbuf1B++)
{
bufor1[wskbuf1A++] = tmptest[wskbuf1B];
}
// bufor1[wskbuf1A++] = ';';

bufor1[wskbuf1A++] = '\r';
bufor1[wskbuf1A++] = '\n';


}
while(wskbuf1A<=bajtow);

ovfbuf1=1;
wskbuf1B=0;
wskbuf1A=0;
wskbuf1C=0;

}
void adcinttostr_buf2(void)
{
wskbuf2B=0;
wskbuf2C=0;
do
{


itoa(adc_bufor2[wskbuf2C++],tmpadc0,10);

for(wskbuf2B=0; wskbuf2B<=2; wskbuf2B++)
{
bufor2[wskbuf2A++] = tmpadc0[wskbuf2B];
}
bufor2[wskbuf2A++] = ';';



itoa(adc_bufor2[wskbuf2C++],tmpadc1,10);

for(wskbuf2B=0; wskbuf2B<=2; wskbuf2B++)
{
bufor2[wskbuf2A++] = tmpadc0[wskbuf2B];
}
bufor2[wskbuf2A++] = ';';



itoa(adc_bufor2[wskbuf2C++],tmpadc2,10);

for(wskbuf2B=0; wskbuf2B<=2; wskbuf2B++)
{
bufor2[wskbuf2A++] = tmpadc2[wskbuf2B];
}
bufor2[wskbuf2A++] = ';';



itoa(adc_bufor2[wskbuf2C++],tmpadc4,10);

for(wskbuf2B=0; wskbuf2B<=2; wskbuf2B++)
{
bufor2[wskbuf2A++] = tmpadc4[wskbuf2B];
}
bufor2[wskbuf2A++] = ';';



itoa(adc_bufor2[wskbuf2C++],tmpadc5,10);

for(wskbuf2B=0; wskbuf2B<=2; wskbuf2B++)
{
bufor2[wskbuf2A++] = tmpadc5[wskbuf2B];
}
bufor2[wskbuf2A++] = ';';



itoa(adc_bufor2[wskbuf2C++],tmpadc6,10);

for(wskbuf2B=0; wskbuf2B<=2; wskbuf2B++)
{
bufor2[wskbuf2A++] = tmpadc6[wskbuf2B];
}
bufor2[wskbuf2A++] = ';';



itoa(adc_bufor2[wskbuf2C++],tmptest,10);

for(wskbuf2B=0; wskbuf2B<=2; wskbuf2B++)
{
bufor2[wskbuf2A++] = tmptest[wskbuf2B];
}
// bufor2[wskbuf2A++] = ';';

bufor2[wskbuf2A++] = '\r';
bufor2[wskbuf2A++] = '\n';


}
while(wskbuf2A<=bajtow);

ovfbuf2=1;
wskbuf2B=0;
wskbuf2A=0;
wskbuf2C=0;

}
void adcinttostr_buf3(void)
{
wskbuf3B=0;
wskbuf3C=0;
do
{


itoa(adc_bufor3[wskbuf3C++],tmpadc0,10);

for(wskbuf3B=0; wskbuf3B<=2; wskbuf3B++)
{
bufor3[wskbuf3A++] = tmpadc0[wskbuf3B];
}
bufor3[wskbuf3A++] = ';';



itoa(adc_bufor3[wskbuf3C++],tmpadc1,10);

for(wskbuf3B=0; wskbuf3B<=2; wskbuf3B++)
{
bufor3[wskbuf3A++] = tmpadc0[wskbuf3B];
}
bufor3[wskbuf3A++] = ';';



itoa(adc_bufor3[wskbuf3C++],tmpadc2,10);

for(wskbuf3B=0; wskbuf3B<=2; wskbuf3B++)
{
bufor3[wskbuf3A++] = tmpadc2[wskbuf3B];
}
bufor3[wskbuf3A++] = ';';



itoa(adc_bufor3[wskbuf3C++],tmpadc4,10);

for(wskbuf3B=0; wskbuf3B<=2; wskbuf3B++)
{
bufor3[wskbuf3A++] = tmpadc4[wskbuf3B];
}
bufor3[wskbuf3A++] = ';';



itoa(adc_bufor3[wskbuf3C++],tmpadc5,10);

for(wskbuf3B=0; wskbuf3B<=2; wskbuf3B++)
{
bufor3[wskbuf3A++] = tmpadc5[wskbuf3B];
}
bufor3[wskbuf3A++] = ';';



itoa(adc_bufor3[wskbuf3C++],tmpadc6,10);

for(wskbuf3B=0; wskbuf3B<=2; wskbuf3B++)
{
bufor3[wskbuf3A++] = tmpadc6[wskbuf3B];
}
bufor3[wskbuf3A++] = ';';



itoa(adc_bufor3[wskbuf3C++],tmptest,10);

for(wskbuf3B=0; wskbuf3B<=2; wskbuf3B++)
{
bufor3[wskbuf3A++] = tmptest[wskbuf3B];
}
// bufor1[wskbuf1A++] = ';';

bufor3[wskbuf3A++] = '\r';
bufor3[wskbuf3A++] = '\n';


}
while(wskbuf3A<=bajtow);

ovfbuf3=1;
wskbuf3B=0;
wskbuf3A=0;
wskbuf3C=0;

}
void adcinttostr_buf4(void)
{
wskbuf4B=0;
wskbuf4C=0;
do
{


itoa(adc_bufor4[wskbuf4C++],tmpadc0,10);

for(wskbuf4B=0; wskbuf4B<=2; wskbuf4B++)
{
bufor4[wskbuf4A++] = tmpadc0[wskbuf4B];
}
bufor4[wskbuf4A++] = ';';



itoa(adc_bufor4[wskbuf4C++],tmpadc1,10);

for(wskbuf4B=0; wskbuf4B<=2; wskbuf4B++)
{
bufor4[wskbuf4A++] = tmpadc0[wskbuf4B];
}
bufor4[wskbuf4A++] = ';';



itoa(adc_bufor4[wskbuf4C++],tmpadc2,10);

for(wskbuf4B=0; wskbuf4B<=2; wskbuf4B++)
{
bufor4[wskbuf4A++] = tmpadc2[wskbuf4B];
}
bufor4[wskbuf4A++] = ';';



itoa(adc_bufor4[wskbuf4C++],tmpadc4,10);

for(wskbuf4B=0; wskbuf4B<=2; wskbuf4B++)
{
bufor4[wskbuf4A++] = tmpadc4[wskbuf4B];
}
bufor4[wskbuf4A++] = ';';



itoa(adc_bufor4[wskbuf4C++],tmpadc5,10);

for(wskbuf4B=0; wskbuf4B<=2; wskbuf4B++)
{
bufor4[wskbuf4A++] = tmpadc5[wskbuf4B];
}
bufor4[wskbuf4A++] = ';';



itoa(adc_bufor4[wskbuf4C++],tmpadc6,10);

for(wskbuf4B=0; wskbuf4B<=2; wskbuf4B++)
{
bufor4[wskbuf4A++] = tmpadc6[wskbuf4B];
}
bufor4[wskbuf4A++] = ';';



itoa(adc_bufor4[wskbuf4C++],tmptest,10);

for(wskbuf4B=0; wskbuf4B<=2; wskbuf4B++)
{
bufor4[wskbuf4A++] = tmptest[wskbuf4B];
}
// bufor4[wskbuf4A++] = ';';

bufor4[wskbuf4A++] = '\r';
bufor4[wskbuf4A++] = '\n';


}
while(wskbuf4A<=bajtow);

ovfbuf4=1;
wskbuf4B=0;
wskbuf4A=0;
wskbuf4C=0;

}
void init_adc(void)
{

ADCSRA |= ((1<<ADPS2)|(1<<ADPS1)|(1<<ADPS0)); //16Mhz/128 = 125Khz the ADC reference clock
ADCSRA |= (1 << ADEN); // Włączenie ADC
ADCSRA |= (1 << ADIE); // Załączenie przerywania
ADCSRA |= (1 << ADSC); // Rozpoczęcie konwersji A2D
ADMUX |= (1 << REFS0); // Ustawienie Napięcia referyncyjnego do AVCC
ADMUX |= (1 << ADLAR); // Justowanie do lewej

//ADCSRB |= (1<<ADTS1) | (1<<ADTS0); //Wyzwalanie ADC przez timer0
//DIDR0 |= (1<<ADC0D);
}
void zapis(void)
{

FIL FIL;

if(adc_ovfbuf1==1)
{
test=1;//nr bufora
zapiszdobuforanr=2;
adcinttostr_buf1();

if (ovfbuf1==1)
{
res = FatFS_Write( &FIL,
"data.csv", // Nazwa pliku
(Wiersz * (bajtow+1)), // Obliczanie odpowiedniej lokalizacji w pliku
bufor1, // Dane do zapisu
bajtow+1, // Liczba bajtow do zapisu
FA_CREATE_ALWAYS | FA_WRITE);// Okreslenie typu dostepu
}

if(res == FR_OK) // Jesli wszystko OK
{
Wiersz++;
adc_ovfbuf1=0;
ovfbuf1=0;

}
else // Jesli nie
{

}

}

else if(adc_ovfbuf2==1)
{
test=2;//nr bufora
zapiszdobuforanr=3;
adcinttostr_buf2();

if (ovfbuf2==1)
{

res = FatFS_Write( &FIL,
"data.csv", // Nazwa pliku
(Wiersz * (bajtow+1)), // Obliczanie odpowiedniej lokalizacji w pliku
bufor2, // Dane do zapisu
bajtow+1, // Liczba bajtow do zapisu
FA_CREATE_ALWAYS | FA_WRITE);// Okreslenie typu dostepu

}
if(res == FR_OK) // Jesli wszystko OK
{
Wiersz++;
adc_ovfbuf2=0;
ovfbuf2=0;
}
else // Jesli nie
{

}



}
else if(adc_ovfbuf3==1)
{
test=3;//nr bufora
zapiszdobuforanr=4;
adcinttostr_buf3();//test=(Wiersz * (bajtow+1));


res = FatFS_Write( &FIL,
"data.csv", // Nazwa pliku
(Wiersz * (bajtow+1)), // Obliczanie odpowiedniej lokalizacji w pliku
bufor3, // Dane do zapisu
bajtow+1, // Liczba bajtow do zapisu
FA_CREATE_ALWAYS | FA_WRITE);// Okreslenie typu dostepu



if(res == FR_OK) // Jesli wszystko OK
{
Wiersz++;
adc_ovfbuf3=0;
ovfbuf3=0;
}
else // Jesli nie
{

}



}

else if(adc_ovfbuf4==1)
{
test=4;//nr bufora
zapiszdobuforanr=1;
adcinttostr_buf4();

res = FatFS_Write( &FIL,
"data.csv", // Nazwa pliku
(Wiersz * (bajtow+1)), // Obliczanie odpowiedniej lokalizacji w pliku
bufor4, // Dane do zapisu
bajtow+1, // Liczba bajtow do zapisu
FA_CREATE_ALWAYS | FA_WRITE);// Okreslenie typu dostepu



if(res == FR_OK) // Jesli wszystko OK
{
Wiersz++;
adc_ovfbuf4=0;
ovfbuf4=0;
}
else // Jesli nie
{

}



}



}
DWORD get_fattime (void)
{
RTC rtc;

if (!RtcOk) return 0;

/* Get local time */
rtc_gettime(&rtc);

/* Pack date and time into a DWORD variable */
return ((DWORD)(rtc.year - 1980) << 25)
| ((DWORD)rtc.month << 21)
| ((DWORD)rtc.mday << 16)
| ((DWORD)rtc.hour << 11)
| ((DWORD)rtc.min << 5)
| ((DWORD)rtc.sec >> 1);
}
static void put_dump (const BYTE *buff, DWORD ofs, BYTE cnt)
{
BYTE i;
xprintf(PSTR("%08lX:"), ofs);

for(i = 0; i < cnt; i++)
xprintf(PSTR(" %02X"), buff[i]);

xputc(' ');
for(i = 0; i < cnt; i++)
xputc((buff[i] >= ' ' && buff[i] <= '~') ? buff[i] : '.');

xputc('\n');
}
static void get_line (char *buff, int len)
{
BYTE c;
int i = 0;

for (;;) {
c = uart_getc();
if (c == '\r') break;
if ((c == '\b') && i) {
i--;
uart_putc(c);
continue;
}
if (c >= ' ' && i < len - 1) {/* Visible chars */
buff[i++] = c;
xputc(c);
}
}
buff[i] = 0;
uart_putc('\n');
}
static FRESULT scan_files (char* path)
{
DIR dirs;
FRESULT res;
int i;
char *fn;

res = f_opendir(&dirs, path);
if (res == FR_OK) {
i = strlen(path);
while (((res = f_readdir(&dirs, &Finfo)) == FR_OK) && Finfo.fname[0]) {
if (_FS_RPATH && Finfo.fname[0] == '.') continue;
#if _USE_LFN
fn = *Finfo.lfname ? Finfo.lfname : Finfo.fname;
#else
fn = Finfo.fname;
#endif
if (Finfo.fattrib & AM_DIR) {
AccDirs++;
path[i] = '/'; strcpy(path+i+1, fn);
res = scan_files(path);
path[i] = '\0';
if (res != FR_OK) break;
} else {
//xprintf(PSTR("%s/%s\n"), path, fn);
AccFiles++;
AccSize += Finfo.fsize;
}
}
}

return res;
}
static void put_rc (FRESULT rc)
{
const prog_char *p;
static const prog_char str[] =
"OK\0" "DISK_ERR\0" "INT_ERR\0" "NOT_READY\0" "NO_FILE\0" "NO_PATH\0"
"INVALID_NAME\0" "DENIED\0" "EXIST\0" "INVALID_OBJECT\0" "WRITE_PROTECTED\0"
"INVALID_DRIVE\0" "NOT_ENABLED\0" "NO_FILE_SYSTEM\0" "MKFS_ABORTED\0" "TIMEOUT\0"
"LOCKED\0" "NOT_ENOUGH_CORE\0" "TOO_MANY_OPEN_FILES\0";
FRESULT i;

for (p = str, i = 0; i != rc && pgm_read_byte_near(p); i++) {
while(pgm_read_byte_near(p++));
}
//xprintf(PSTR("rc=%u FR_%S\n"), rc, p);
}
void ioinit (void)
{
DDRA &=~ (1<<PA3); //ustawwienia przycisku rec
PORTA |= (1<<PA3); //przycisk rec pullup do vcc
DDRA &=~ (1<<PA0);
DDRA &=~ (1<<PA1);
DDRA &=~ (1<<PA2);
DDRA &=~ (1<<PA4);
DDRA &=~ (1<<PA5);
DDRA &=~ (1<<PA6);

DDRC |= (1<<PC3); //jako wyjście
DDRC |= (1<<PC2); //jako wyjście

DDRC |= (1<<PC5); //jako wyjście
DDRC |= (1<<PC4); //jako wyjście

DDRD &= ~(1<<PD0); // wejscie
DDRD &= ~(1<<PD1); // wejscie

PORTD |= (1<<PD0); //pull up na wejście
PORTD |= (1<<PD1); //pull up na wejście

DDRD &= ~(1<<PD2); //
DDRB &= ~(1<<PB0); //
PORTD |= (1<<PD2);
PORTB |= (1<<PB0);

DDRD &= ~(1<<PD3); //
DDRB &= ~(1<<PB1); //
PORTD |= (1<<PD3);
PORTB |= (1<<PB1);


DDRB &= ~(1<<PB2); //
DDRB &= ~(1<<PB3); //
PORTB |= (1<<PB2);
PORTB |= (1<<PB3);

DDRD |= (1<<PD5); //wyjscie
DDRD |= (1<<PD4); //wyjscie
DDRD |= (1<<PD7); //wyjscie

DDRD |= (1<<PD6); //wyjscie
DDRC |= (1<<PC7); //wyjscie
DDRC |= (1<<PC6); //wyjscie



}
void timery(void)
{
///////////////////////////////////PWM////////////////////////////////////////////////////////

////////////////////////////////TIMER1//8bit////////Phase Correct mode 1//////////////////////
TCCR1A |= (1<<WGM10)|(1<<COM1A1)|(1<<COM1B1);
TCCR1B |= (1<<CS10);//prescaller ustawiony na 1 na kanale OC1A i OC1B
////////////////////////////////TIMER2/8bit////////Phase Correct mode 1///////////////////////
TCCR2A |= (1<<COM2A1)|(1<<WGM20);
TCCR2B |= (1<<CS20);//prescaller ustawiony na 1 OC2A

//////////////////////////TIMER0//////////CTC co 1ms///////////////////////
//
TCCR0A |= (1<<WGM01);
TCCR0B |= (1<<CS02)|(1<<CS00); //preskaler ustawiony na 1024//speed = F_CPU/1024

TIMSK0 |= (1<<OCIE0A); // enable interrupt for timer match a
OCR0A =16;// 1 ms interrupt at 16MHz


//////////////////////TIMER0//////////CTC co 10ms///////////////////////

// TCCR0A |= (1<<WGM01);
// TCCR0B |= (1<<CS02)|(1<<CS00); //preskaler ustawiony na 1024//speed = F_CPU/1024
//
// TIMSK0 |= (1<<OCIE0A); // enable interrupt for timer match a
// OCR0A =159;// 10 ms interrupt at 16MHz

}
FRESULT FatFS_Write(FIL *File, char *Nazwa, DWORD Przesuniecie,char *Data, UINT IleBajtow, uint8_t Mode)
{
UINT bw; // zapisanych bajtow
FRESULT res; // rezultat funkcji

res = f_open(File, Nazwa, Mode); // Otwiera plik
if(res == FR_OK)
{
res = f_lseek(File, Przesuniecie); // Ustawia wskaznik zapisu do pliku w odpowiednim miejscu
if(res == FR_OK)
{
res = f_write(File, Data, IleBajtow, &bw); // Zapisz bajtow do pliku
if(res == FR_OK)
{
res = f_close(File); // Zamkyka plik
}
}
}

return res; // rezultat funkcji
}
void init_spi(void)
{
DDRB |= (1<<CS)|(1<<MOSI)|(1<<SCK);// piny SPI jako wyjścia
DDRA |= (1<<LT); // zatrzask

PORTB|= (1<<CS);

_delay_ms(100);

//SPCR |= (1<<SPE)|(1<<MSTR)|(1<<SPR1)|(1<<SPR0); //włącz SPI// ustaw na Master// fosc/128 125kHz
SPCR |= 0x52; //włącz SPI// ustaw na Master// fosc/64 250kHz
}
void sdcard_init(void)
{
res = disk_initialize(0); // Inicjalizacja karty SD
if(res != 0) // Jezeli inicjalizacja sie nie powiodla
{
_delay_ms(100);
LCD_GoTo(0,1);
LCD_WriteText("************SD INIT ERROR*************");
_delay_ms(100);
LCD_Clear();
}
else // Jesli sie powiodla
{
f_mount(&FatFs[0], Line, 0);

if(res != 0) // Jesli montowanie sie nie powiodlo
{
_delay_ms(100);
LCD_GoTo(0,1);
LCD_WriteText("************SD MOUNT ERROR*************");
_delay_ms(100);
LCD_Clear();
}
else // Jesli sie powiodlo
{
_delay_ms(100);
LCD_GoTo(0,1);
LCD_WriteText("*************SD CARD OK*************");
_delay_ms(100);
LCD_Clear();
}
}
}

int main (void)
{

FATFS FS;
FIL FIL;

ovfbuf1=0;
ovfbuf2=0;
ovfbuf3=0;
ovfbuf4=0;
adc_ovfbuf1=0;
adc_ovfbuf2=0;
adc_ovfbuf3=0;
adc_ovfbuf4=0;
zapiszdobuforanr=0;
recflag=0;
recstart=0;
lcdonoff=1;// WŁĄCZ (1) WYŁĄCZ (0) LCD REJESTR i KLAWISZE
RTC rtc;


ioinit();
timery();
init_spi();
LCD_Initalize();
Przerywania();
init_adc();
sdcard_init();

if (rtc_init() && rtc_gettime(&rtc)) {/* Initialize RTC */
RtcOk = 1;
//xprintf(PSTR("Current time: %u/%u/%u %02u:%02u:%02u\n"), rtc.year, rtc.month, rtc.mday, rtc.hour, rtc.min, rtc.sec);
} else {
//xputs(PSTR("RTC is not available.\n"));
}

_delay_ms(500);
LCD_Clear();
sei();

while(1)
/////////////////////////////////////////PETLA GLOWNA PROGRAMU/////////////////////////////////////////////
{

lcdonoff=1;// WŁĄCZ WYŁĄCZ LCD REJESTR i KLAWISZE

if(!(PINA & (1<<PA3)))// Rozpoczęcie rejestrowania
{
_delay_ms(100);

if (recstart==1)
{
recstart=0;
}
else if(recstart==0)
{
recstart++;
}
_delay_ms(100);
}

if(recstart==1)
{
zapis();
recflag=1;
}
if(recstart==0)
{
recflag=0;
}

//////////////////////////////////////////////WYŚWIETLACZ 4x40////////////////////////////////////

LCD_GoTo(0,0);
LCD_WriteText("rec= ");
itoa(Wiersz,wiersz_char,10);
LCD_GoTo(6,0);
LCD_WriteText(wiersz_char);


/////////////////////////////////////////////////E2///////////////////////////////////////////
LCD_GoTo(0,2);
LCD_WriteText("ADC0= ");
itoa(adc0,adc0_char,10);
LCD_GoTo(6,2);
LCD_WriteText(adc0_char);

LCD_GoTo(10,2);
LCD_WriteText("ADC1= ");
itoa(adc1,adc1_char,10);
LCD_GoTo(16,2);
LCD_WriteText(adc1_char);

LCD_GoTo(20,2);
LCD_WriteText("ADC2= ");
itoa(adc2,adc2_char,10);
LCD_GoTo(26,2);
LCD_WriteText(adc2_char);

// LCD_GoTo(30, 2);
// LCD_WriteText("ADC3= ");
// itoa(adc3,adc3_char,10);
// LCD_GoTo(36, 2);
// LCD_WriteText(adc3_char);

LCD_GoTo(0,3);
LCD_WriteText("ADC4= ");
itoa(adc4,adc4_char,10);
LCD_GoTo(6,3);
LCD_WriteText(adc4_char);

LCD_GoTo(10,3);
LCD_WriteText("ADC5= ");
itoa(adc5,adc5_char,10);
LCD_GoTo(16,3);
LCD_WriteText(adc5_char);

LCD_GoTo(20,3);
LCD_WriteText("ADC6= ");
itoa(adc6,adc6_char,10);
LCD_GoTo(26,3);
LCD_WriteText(adc6_char);

// LCD_GoTo(30, 3);
// LCD_WriteText("ADC7= ");
// itoa(adc7,adc7_char,10);
// LCD_GoTo(36, 3);
// LCD_WriteText(adc7_char);

}//pentla for


}//main


ISR(ADC_vect)
{

if (recflag==1)
{

if(zapiszdobuforanr==2)
{
adc_test=2;
////////////////////////////////////////zapis do bufora 2///////////////////////////////////////
if (adc_wskbuf2<=ADCBUFSIZE)
{
adc_bufor2[adc_wskbuf2++] = adc0;//0
adc_bufor2[adc_wskbuf2++] = adc1;//1
adc_bufor2[adc_wskbuf2++] = adc2;//2
adc_bufor2[adc_wskbuf2++] = adc4;//3
adc_bufor2[adc_wskbuf2++] = adc5;//4
adc_bufor2[adc_wskbuf2++] = adc6;//5
adc_bufor2[adc_wskbuf2++] = adc_test;//6

}
else
{
adc_ovfbuf2=1;
adc_wskbuf2=0;

}
}
if(zapiszdobuforanr==1)
{
adc_test=1;
////////////////////////////////////////zapis do bufora 1/////////////////////////////////////////
if (adc_wskbuf1<=ADCBUFSIZE)
{
adc_bufor1[adc_wskbuf1++] = adc0;//0
adc_bufor1[adc_wskbuf1++] = adc1;//1
adc_bufor1[adc_wskbuf1++] = adc2;//2
adc_bufor1[adc_wskbuf1++] = adc4;//3
adc_bufor1[adc_wskbuf1++] = adc5;//4
adc_bufor1[adc_wskbuf1++] = adc6;//5
adc_bufor1[adc_wskbuf1++] = adc_test;//6
}
else
{
adc_ovfbuf1=1;
adc_wskbuf1=0;

}

}
else if(zapiszdobuforanr==3)
{
adc_test=3;
////////////////////////////////////////zapis do bufora 3/////////////////////////////////////////
if (adc_wskbuf3<=ADCBUFSIZE)
{
adc_bufor3[adc_wskbuf3++] = adc0;//0
adc_bufor3[adc_wskbuf3++] = adc1;//1
adc_bufor3[adc_wskbuf3++] = adc2;//2
adc_bufor3[adc_wskbuf3++] = adc4;//3
adc_bufor3[adc_wskbuf3++] = adc5;//4
adc_bufor3[adc_wskbuf3++] = adc6;//5
adc_bufor3[adc_wskbuf3++] = adc_test;//6

}
else
{
adc_ovfbuf3=1;
adc_wskbuf3=0;

}


}
else if(zapiszdobuforanr==4)
{
adc_test=4;
////////////////////////////////////////zapis do bufora 4/////////////////////////////////////////
if (adc_wskbuf4<=ADCBUFSIZE)
{
adc_bufor4[adc_wskbuf4++] = adc0;//0
adc_bufor4[adc_wskbuf4++] = adc1;//1
adc_bufor4[adc_wskbuf4++] = adc2;//2
adc_bufor4[adc_wskbuf4++] = adc4;//3
adc_bufor4[adc_wskbuf4++] = adc5;//4
adc_bufor4[adc_wskbuf4++] = adc6;//5
adc_bufor4[adc_wskbuf4++] = adc_test;//6
}
else
{
adc_ovfbuf4=1;
adc_wskbuf4=0;

}


}
}
else if(recflag==0 & zapiszdobuforanr==0)
{
adc_test=0;
////////////////////////////////////////zapis do bufora 1/////////////////////////////////////////

if (adc_wskbuf1<=ADCBUFSIZE)
{
adc_bufor1[adc_wskbuf1++] = adc0;//0
adc_bufor1[adc_wskbuf1++] = adc1;//1
adc_bufor1[adc_wskbuf1++] = adc2;//2
adc_bufor1[adc_wskbuf1++] = adc4;//3
adc_bufor1[adc_wskbuf1++] = adc5;//4
adc_bufor1[adc_wskbuf1++] = adc6;//5
adc_bufor1[adc_wskbuf1++] = adc_test;//6

}
else
{
adc_ovfbuf1=1;
adc_wskbuf1=0;

}

}


/////////////////////////////////////////////////////////
switch (channel) // wybór kanału do odczytu ADC
{

/////////////////////////////////////////////////////////////////////////////////////////////////////////////
case (1): // ADC0

ADMUX = (1<<ADLAR) |(1<<REFS0)| channel; //Ustawianie nowych wartości

do
{
adc0 = ADCH;
}
while(ADCSRA & (1<<ADSC)); // SPRAWDZENIE CZY JUŻ SIĘ SKOŃCZYŁO

break;
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
case (2): // ADC1

ADMUX = (1<<ADLAR) |(1<<REFS0)| channel; //Ustawianie nowych wartości
do
{
adc1 = ADCH;
}
while(ADCSRA & (1<<ADSC)); // SPRAWDZENIE CZY JUŻ SIĘ SKOŃCZYŁO


break;
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
case (3): // ADC2

ADMUX = (1<<ADLAR) |(1<<REFS0)| channel; //Ustawianie nowych wartości
do
{
adc2 = ADCH;
}
while(ADCSRA & (1<<ADSC)); // SPRAWDZENIE CZY JUŻ SIĘ SKOŃCZYŁO


break;
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

case (4): // ADC3

ADMUX = (1<<ADLAR) |(1<<REFS0)| channel; //Ustawianie nowych wartości

do
{
adc3 = ADCH;
}
while(ADCSRA & (1<<ADSC)); // SPRAWDZENIE CZY JUŻ SIĘ SKOŃCZYŁO


break;
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

case (5): // ADC4

ADMUX = (1<<ADLAR) |(1<<REFS0)| channel; //Ustawianie nowych wartości

do
{
adc4 = ADCH;
}
while(ADCSRA & (1<<ADSC)); // SPRAWDZENIE CZY JUŻ SIĘ SKOŃCZYŁO

break;
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

case (6): // ADC5

ADMUX = (1<<ADLAR) |(1<<REFS0)| channel; //Ustawianie nowych wartości

do
{
adc5 = ADCH;
}
while(ADCSRA & (1<<ADSC)); // SPRAWDZENIE CZY JUŻ SIĘ SKOŃCZYŁO

break;

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

case (0): // ADC6

ADMUX = (1<<ADLAR) |(1<<REFS0)| channel; //Ustawianie nowych wartości
do
{
adc6 = ADCH;
}
while(ADCSRA & (1<<ADSC)); // SPRAWDZENIE CZY JUŻ SIĘ SKOŃCZYŁO

break;

}

if(channel<6)
channel++;
else
channel=0;

ADCSRA |= _BV(ADSC); // start konwersji
}

ISR(TIMER0_COMPA_vect)
{ //powinno być co 10ms

Timer++;
disk_timerproc();
}[/syntax]

Bardzo proszę o pomoc w przeanalizowaniu problemu.
Z góry bardzo dziękuję za chęć pomocy i poświęcony czas.

Statystyki: Napisane przez Payfer — 16 wrz 2014, o 18:40

]]> 2014-07-17T20:12:51+01:00 2014-07-17T20:12:51+01:00 https://forum.atnel.pl/viewtopic.php?t=7793&p=87941#p87941 <![CDATA[Re: Rejestrator ADC Atmega 1284P - problem z zapisem na SD]]> Payfer napisał(a):

Mam wrażenie, że przerywania (od ADC) za szybko zapełniają bufory.

Atmega 1284 ma 16KB pamięci RAM możesz zwiększyć liczbę buforów. Problemem może być długi zapis bufora na kartę. Nie chodzi mi tutaj o sam fakt wysłania przez SPI, ale o fizyczny zapis w pamięci Flash karty SD: http://elm-chan.org/docs/mmc/mmc_e.html

Payfer napisał(a):

Kiedy zapisywać dane do buforów i gdzie najlepiej to wykonywać czy w przerywaniach czy w pętli głównej?
W przerwaniach. To krótka operacja.
Payfer napisał(a):

Jeśli w przerywaniach to: Czy zapełnianie bufora 1 i 2 mam wykonywać w przerywaniach od ADC czy np od Timera?
W przerwaniu ADC. Skoro wynik jest gotowy to należy go skopiować.
Payfer napisał(a):

Czy przetwornik ADC powinien być ustawiony w tryb Free Running Mode?(gdzieś na forach znalazłem taką podpowiedź)
W trybie Free Running osiągniesz najwyższe prędkości, ale nie masz wtedy dokładnego sterowania co ile zrobić pomiar. Można wykorzystać tryb CTC timera, który będzie wyzwalał pomiar. Przykładowy kod niezwiązany z tematem takiego ustawienia:
[syntax=c]#define S_Freq 44100 //sampling frequency min 9,8kHz max 46,3kHz

void adc_init(void)
{
//ADC
ADMUX |= (1<<REFS0) | (1<<ADLAR); //AREF=AVCC, Left Adj.,ADC0
ADCSRA |= (1<<ADEN) | (1<<ADATE) | (1<<ADIE) | (1<<ADPS2) | (1<<ADPS0);
//enable ADC, Auto Trigger ADC, ADC interrupt, prescaler 32 (20MHz/32=625kHz )
//625k/13.5=46,3k
ADCSRB |= (1<<ADTS1) | (1<<ADTS0); //Timer0 Compare Match will trigger ADC
DIDR0 |= (1<<ADC0D);

//Timer0
TCCR0A |= (1<<WGM01); //CTC mode
OCR0A = F_CPU/8/S_Freq;
TCCR0B |= (1<<CS01); //clk/8, start timer0
}[/syntax]
Payfer napisał(a):

Myślałem również nad buforami kołowymi i kolejkach FIFO....ale nie wiem czy w moim przypadku jest to konieczne.
To się tutaj nie nadaje. Do zapisu na kartę potrzebujesz blok danych i bufory to dobre rozwiązanie. FIFO mógłbyś wykorzystać do ciągłego wysyłania tych pomiarów na port szeregowy.

Statystyki: Napisane przez Krauser — 17 lip 2014, o 20:12

]]> 2014-07-17T10:57:49+01:00 2014-07-17T10:57:49+01:00 https://forum.atnel.pl/viewtopic.php?t=7793&p=87881#p87881 <![CDATA[Rejestrator ADC Atmega 1284P - problem z zapisem na SD]]>
Buduję rejestrator ADC z zapisem/odczytem na kartę SD.Układ oparty jest na procesorze Atmega 1284P. Taktowany jest zewnętrznym kwarcem 16MHz. Cały układ pracuje na napięciu 5V poza kartą SD (zasilanie 3.3V + 74LCV125D). Od strony elektronicznej-hardware'owej wszystko pracuje prawidłowo, problemem jest oprogramowanie.

Urządzenie składa się z wyświetlacza, potencjometrów (ADC), przycisków zrobionych na drabince rezystorów oraz podświetlania przycisków za pomocą diód led.
Wyświetlacz 4x40 i podświetlanie przycisków mam zrobione na 3 rejestrach przesuwnych. Dane wysyłam za pomocą sprzętowego SPI.

Na sprzętowym SPI mam również podłączoną kartę SD, na którą chciałbym zapisywać dane.
Na karcie SD chciałbym rejestrować sygnał z 5 kanałów ADC w krótkich odstępach czasowych( np. co 1ms – zależy mi na dokładności) i zapisywać je na karcie SD w formacie .csv. Później chciałbym te dane odtwarzać i sterować wypełnieniem wyjść PWM z taką samą prędkością jak zapis nie zakłócając tym samym pracy wyświetlacza, czy też podświetlania klawiszy.

Udało mi się zainicjować bibliotekę FatFS od Elm-chana. Przetestowałem ją i działa mi zapis na kartę, jak również odtwarzanie na przykładzie ze strony elm-chana z konsolą po RS232.

Poradziłem sobie z odpaleniem wszystkiego razem, działającym przełączaniem kanałów SPI, LCD przyciski itp.
Wszystko działa poza poprawnością zapisu z buforów na kartę.

Szczegółowe założenia jakimi się kierowałem:
Chciałbym zapisywać wartości poszczególnych kanałów adc w przerywaniach ADC do buforów. Gdy skończy się zapis danych z kanałów adc do bufora 1 rozpoczyna się zapis na kartę SD z bufora 1 i w trakcie zapisu na kartę wykonywany jest zapis wartości adc do bufora 2. Gdy skończy się zapis na kartę SD z bufora 1 następuje zapis na kartę z bufora 2 oraz zapis wartości z adc do bufora 1. No i tak w kółko dzięki ustawianiu odpowiednich flag o przepełnieniu bądź o zezwoleniu na zapełnianie się poszczególnych buforów.
W tym celu stworzyłem przykładową ramkę danych buforów o rozmiarze 512 w których zapisywane mają być wiersze/pomiary - (493 komórki) wyglądające w następujący sposób:

Obrazek

Aktualnie zapis działa jednak w taki sposób, że gdy kręcę potencjometrem wartości adc zmieniają się w zapisie co 17 wierszy (czyli co bufor) skokowo choć czasem zdarzy się zapis różnych wartrości w 17 pomiarach w buforze 1 lub 2 . Chciałbym uzyskać w poszczególnych wierszach bufora również wartości pomiędzy tymi skokami. Poniżej przykład zapisywanych danych obecnie:

Obrazek

ADC mam ustawione następująco:
[syntax=c]ADCSRA |= ((1<<ADPS2)|(1<<ADPS1)|(1<<ADPS0)); //16Mhz/128 = 125Khz the ADC reference clock
ADCSRA |= (1 << ADEN); // Włączenie ADC
ADCSRA |= (1 << ADIE); // Załączenie przerywania
ADCSRA |= (1 << ADSC); // Rozpoczęcie konwersji A2D
ADMUX |= (1 << REFS0); // Ustawienie Napięcia do AVCC
ADMUX |= (1 << ADLAR); // Justowanie do lewej[/syntax]
Pomiędzy kanałami ADC przełączam się po przez funkcję switch(channel) w przerywaniach od ADC. Przełączanie i zapisywanie do zmiennych adc0,adc1,adc2...itd działa poprawnie.

Mam wrażenie, że przerywania (od ADC) za szybko zapełniają bufory.
Zależy mi na zapisie ok 1000 wierszy danych na sekundę lub więcej nie tracąc wartości pośrednich tak jak dzieje mi się teraz.

Proszę Was o odpowiedz na pytania:
Kiedy zapisywać dane do buforów i gdzie najlepiej to wykonywać czy w przerywaniach czy w pętli głównej?
Jeśli w przerywaniach to: Czy zapełnianie bufora 1 i 2 mam wykonywać w przerywaniach od ADC czy np od Timera?
Czy przetwornik ADC powinien być ustawiony w tryb Free Running Mode?(gdzieś na forach znalazłem taką podpowiedź)
Myślałem również nad buforami kołowymi i kolejkach FIFO....ale nie wiem czy w moim przypadku jest to konieczne.


Bardzo proszę o wskazówki i pomoc.
P.S.
Przeglądałem projekt Pana Mirka - Wav recordera i wiem, że prędkość z częstotliwością 1kHz jest jak najbardziej osiągalna.

Statystyki: Napisane przez Payfer — 17 lip 2014, o 10:57

]]>