Przeszukaj forum

Tak jak w tytule plus dodatkowe pytanie, wytłumaczę na podstawie kodu. Mam pamięć która przechowuje parametry transmisji zapisane jako csv (świadomie zrezygnowałem z JSON) następnie po zainstalowaniu systemu plików i odnalezieniu tego z parametrami "reg1.txt"[będzie .csv] robię dwie rzeczy: zliczam ile jest linii(wierszy) w pliku i przesyłam kolejne wiersze do funkcji dekodującej. while ((d = readdir(dh)) != NULL) { printf("DIR %s\n", d->d_name); if(0 == (strcmp(d->d_name,"reg1.txt"))) { FILE * f = fopen("/usb/reg1.txt", "r"); char line[128]; int l = 0; if(mdbTask != NULL){ vTaskSuspend(mdbTask); while(fgets(line, sizeof(line), f)) //where sizeof(buf) is the length of //line you anticipate reading in. { //do something with buf here; //The input of fgets will be NULL as soon //as its input fp has been fully read, then exit the loop l++; } decode_csv(NULL,l); FILE * f = fopen("/usb/reg1.txt", "r"); // printf("test1\n"); while(fgets(line, sizeof(line), f)) //where sizeof(buf) is the length of { decode_csv(line, 0); } Pierwsze otwarcie pliku ma na celu zliczenie linii, jest to później potrzebne gdyż stosuję dynamiczną alokację pamięci. Problem był kiedy chciałem przesłać do funkcji "decode_csv" kolejne linie z pliku. Poradziłem sobie przypisując ponownie wskaźnik file * f nie jestem pewien czy to prawidłowe rozwiązanie? Ewentualnie czy istnieje inny sposób na zliczenie wierszy w pliku tekstowym? Poniżej plik na którym testuję U1,1,4,2,0,1,V I1,1,4,2,6,1,A P1,1,4,2,18,1,W

Cześć, zapewne wielu z was miało problem z obsługą równolegle w czasie kiklu zadań pisząc program dla Arduino. Często mamy zadania typu zbieranie danych z czujników, wyświetlanie ich na wyświetlaczu LCD, sterowania serwo-mechanizmami itp. Jak było to wyjaśnione w drugiej części kursu Arduino można taką pseudo-równoległą obsługę kilku zadań oprogramować za pomocą funkcji millis() - nie jest to niestety prawdziwa wielozadaniowość. Dla trochę mocniejszych MCU (ESP32 i STM32xx) możemy użyć prawdziwego RTOS'a do obsługi wielozadaniowośći. Dla przykładu w obsłudze "Board" dla ESP32 w ArduinoIDE jest osadzony "Free RTOS". Jednakże dla np. płytki "Arduino UNO R3" "Free RTOS" zajmuje za dużo zasobów, aby można go użyć. Jaki więc jest rozwiązanie dla płytek z małymi MCU AVR (np. Atmega328 lub Atmega 324)? Ostatnio natrafiłem na bardzo fajny projekt o nazwie RIOS - jest to scheduler tasków napisany w języku C i zajmujący tak mało zasobów, że może być używany na małych MCU AVR (np. na płytce Arduino UNO). Tutaj linki do strony domowej projektu i portu RIOS dla AVR: https://www.cs.ucr.edu/~vahid/rios/ https://www.cs.ucr.edu/~vahid/rios/rios_avr.htm A tutaj link do filmu o RIOS na Youtube: Postanowiłem wypróbować jak będzie działał RIOS na płytce Arduino UNO R3. Wypróbowałem kod z drugiego podanego linku (wersja schedulera preemptive). Kod został zmodyfikowany tak aby każdy z trzech użytych tasków migał z osobna diodą LED (zielona LED - okres 0.4s, czerwona 1s, żółta 2 s). Tutaj kod zmodyfikowanego kodu dla Arduino UNO (sketch dla Arduino IDE): #include <avr/io.h> #include <avr/interrupt.h> #include <math.h> #define F_CPU 8000000UL #include <util/delay.h> typedef struct task { unsigned char running; // 1 indicates task is running int state; // Current state of state machine unsigned long period; // Rate at which the task should tick unsigned long elapsedTime; // Time since task's previous tick int (*TickFct)(int); // Function to call for task's tick } task; task tasks[3]; const unsigned char tasksNum = 3; const unsigned long tasksPeriodGCD = 25; const unsigned long period1 = 400; //okres 0.4s const unsigned long period2 = 1000;//okres 1s const unsigned long period3 = 3000;//okres 3s int TickFct_1(int state); int TickFct_2(int state); int TickFct_3(int state); unsigned char runningTasks[4] = {255}; // Track running tasks, [0] always idleTask const unsigned long idleTask = 255; // 0 highest priority, 255 lowest unsigned char currentTask = 0; // Index of highest priority task in runningTasks unsigned schedule_time = 0; ISR(TIMER1_COMPA_vect) { unsigned char i; for (i=0; i < tasksNum; ++i) { // Heart of scheduler code if ( (tasks[i].elapsedTime >= tasks[i].period) // Task ready && (runningTasks[currentTask] > i) // Task priority > current task priority && (!tasks[i].running) // Task not already running (no self-preemption) ) { SREG &= 0x7F; tasks[i].elapsedTime = 0; // Reset time since last tick tasks[i].running = 1; // Mark as running currentTask += 1; runningTasks[currentTask] = i; // Add to runningTasks SREG |= 0x80; tasks[i].state = tasks[i].TickFct(tasks[i].state); // Execute tick SREG &= 0x7F; tasks[i].running = 0; // Mark as not running runningTasks[currentTask] = idleTask; // Remove from runningTasks currentTask -= 1; SREG |= 0x80; } tasks[i].elapsedTime += tasksPeriodGCD; } } void init_processor() { /*Set up SPI*/ PORTB = 0xff; /*Set up timer*/ TCCR1B = (1<<WGM12)|(1<<CS11); // CTC mode (clear timer on compare). Prescaler=8 // AVR output compare register OCR0. OCR1A = 25000; // AVR timer interrupt mask register TIMSK1 = (1<<OCIE1A); //enables compare match interrupt TCNT1 = 0; /* Init GPIO pins PB0, PB1, Pb2 */ DDRB |= _BV(DDB0); //Pin 8 DDRB |= _BV(DDB1); //Pin 9 DDRB |= _BV(DDB2); //Pin 10 /*Enable global interrupts*/ SREG |= 0x80; } int main(void) { init_processor(); // Priority assigned to lower position tasks in array unsigned char i = 0; tasks[i].state = -1; tasks[i].period = period1; tasks[i].elapsedTime = tasks[i].period; tasks[i].running = 0; tasks[i].TickFct = &TickFct_1; ++i; tasks[i].state = -1; tasks[i].period = period2; tasks[i].elapsedTime = tasks[i].period; tasks[i].running = 0; tasks[i].TickFct = &TickFct_2; ++i; tasks[i].state = -1; tasks[i].period = period3; tasks[i].elapsedTime = tasks[i].period; tasks[i].running = 0; tasks[i].TickFct = &TickFct_3; while(1) { } } int TickFct_1(int state) { //_delay_us(1000); PORTB ^= _BV(PB0); return 0; } int TickFct_2(int state) { //_delay_us(5000); PORTB ^= _BV(PB1); return 0; } int TickFct_3(int state) { //_delay_us(25000); PORTB ^= _BV(PB2); return 0; } A tutaj zrzut ekranu z komlipacji w Arduino IDE 2.3.2 Jak widać program binarny po kompilacji zajmuje zaledwie 730 bajtów i 44 bajty RAM (2%) co pozostawia prawie całą pamięć dla obsługi naszej aplikacji. Do Arduino UNO do pinów 8, 9, 10 (PB0, PB1, PB2) zostały podłączone trzy diody LED przez rezystory 240 Ohm. Poniżej krótki film wiedo z działania powyższego programu. Niestety filmu nie zamieszczę bo format mp4 nie jest obsługiwany dla forum. Ja zamierzam w programach dla Arduino UNO R3 używać RIOS 😀 Pozdrawiam BTW: jak zapewne wielu z was zauważy tak prosty RTOS (sam scheduler tasków) nie zawiera implementacji wielu ważnych mechanizmów jak mutexy, semafory i kolejki. Można je spróbować zaimplementować samemu lecz nie zawsze jerst to trywialne ponieważ niektóre operacje muszą być atomowe.

Tytuł mówi wszystko: chciałbym wykorzystać nowe możliwości UNO R4 do zabawy z systemem czasu rzeczywistego. Język C. Czy jest (już) port któregoś z systemów jak FreeRTOS czy MBED? Pozdrowienia, Marek