ATNEL tech-forum 2016-04-18T21:41:50+01:00 https://forum.atnel.pl/feed.php?f=4&t=15073&mode 2016-04-18T21:41:50+01:00 2016-04-18T21:41:50+01:00 https://forum.atnel.pl/viewtopic.php?t=15073&p=158870#p158870 <![CDATA[Re: UART Atmega8 przesylanie wartosci z ADC i generowanie PW]]>

--
Pozdrawiam,
Robert

Statystyki: Napisane przez rskup — 18 kwi 2016, o 21:41

]]> 2016-04-17T17:50:27+01:00 2016-04-17T17:50:27+01:00 https://forum.atnel.pl/viewtopic.php?t=15073&p=158749#p158749 <![CDATA[Re: UART Atmega8 przesylanie wartosci z ADC i generowanie PW]]> rskup napisał(a):

Stosowanie znaków końca linii jest dobra przy komunikacji z wykorzystaniem liter i cyfr. Lecz jak my przesyłane dowolnych wartości bajtów, to już takie coś nie przejdzie :( Dlatego w poważniejszych rozwiązaniach takie dane się ramkuje wysyłając ramkę typowo w postaci:
._______ ______ _____ ______
| START | DANE | CRC | STOP |
| ______|______|_____|_____|
gdzie:
START - wybrany znak oznaczający początek ramki (np. znak ASCII STX)
STOP - wybrany znak oznaczający koniec ramki (np. znak ASCII ETX)
CRC - suma kontrolna liczona według wybranego algorytmu (może być więcej niż jeden bajt, ale jej długość jest stała i ustalona)
DANE - przesyłane dane (dowolna, zmienna liczba bajtów)

Aby można było przesłać wartości w danych pokrywające się wartością ze znakami START, STOP wykonuje się tzw. ESCejpowanie. Polega to na tym, że aby wysłać w polu DATA znak o wartości START, wysyła się znak ESC i następnie zanegowany znak START. Tak samo zamiast STOP wysyła się znak ESC i zanegowany znak STOP. Dodatkowo trzeba zrobić jeszcze jedno ESCejpowanie. Aby wysłać znak ESC wysyłamy ESC i zanegowany znak ESC.
Dzięki takiej operacji mamy zawsze łatwą synchronizację początku ramki (odebranie znaku START oznacza początek ramki). Wiemy także kiedy jest koniec ramki (odebranie znaku STOP). Oraz możemy przesłać dowolną wartość binarną w polu DATA.
A w kodzie odbiorczym wystarczy dodać jedno proste sprawdzenie. Jeżeli otrzymaliśmy znak ESC, to nie dodajemy go do bufora odbiorczego, tylko ustawiamy dodatkowy znacznik. Przy odbiorze bajtu jeżeli mamy znacznik ustawiony to taki bajt dodawany jest do bufora jako zanegowany (wysłany był jako zanegowany, więc podwójna negacja da właściwy znak). I tyle :) Nic więcej nie trzeba dodawać.

Jako sumę kontrolną warto stosować sumę, która ma pewną dodatkową właściwość. Chodzi o to by suma wyliczona na bajtach DATA i bajtach samej sumy (pole CRC) dawała zero. Dzięki temu licząc ją na bieżąco przy kolejnym bajcie, jak dojdziemy do znaku STOP, to gdy suma kontrolna jest poprawna, to mamy wartość 0 :) Taką właściwość ma np. bardzo popularny algorytm wyliczający sumę kontrolną CRC16.

--
Pozdrawiam,
Robert

Fajnie opisane podejście - a masz może do tego juz opracowany kod którym mógłbyś się podzielić ?

Sent from my GT-I9506 using Tapatalk

Statystyki: Napisane przez RafPe — 17 kwi 2016, o 17:50

]]> 2016-04-14T12:18:46+01:00 2016-04-14T12:18:46+01:00 https://forum.atnel.pl/viewtopic.php?t=15073&p=158511#p158511 <![CDATA[Re: UART Atmega8 przesylanie wartosci z ADC i generowanie PW]]>
Zdecydowałem się na wykorzystanie tokenów. Z pomocą BB i GB wyszło coś takiego:

[syntax=c]int main(void) {


PWM();

USART_Init(__UBRR);

register_uart_str_rx_event_callback( analizuj_dane_rs232 );
sei();
DDRB |= (1<<PB0) | (1<<PB1);

while(1)
{

UART_RX_STR_EVENT( uart_buf );

}[/syntax]
[syntax=c]void analizuj_dane_rs232 (char *buf)
{
char *wsk;

wsk = strtok( buf , "," );

if ( !strcmp( wsk , "$" ) );
{
wsk = strtok( NULL , "," );

if( !strcmp( wsk, "dioda1") )

{wsk = strtok( NULL , "," );

if ( !strcmp( wsk , "zapal") ) PORTB |= (1<<LED1);
if ( !strcmp( wsk , "zgas") ) PORTB &= ~(1<<LED1);
}

if( !strcmp( wsk, "dioda2") )

{wsk = strtok( NULL , "," );

if ( !strcmp( wsk , "zapal") ) PORTB |= (1<<LED2);
if ( !strcmp( wsk , "zgas") ) PORTB &= ~(1<<LED2);
}

/*if( !strcmp( wsk , "serwo" ) );

{
wsk = strtok( NULL , "," );

//uint8_t data1 = atoi("15");//dziala ze stala
*
uint8_t data1 = atoi(wsk);
pwm1_get_value(data1);

}
*/
if( !strcmp( wsk , "silnik2" ) );

{
wsk = strtok( NULL , "," );

uint8_t data2 = atoi(wsk);

pwm2_get_value(data2);

}

if( !strcmp( wsk , "silnik1" ) );

{
wsk = strtok( NULL , "," );

uint8_t data3 = atoi(wsk);

pwm3_get_value(data3);

}

if( !strcmp( wsk , "silnik0" ) );

{
wsk = strtok( NULL , "," );

uint8_t data4 = atoi(wsk);

pwm4_get_value(data4);

}

}[/syntax]

Z nadajnika wysyłam coś takiego (narazie stałe wartości w ramach testowania, później będą to odczyty z ADC):

[syntax=c]uart_puts( "$" );
uart_puts( "," );
uart_puts( "serwo" );
uart_puts( "," );
uart_putint( 25 , 10 );
uart_puts( "\r\n" );

uart_puts( "$" );
uart_puts( "," );
uart_puts( "silnik2" );
uart_puts( "," );
uart_putint( 15 , 10 );
uart_puts( "\r\n" );

uart_puts( "$" );
uart_puts( "," );
uart_puts( "silnik1" );
uart_puts( "," );
uart_putint( 15 , 10 );
uart_puts( "\r\n" );

uart_puts( "$" );
uart_puts( "," );
uart_puts( "silnik0" );
uart_puts( "," );
uart_putint( 10 , 10 );
uart_puts( "\r\n" );

/*
if ( !(PINB & 1<<LED1) )
{
uart_puts("$");
uart_puts(",");
uart_puts("dioda1");
uart_puts(",");
uart_puts("zapal");
uart_puts("\r\n");
}
if ( (PINB & 1<<LED1) )
{
uart_puts("$");
uart_puts(",");
uart_puts("dioda1");
uart_puts(",");
uart_puts("zgas");
uart_puts("\r\n");
}
if ( !(PINB & 1<<LED2) )
{
uart_puts("$");
uart_puts(",");
uart_puts("dioda2");
uart_puts(",");
uart_puts("zapal");
uart_puts("\r\n");
}
if ( (PINB & 1<<LED2) )
{
uart_puts("$");
uart_puts(",");
uart_puts("dioda2");
uart_puts(",");
uart_puts("zgas");
uart_puts("\r\n");
}
/*[/syntax]

Problem polega na tym, że funkcja odbiorcza nie rozróżnia mi (nie wiem czemu) poszczególnych, powiedzmy adresów.
To jest:

Wysyłam z nadajnika tylko ramkę dla "silnik0". Odbiornik odbiera, ale nie przypisuje tego "silnikowi0", a pierwszemu napotkanemu (w funkcji analizuj_dane_rs232), czyli "silnik2". Reszta komend w nadajniku jest zakomentowana.

Z kolei kiedy wyślę tylko komendy dla diody1 i diody2 (lecz komendy dla silników i serwa są zakomentowane) to odbiornik już rozróżnia prawidłowo. Kiedy jednak dodam do tego jeszcze komendę dla np. serwa to już się sypie i serwo dostaje jakiś misz masz.

Suma sumarum wydaję mi się, że błąd polega po stronie odbiorczej. Coś chyba nie tak ze wskaźnikiem. No chyba, że nadajnik też miesza bajty, choć mało prawdopodobne.

Statystyki: Napisane przez idzik15 — 14 kwi 2016, o 12:18

]]> 2016-04-09T19:57:05+01:00 2016-04-09T19:57:05+01:00 https://forum.atnel.pl/viewtopic.php?t=15073&p=158166#p158166 <![CDATA[Re: UART Atmega8 przesylanie wartosci z ADC i generowanie PW]]> Dlatego w poważniejszych rozwiązaniach takie dane się ramkuje wysyłając ramkę typowo w postaci:
._______ ______ _____ ______
| START | DANE | CRC | STOP |
| ______|______|_____|_____|
gdzie:
START - wybrany znak oznaczający początek ramki (np. znak ASCII STX)
STOP - wybrany znak oznaczający koniec ramki (np. znak ASCII ETX)
CRC - suma kontrolna liczona według wybranego algorytmu (może być więcej niż jeden bajt, ale jej długość jest stała i ustalona)
DANE - przesyłane dane (dowolna, zmienna liczba bajtów)

Aby można było przesłać wartości w danych pokrywające się wartością ze znakami START, STOP wykonuje się tzw. ESCejpowanie. Polega to na tym, że aby wysłać w polu DATA znak o wartości START, wysyła się znak ESC i następnie zanegowany znak START. Tak samo zamiast STOP wysyła się znak ESC i zanegowany znak STOP. Dodatkowo trzeba zrobić jeszcze jedno ESCejpowanie. Aby wysłać znak ESC wysyłamy ESC i zanegowany znak ESC.
Dzięki takiej operacji mamy zawsze łatwą synchronizację początku ramki (odebranie znaku START oznacza początek ramki). Wiemy także kiedy jest koniec ramki (odebranie znaku STOP). Oraz możemy przesłać dowolną wartość binarną w polu DATA.
A w kodzie odbiorczym wystarczy dodać jedno proste sprawdzenie. Jeżeli otrzymaliśmy znak ESC, to nie dodajemy go do bufora odbiorczego, tylko ustawiamy dodatkowy znacznik. Przy odbiorze bajtu jeżeli mamy znacznik ustawiony to taki bajt dodawany jest do bufora jako zanegowany (wysłany był jako zanegowany, więc podwójna negacja da właściwy znak). I tyle :) Nic więcej nie trzeba dodawać.

Jako sumę kontrolną warto stosować sumę, która ma pewną dodatkową właściwość. Chodzi o to by suma wyliczona na bajtach DATA i bajtach samej sumy (pole CRC) dawała zero. Dzięki temu licząc ją na bieżąco przy kolejnym bajcie, jak dojdziemy do znaku STOP, to gdy suma kontrolna jest poprawna, to mamy wartość 0 :) Taką właściwość ma np. bardzo popularny algorytm wyliczający sumę kontrolną CRC16.

--
Pozdrawiam,
Robert

Statystyki: Napisane przez rskup — 9 kwi 2016, o 19:57

]]> 2016-04-09T19:00:26+01:00 2016-04-09T19:00:26+01:00 https://forum.atnel.pl/viewtopic.php?t=15073&p=158164#p158164 <![CDATA[Re: UART Atmega8 przesylanie wartosci z ADC i generowanie PW]]> Statystyki: Napisane przez krafin — 9 kwi 2016, o 19:00

]]> 2016-04-09T18:57:42+01:00 2016-04-09T18:57:42+01:00 https://forum.atnel.pl/viewtopic.php?t=15073&p=158162#p158162 <![CDATA[Re: UART Atmega8 przesylanie wartosci z ADC i generowanie PW]]> Mi bardzo pomogły poradniki video Mirka "WIFI232 - programowanie - Part ". Tytuł wskazywałby na moduły wifi, ale na zwykłym kablowym połączeniu działa to identycznie.
Tak na szybko podpowiadając w Twoim przypadku najwygodniej byłoby wykorzystać tokeny, które również są omawiane w tych poradnikach.
Serdecznie polecam te kilka poradników, tylko dzięki nim ja zrealizowałem swój układ.

Statystyki: Napisane przez karolen — 9 kwi 2016, o 18:57

]]> 2016-04-09T18:27:58+01:00 2016-04-09T18:27:58+01:00 https://forum.atnel.pl/viewtopic.php?t=15073&p=158159#p158159 <![CDATA[Re: UART Atmega8 przesylanie wartosci z ADC i generowanie PW]]>

W tak prostym przypadku, nie używałbym stringów. Skoro odczytujesz dany kanał ADC, to znasz jego numer. Wobec tego proponuję skorzystać z takiej struktury:
[syntax=c]struct Data {
uint8_t channel;
uint8_t value;
};[/syntax]Następnie wysyłasz taką strukturę przez usart. Odbiornik odbiera dwa bajty, z których pierwszy jest numerem kanału ADC, a drugi wartością.
Problemem w takim podejściu może być odpowiednia synchronizacja, bo jeśli z jakiegoś powodu, jeden bajt się straci, to wartości zostaną zamienione ze sobą. A więc należy obudować te dane w bajt lub bajty określające początek i koniec transmisji.

Może jeszcze odbiornik odpytywać pierwszy układ o dane z przetwornika. A jeżeli rolą nadajnika jest tylko pomiar, to może warto go zastąpić cyfrowym przetwornikiem A/C.

Statystyki: Napisane przez Sparrow-hawk — 9 kwi 2016, o 18:27

]]> 2016-04-09T13:57:15+01:00 2016-04-09T13:57:15+01:00 https://forum.atnel.pl/viewtopic.php?t=15073&p=158136#p158136 <![CDATA[Re: UART Atmega8 przesylanie wartosci z ADC i generowanie PW]]> W BB jest to dobrze opisane.
Jak już odbierzesz kompletną komendę (tak żeby program wiedział gdzie jest jej początek i koniec), to analizujesz ją np. funkcjami do porównywania stringów.
Np. serwo1=1024 analizujesz do znaku = i wybierasz serwo, później analizujesz do końca(np. do znaku nowej linni, lub końca stringa) i ustawiasz to serwo na zadaną wartość.

Statystyki: Napisane przez ciamciak — 9 kwi 2016, o 13:57

]]> 2016-04-09T13:12:22+01:00 2016-04-09T13:12:22+01:00 https://forum.atnel.pl/viewtopic.php?t=15073&p=158135#p158135 <![CDATA[UART Atmega8 przesylanie wartosci z ADC i generowanie PWM]]>
Tworzę prosty nadajnik i odbiornik do sterowania wykorzystujący do tego dwie Atmegi8 (po jednej w każdym module). W nadajniku mam potencjometry. Sygnał jest konwertowany przez ADC i następnie wysyłany do odbiornika (przez UART), gdzie generowany jest sygnał PWM do serwomechanizmów.

Problem polega na tym żeby odbiornik rozróżniał, z którego potencjometru wysyłana jest wartość i żeby odpowiedni serwomechanizm (a nie inny) tą wartość otrzymał .

Myślałem nad jakimś sposobem adresowania każdego potencjometru i póki co najbliżej działający pomysł wygląda tak (fragment kodu):
[syntax=c]while(1) //petla glowna
{ if ( (PINC & 1<<PC3) )
{
USART_transmit(0b11111111); //wartosc "adresu"
USART_transmit(pwm1); //pwm1 - to wartosc z ADC
}

if ( (PINC & 1<<PC2) )
{
USART_transmit(0b10000001);
USART_transmit(pwm2);
}

//kawalek funkcji odbierajacej

while (! (UCSRA & (1 << RXC)) );
{
receiveData = UDR;
if (receiveData == 0b11111111)
{
pwm1 = UDR;
}
if (receiveData == 0b10000001)
{
pwm2 = UDR;
}[/syntax]

Generalnie pomysł polega na tym, że idzie 1 bajt "adres", następnie 1 bajt "dana". I tak w kółko. Tylko mam problem z zaimplementowaniem tego.

Sam ADC, PWM, UART itd działają OK kiedy przesyłam jedną wartość ( to jest tylko z jednego potencjometru, drugi mam zakomentowany). Kiedy mam oba, to też działa, ale ewidentnie sypią się błędy, bo jednym potencjometrem czasami steruję jednym serwem a czasami dwoma.

Za wszelką pomoc i sugestie dzięki

Statystyki: Napisane przez idzik15 — 9 kwi 2016, o 13:12

]]>