ATNEL tech-forum

Re: Odstępy czasowe pomiędzy poleceniami w sposób nieblokują

2017-01-28T11:30:16+01:00

Bardzo dziękuję. Spróbuję ten automat zaimplementować w kodzie programu i poproszę o sprawdzenie.

Statystyki: Napisane przez avrfun — 28 sty 2017, o 11:30

Re: Odstępy czasowe pomiędzy poleceniami w sposób nieblokują

2017-01-28T10:43:03+01:00

Chciałbym jeszcze dodać, że koncentrowałem się tutaj bardziej na pokazaniu implementacji maszyny stanów, niż na precyzyjnym odmierzaniu czasu. Świadomie ustaliłem interwał inkrementacji zmiennej timestamp na 10ms, aby podczas odliczania 1000ms jej wartość nie przekroczyła 256, czyli pojemności typu uint8_t (1 bajtu).

Chodziło mi o to, żeby nie komplikować niepotrzebnie kodu, ponieważ zmienne kilkubajtowe modyfikowane w przerwaniu wymagają w pętli głównej programu atomowego dostępu, co oznacza, że podczas każdego ich użycia należy wyłączać globalną flagę zezwalającą na przerwania (czy też użyć np. makra ATOMIC_BLOCK).

W związku z powyższym mój kod może powodować pewne niedokładności rzędu jednego okresu obiegu timera, czyli 10ms. Jeśli jest to problemem, można zmniejszyć okres do 1ms i użyć zmiennej timestamp typu uint16_t, pamiętając o wyłączaniu przerwań w odpowiednich miejscach.

Statystyki: Napisane przez andrews — 28 sty 2017, o 10:43

Re: Odstępy czasowe pomiędzy poleceniami w sposób nieblokują

2017-01-27T18:51:22+01:00

andrews napisał(a):

Bardzo dziękuję! Przeanalizuję kod i w razie niejasności i wątpliwości poproszę o wyjaśnienie. Pozdrawiam.

Statystyki: Napisane przez avrfun — 27 sty 2017, o 18:51

Re: Odstępy czasowe pomiędzy poleceniami w sposób nieblokują

2017-01-27T18:01:55+01:00

Przedstawię jak mniej więcej jak ja bym to widział. Nie będzie to kod gotowy do skopiowania i skompilowania, ale taki "zarys" (objaśnienia w kodzie - w razie niejasności postaram się wyjaśnić):

[syntax=c]//................................

// czas "obiegu" timera w ms
#define TIMER_PERIOD 10

// definicje czasów opóźnień w ms
#define DELAY1 1000
#define DELAY2 200
#define DELAY3 300

//..................................

// stany, jakie może przyjąć automat
enum State {
WAITING_FOR_HIGH_LEVEL,
WAITING_FOR_LOW_LEVEL,
FISRT_DELAY,
SECOND_DELAY,
THIRD_DELAY
};

// ..........................

// zmienna inkrementowana w przerwaniu timera
volatile uint8_t timestamp;

//...........................

// timer2 (przykładowo) skonfigurowany na 10ms
// w procedurze obsługi przerwania tylko
ISR(TIMER2_COMPA_vect)
{
timestamp++;
}

//..........................

