Re: FatFS, buforowanie danych z ADC

2014-04-14T22:34:55+01:00

markaj napisał(a):

czy wtedy konwersja tak dużej ilości danych nie spowolni samej procedury zapisu?

Tak czy siak musisz tą konwersję wykonać, a nie widzę powodu dla którego musiałaby się odbywać w przerwaniu (przechowywanie wartości w stringu zwiększa jedynie zajętość pamięci; konwersja w przerwaniu wydłuża je, mogąc powodować przerwanie jakiejś ważnej operacji w głównej pętli na zbyt długo - konwertując poza przerwaniem masz możliwość kontroli tego).

markaj napisał(a):

jak zatem wyznaczyć poziom zajętości bufora? czekać do jego całkowitego wypełnienia?

Temat przecież powstał między innymi dlatego, że nowe dane nadlatują Ci zanim zwolnisz dla nich miejsce... bufor musi mieć więc rozmiar (co najmniej) zapisywanej paczki + rozmiar danych które nadlecą podczas zapisywania tejże paczki.

markaj napisał(a):

jakiej wielkości bufor pozwoli na uzyskanie jak największej częstotliwości próbkowania

Na AVRach jest to bez znaczenia. Znaczenie za to ma sposób w jaki go oprogramujesz.

markaj napisał(a):

czytałem, że zapis do karty SD odbywa się całymi sektorami po 512 Mbajtów. czy z tego wynika, taką wielkość powinno się stosować?

Nie Mbajtów, a bajtów. I nie 512, a co najmniej 512. Warto to stosować, o ile jesteś w stanie zapewnić, że zapisywane dane o wielkości sektora nie będą rozłożone pomiędzy 2 sektorami.

Statystyki: Napisane przez barney — 14 kwi 2014, o 22:34

Re: FatFS, buforowanie danych z ADC

2014-04-14T21:18:47+01:00

Dzięki za odpowiedź

czyli sugerujesz, żeby jednak dane z bufora konwertować na string w pętli głównej po przekroczeniu jakiegoś poziomu zajętości? konwersja pojedynczej wartości za pomocą funkcji itoa jest stosunkowo prosta. ale jakie podejście przyjąć przy całej tablicy liczb? zastosować do tego pętlę for? czy wtedy konwersja tak dużej ilości danych nie spowolni samej procedury zapisu? jak zatem wyznaczyć poziom zajętości bufora? czekać do jego całkowitego wypełnienia? jakiej wielkości bufor pozwoli na uzyskanie jak największej częstotliwości próbkowania. czytałem, że zapis do karty SD odbywa się całymi sektorami po 512 Mbajtów. czy z tego wynika, taką wielkość powinno się stosować?

Statystyki: Napisane przez markaj — 14 kwi 2014, o 21:18

Re: FatFS, buforowanie danych z ADC

2014-04-14T20:54:12+01:00

markaj napisał(a):

Zatem czy takie wywołanie się przerwania w trakcie zapisu nie powoduje, że zapis jest w pewien sposób zaburzony? Kolejne pytanie dotyczy możliwości tracenia próbekz ADC. Czy zastosowanie 2 buforów rozwiązuje ten problem? Jeśli tak, to jak mniej więcej zabrać się za ich implementację?

Nie wiem jak pewne rzeczy są w libsie Elm-Chana zrealizowane, ale operując na niższej warstwie (tzn. bezpośrednio na sektorach karty) zrealizowałbym zapis tworząc w RAMie AVRa bufor FIFO z którego dane są ściągane (zapisywane na kartę) po przekroczeniu rozmiaru sektora.

Pewnie nie masz takich możliwości, więc zrób sobie bufor FIFO do przechowywania wartości dwójkowo, a konwersji na stringa i zapisu dokonuj dopiero po przekroczeniu jakiegoś poziomu zajętości bufora.

Swoją drogą, to jeżeli zaimplementujesz obsługę karty w odpowiedni sposób, to możesz sobie wysyłać bit po bicie z dowolnie długimi przerwami między nimi

Statystyki: Napisane przez barney — 14 kwi 2014, o 20:54

Re: FatFS, buforowanie danych z ADC

2014-04-14T20:22:48+01:00

dobrze, poprawiłem znaczniki kodu, mam nadzieję, że teraz ktoś się odezwie:)

Statystyki: Napisane przez markaj — 14 kwi 2014, o 20:22

FatFS, buforowanie danych z ADC

2014-04-14T14:37:46+01:00

Witam wszystkich serdecznie:)