// definicja funkcji wywoływanej cyklicznie w pętli while (1) we funckji [i]main[/i]
void RTC_EVENT(void)
{
// zmienna statyczna reprezentująca aktualny stan automatu
static enum State current_state = WAITING_FOR_HIGH_LEVEL;
// zmienna wyznaczająca moment końca opóźnienia
static uint8_t next_send_time;

switch (current_state)
{
case WAITING_FOR_HIGH_LEVEL:
// jeśli na pinie wystąpił stan wysoki
if ( (PINC & KEY_SOFT_INT_PIN) )
{
// włączamy oczekiwanie na stan niski
current_state = WAITING_FOR_LOW_LEVEL;
}
break;
case WAITING_FOR_LOW_LEVEL: /* czekamy na stan niski na pinie */
// jeśli wystąpił stan niski
if ( !(PINC & KEY_SOFT_INT_PIN) )
{
// odczytujemy czas
get_rtc_datetime();
// jeśli sekundy przyjęly wartość 0
if (datetime.ss == 0)
{
// wysyłamy pierwszy pakiet
uart_puts("1");
// oznaczamy moment w którym upłynie pierwsze opóźnienie
next_send_time = timestamp + DELAY1/TIMER_PERIOD;
// włączamy pierwsze opóźnienie
current_state = FISRT_DELAY;
}
// jeśli nie przyjęły wartości 0
else
{
// włączamy oczekiwanie na stan niski
current_state = WAITING_FOR_HIGH_LEVEL;
}
}
break;
case FISRT_DELAY:
// jeśli timestamp osiągnął żądaną wartość
if ( timestamp >= next_send_time )
{
// wysyłamy drugi pakiet
uart_puts("2");
// oznaczamy moment w którym upłynie drugie opóźnienie
next_send_time = timestamp + DELAY2/TIMER_PERIOD;
// włączamy drugie opóźnienie
current_state = SECOND_DELAY;
}
break;
case SECOND_DELAY:
// jeśli timestamp osiągnął żądaną wartość
if ( timestamp >= next_send_time )
{
// wysyłamy trzeci pakiet
uart_puts("3");
// oznaczamy moent w którym upłynie trzecie opóźnienie
next_send_time = timestamp + DELAY3/TIMER_PERIOD;
// włączamy trzecie opóźnienie
current_state = THIRD_DELAY;
}
break;
case THIRD_DELAY:
// jeśli timestamp osiągnął żądaną wartość
if ( timestamp >= next_send_time )
{
// wysyłamy ostatni pakiet
funkcja_send(argumenty);
// włączamy oczekiwanie na stan niski
current_state = WAITING_FOR_HIGH_LEVEL;
}
break;
}
}

//...........................[/syntax]

Statystyki: Napisane przez andrews — 27 sty 2017, o 18:01

Re: Odstępy czasowe pomiędzy poleceniami w sposób nieblokują

2017-01-27T12:20:42+01:00

andrews napisał(a):

Możesz zaimplementować wewnątrz funkcji prosty automat skończony (ang. finite state machine).

W tej chwili nie mam czasu, a trudno to opisać na szybko w kilku słowach, więc może późniejszym popołudniem/wieczorem pokażę jakiś przykładowy kod, jeśli problem nie zostanie jeszcze rozwiązany.

Bardzo dziękuję. Poszukam. Będę wdzięczny za przykład w miarę wolnego czasu. Mój "automat" jest nieskończony bo timer programowy działa non-stop .
Pozdrawiam

------------------------ [ Dodano po: 22 minutach ]

Zrobiłem tak:
[syntax=c]void inicjalizacja(){

if(!Timer1){

switch(licznik){

case 0: uart_puts("1"); break;
case 10: uart_puts("2"); break;
}
licznik++;
Timer1 = 10;
}
}[/syntax]

Statystyki: Napisane przez avrfun — 27 sty 2017, o 12:20

Re: Odstępy czasowe pomiędzy poleceniami w sposób nieblokują

2017-01-27T11:56:31+01:00

Możesz zaimplementować wewnątrz funkcji prosty automat skończony (ang. finite state machine).

W tej chwili nie mam czasu, a trudno to opisać na szybko w kilku słowach, więc może późniejszym popołudniem/wieczorem pokażę jakiś przykładowy kod, jeśli problem nie zostanie jeszcze rozwiązany.

Statystyki: Napisane przez andrews — 27 sty 2017, o 11:56

Re: Odstępy czasowe pomiędzy poleceniami w sposób nieblokują

2017-01-27T11:34:03+01:00

anonimg3 napisał(a):

Nie lepiej wrzucić do uC i sprawdzić, czy działa?

Wrzucę i sprawdzę

Statystyki: Napisane przez avrfun — 27 sty 2017, o 11:34

Re: Odstępy czasowe pomiędzy poleceniami w sposób nieblokują

2017-01-27T11:31:04+01:00

Po pierwsze nie wiem czemu funkcja inicjalizacja() jest w while() oraz RTC_EVENT(). Po drugie ciężko powiedzieć, bo nie ma całego kodu a jedynie fragmenty. Nie lepiej wrzucić do uC i sprawdzić, czy działa?

Statystyki: Napisane przez anonimg3 — 27 sty 2017, o 11:31

Re: Odstępy czasowe pomiędzy poleceniami w sposób nieblokują

2017-01-27T11:16:17+01:00

anonimg3 napisał(a):

Dziękuję. Jest to kwestia organizacji dużego programu. Myślałem żeby zrobić tak:

1. W ciele RTC_EVENT(), jak w pierwszym poscie, przed funkcją send umieścić funkcję inicjalizacja
[syntax=c]void RTC_EVENT(void){

/* Programowy INT0 RTC->INT0->KEY_SOFT_INT_PIN */
if(!key_lock && !(PINC & KEY_SOFT_INT_PIN)){

key_lock=1;
get_rtc_datetime(&datetime); // Odczyt daty i czasu z układu RTC

if(datetime.ss ==0){

inicjalizacja();
funkcja_send(argumenty) // Właściwa funkcja wysyłająca dane do uart
}

} else if(key_lock && (PINC & KEY_SOFT_INT_PIN)) key_lock=0;
}[/syntax]
2. Funkcję inicjalizacja umieścić w pętli while
[syntax=c]while(1){

UART_RX_STR_EVENT(bufor);
RTC_EVENT();
inicjalizacja();
}[/syntax]
3. W ciele funkcji inicjalizacja zawrzeć timer programowy z licznikiem, który będzie odmierzał zadane odstępy czasu, przy konkretnej wartości licznika funkcja się zakończy i powróci do miejsca wywołania w RTC_EVENT() i w następnej kolejności uruchomiona zostanie funkcja send
[syntax=c]void inicjalizacja(){

if(!Timer1){

if(licznik == 0) uart_puts("1\r");
if(licznik == 1) uart_puts("2\r");
if(licznik == 2) uart_puts("3\r");
if(licznik == 3) uart_puts("4\r\r");

if(licznik == 3){

licznik = 10;

} else {

licznik++;
Timer1 = 200;
}
}
}[/syntax]
Czy założenia tego pomysłu są poprawne?

Statystyki: Napisane przez avrfun — 27 sty 2017, o 11:16

Re: Odstępy czasowe pomiędzy poleceniami w sposób nieblokują

2017-01-27T10:15:10+01:00

Dlaczego nie możesz umieścić w pętli while()? Wystarczy, że zamiast wysyłania w RTC_EVENT() ustawisz jakąś zmienną pomocniczą, a w pętli while() sprawdzisz warunek na podstawie tej zmiennej. Co do odstępu czasowego to odsyłam do poradnika MODULO na YT, który przygotował Pan Mirosław.

BTW. Zachęcam do zakupu YELLOWBOOKA, bo tam jest pięknie opisana realizacja timerów sprzętowych oraz timeoutów z wykorzystaniem struktur i jednego przerwania sprzętowego, oczywiście w sposób nieblokujący.

Statystyki: Napisane przez anonimg3 — 27 sty 2017, o 10:15

Odstępy czasowe pomiędzy poleceniami w sposób nieblokujący

2017-01-27T08:58:32+01:00

Witam!

Mam pewien problem z wykonaniem kilku instrukcji po kolei, nieblokująco (timer programowy – 10ms), ale w szczególnej sytuacji. W programie głównym, w pętli while, wywoływane jest zdarzenie od okładu RTC RTC_EVENT(). W zdarzeniu tym w rytm sygnału z RTC co 1 sekundę pobierany jest z niego czas i gdy sekundy są zerowe (co minutę) następuje uruchomienie funkcji (funkcja_send) wysyłającej dane przez uart. Problem w tym, że przed właściwym wysłaniem danych (funkcja_send) chciałbym wysłać do uart serię poleceń w odstępach np. 1000, 200, 300ms. Gdyby funkcja_send była w pętli while problemu by nie było. Proszę o pomoc i wskazówki. W kodzie wygląda to tak:

[syntax=c]while(1){

UART_RX_STR_EVENT(bufor);
RTC_EVENT();
}[/syntax]

[syntax=c]void RTC_EVENT(void){

/* Programowy INT0 RTC->INT0->KEY_SOFT_INT_PIN */
if(!key_lock && !(PINC & KEY_SOFT_INT_PIN)){

key_lock=1;
get_rtc_datetime(&datetime);// Odczyt daty i czasu z układu RTC

if(datetime.ss ==0){

uart_puts("1");
1000ms // jak wstawić ten odstęp czasowy nieblokująco;
uart_puts("2";
200ms // jak wstawić ten odstęp czasowy nieblokująco;
uart_puts("3");
300ms // jak wstawić ten odstęp czasowy nieblokująco;

funkcja_send(argumenty) // Właściwa funkcja wysyłająca dane do uart
}

} else if(key_lock && (PINC & KEY_SOFT_INT_PIN)) key_lock=0;
}[/syntax]

Pozdrawiam

Statystyki: Napisane przez avrfun — 27 sty 2017, o 08:58