Od dłuższego czasu pracuję nad prototypem elektronicznego stetoskopu, który dokonuje akwizycję danych pomiariwych na karcie SD.
W związku z tym, że interesujące mnie pasmo dochodzi do 500Hz, częstotliwość próbkowania jaką muszę uzyska to minimum 1kHz.Wykorzystuję Atmegę 328p.Prcuję zatem nad biblioteką FatFS i odpowiednim systemem buforowania próbek pochodzących z ADC. Póki co staram się zaimplementować1 bufor lecz w domyśle, ostatecznie planuję zastosować 2 bufory. Bardzo proszę o zweryfikowanie mojej koncepcji. Zdefiniowałem sobie funkcję, która zwraca ilość cyfr podanych jako argumet i zastosowałem ją w obsłudze przerwania, aby przesunąć wskaźnik o odpowiednią ilość miejsc w moim buforze.Doszedłem bowiem do wniosku, że biblioteczna funkcja itoa (wykorzystywana w celu skonwertowania danych z ADC do stringa) nie zwraca wskaźnika do ostatniego miejsca w tablicy, do której wpisuje pomiary. Wydaje mi się jednak, że stosowanie funkcji operującej na stringach w przerwaniu może nie być dobrym pomysłem.W obsłudze przerwania zewnętrznego dokonuję prymitywnego multipleksowania kanału ADC, ponieważ projekt zakłada podawanie na analogowy filtr przestrajany częstotliwością fali prostokątnej generowanej w trybie CTC. Wartość podawana z potencjometrudeterminuje zatem cutoff filtra dolnoprzepustowego. Nie wiem również jakiej wielkości bufor zastosować, żeby nie zaśmiecić zbytnio pamięci RAM. W trybie podawania częstotliwości odcięcia przetwornik działa poprawnie. Natomiast w trybie zapisu danych na SD na wyświetlaczu LCD widoczne są zmienne wartości. Natomiast na karcie w tym czasie zapisuje się w zasadzie stała wartość, ok 380. Przetwornik jest skonfigurowany w trybie free running mode. Dane chcę zapisywać w postaci kolumny, żeby móc sobie wygenerować od razu plik .csv. Mam też wątpliwości co do samego działania zapisu w momencie wywołania przerwania od ADC. Wydaje mi się, że czas obsługi tego przerwania powinien być krótszy niż sama procedura zapisu na SD. Zatem czy takie wywołanie się przerwania w trakcie zapisu nie powoduje, że zapis jest w pewien sposób zaburzony? Kolejne pytanie dotyczy możliwości tracenia próbekz ADC. Czy zastosowanie 2 buforów rozwiązuje ten problem? Jeśli tak, to jak mniej więcej zabrać się za ich implementację? Przepraszam za dużą ilość zakomentowanych linii i ewentualną nieczytelność ale to jest bardzo robocza wersja kodu. Jeśli coś wymaga dokładniejszego wyjaśnienia to oczywiście postaram się sprecyzować o co chodzi. Będę bardzo wdzięczy za wszelkie sugestie i pomoc.

Pozdrawiam:)

[syntax=c]#include
#include
#include
#include
#include
#include
#include "LCD/HD44780.h"
#include "ADC/ADC_Handle.h"
#include "generator/generator.h"
#include "FatFs/ff.h"

// deklaracja funkcji obliczającej ilosc cyfr
static inline unsigned int digit_num(unsigned int num);

//potrzebne do FsFat

typedef struct {
WORDyear;/* 2000..2099 */
BYTEmonth;/* 1..12 */
BYTEmday;/* 1.. 31 */
BYTEwday;/* 1..7 */
BYTEhour;/* 0..23 */
BYTEmin;/* 0..59 */
BYTEsec;/* 0..59 */
} RTC;

DWORD get_fattime ()
{
RTC rtc;

/* Get local time */
//rtc_gettime(&rtc);
rtc.year = 2010;
rtc.month = 10;
rtc.mday = 21;
rtc.hour = 17;
rtc.min = 45;
rtc.sec = 0;

/* 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);

}

//zmienne do obslugi FatFs

char file_name[] = "test.csv";
char bufor[4];

//zmienne do obsługi przerwań

volatile long unsigned int luiPressButtonCounter = 0;// zmienna sterująca programem, naprzemienny tryb ustawinia częstotl. i zapisu
volatile int adc;
volatile int adc1;
volatile unsigned char kanal = 1;
char buff1[128];
//char buff2[64];
char* p_buff_write = buff1;
//volatile char buff_used = 1; // zmienne do 2 buforów
//volatile char buff_finish = 0;//

//funkcja glowna

int main(void) {

// zmienne do obslugi FatFs

BYTE res;
UINT s1;
FATFS fs;
FIL fat;

//zmienne do obslugi LCD

char wy[4];//bufor wyniku - 4bit tablica - zapis decymalny
long wynik; //zmienna z wynikiem po konwersji

// Inicjalizacja SPI

#define SCK PB5
#define MOSI PB3
#define MISO PB4
#define CS PB0

DDRB = (1<SPCR = (1<

// Inicjalizacja przerwania zewnetrznego INT1 falling

EICRA |= (1<EIMSK |= (1<

//inicjalizacja LCD

LCD_Initalize();
LCD_Home(); //Ustawienie kursora w pozycji (0,0)
LCD_WriteText("Start!");
_delay_ms(2000);
LCD_Clear();

//Inicjalizacja ADC

ADCSRA |= (1< ADCSRA |= (1< ADCSRA |= (1< ADMUX |= (1< ADMUX &= ~0x07;// maskowanie 3 bitów
ADMUX |= kanal; // kanal 4 do czestotliwosci na wejsciu programu
ADCSRA |= (1< ADCSRA |= (1< DDRC &=~ (1< DDRC &=~ (1< ADCSRB &= ~(1< ADCSRB &= ~(1< ADCSRB &= ~(1<

//Inicjalizacja generatora

generator_setup(15,1); // z biblioteki generator.h

// globalne odblokowanie przerwan

sei();

//petla glowna

while(1)
{

if(luiPressButtonCounter%2 == 0){

wynik = map(adc1, 0, 1023, 2000, 50000); //konwersja wyniku ADC do danego przedzialu

set_frequency(wynik, 1); // ustawienie cut off filtra

LCD_Clear();
LCD_Home();
LCD_WriteText("Freq:");
LCD_GoTo(0, 1); //Ustawienie kursora w pozycji (0,1)
LCD_WriteText(" "); //kasowanie poprzedniej wartosci
itoa(wynik/100,wy,10); //konwersja wyniku do tablicy char - biblioteka stdlib
LCD_GoTo(0, 1); //Ustawienie kursora w pozycji (0,1)
LCD_WriteText(wy); //Wyświetlenie wyniku
_delay_ms(100);//opóźnienie
LCD_Clear();
}

else {

itoa(adc1, buff1, 10);

LCD_Home();
LCD_WriteText("Zapis");
LCD_GoTo(0,1);
LCD_WriteText(" ");
LCD_GoTo(0,1);
LCD_WriteText(buff1);// wypisanie częstotliwoci na LCD

//zapis na SD

res = f_mount(0,&fs);

if(res == FR_OK) {
res = f_open(&fat, file_name, FA_OPEN_ALWAYS | FA_WRITE);

if(res == FR_OK) {

f_lseek(&fat, fat.fsize);
uint16_t bytes_count = 123;//(uint32_t)p_buff_write - (uint32_t)buff;

//if(buff_used == 1) p_buff_ready = buff2; // do 2 buforów
//else p_buff_ready = buff1;
res = f_write(&fat, buff1, bytes_count, &s1);
//f_lseek(&fat, fat.fsize);
f_close (&fat);
f_mount(0,NULL);
//buff_finish = 1;

}

}

}

}
}

ISR(INT0_vect){

luiPressButtonCounter++;//inkrementacja licznika do sterowania programem
if(kanal == 1) kanal = 0;//zmiana kanalu ADC
else kanal=1;

ADMUX &= ~0x07; //maskowanie 3 bitow rejestru
ADMUX |= kanal; // ustawienie kanalu 4 lub 5

}

ISR(ADC_vect){

static unsigned int count_tab;
unsigned int offset; // przesunięcie wskaźnika w buforze
adc1 = ADC;
static int g;
char *pc;
//if(g<24) { //~128/5 -> zapis po max 5 znaków - chyba zły pomysł
adc=(unsigned int)adc1;

if(count_tab<5) {

offset = digit_num(adc1);
itoa(ADC, p_buff_write, 10);

//}

static int licznik;
//pc = itoa(licznik, p_buff_write, 10);
licznik++;
count_tab++;
//p_buff_write += 4;
p_buff_write += offset;
*(p_buff_write++) = '\0';
g++;
}

//else g=0; //{

//g=0;
//buff_finish = 0;
/*if(buff_used == 1) {
p_buff_write = buff2;
buff_used = 2;
}

else {

p_buff_write = buff1;
buff_used = 1;
}*/
//}

}

static inline unsigned int digit_num(unsigned int num) {

unsigned int temp = num;
unsigned int counter = 0;

while(temp) {

counter++;
temp/=10;
}

if(counter==0) return 1;
else return counter;

}[/syntax]

Kody źródłowe umieszczamy w znacznikach synax=c, bez odbioru! //kila

Statystyki: Napisane przez markaj — 14 kwi 2014, o 14:37

ATNEL tech-forum

Re: FatFS, buforowanie danych z ADC

Re: FatFS, buforowanie danych z ADC

Re: FatFS, buforowanie danych z ADC

Re: FatFS, buforowanie danych z ADC

FatFS, buforowanie danych z ADC