[5] Atxmega - RS485

Ten post chciałbym poświęcić na opisanie sposobu wykonania komunikacji w standardzie transmisji szeregowej RS485.

Opis

Dane będą wysyłane z mikrokontrolera przy użyciu trzech linii. Dwie z nich czyli RX oraz TX wysyłają oraz odbierają dane. Natomiast trzecia będzie odpowiadała za sterowanie.

W standardzie 485 dane muszą być wysyłane naprzemiennie w trybie half-duplex. Dużym plusem takiego rodzaju transmisji jest odporność na zakłócenia przez zastosowanie skrętki dwu przewodowej, daleki zasięg oraz możliwość podłączenia wielu urządzeń na linii.  

Jeśli chodzi o hardware to można wykorzystać jakieś gotowe moduły, bądź wykonać własny konwerter np. poprzez wykorzystanie układu ST3485EB, który jest konwerterem na RS485/RS422. Pozwala on zarówno na wysyłanie jak i odbieranie danych w trybie half-duplex. Aby dane odebrać poprawnie na komputerze przez serial port to należałoby użyć konwerter z RS485 na USB.

Kod Programu:

Wybrałem domyślne porty do obsługi UARTC:

1. #define RE_DE_PIN  PIN4_bm
2. #define RE_DE_PORT PORTC
4. #define TX_PIN  PIN3_bm
5. #define TX_PORT PORTC
7. #define RX_PIN  PIN2_bm
8. #define RX_PORT PORTC

Włączenie pinów wygląda następująco:

1. #define setPinInput(port, pin)      port.DIRCLR |= pin
2. #define setPinOutput(port, pin)     port.DIRSET |= pin
3. #define setPinHigh(port, pin)       port.OUTSET = pin
4. #define setPinLow(port, pin)        port.OUTCLR = pin
6.     setPinInput(RX_PORT, RX_PIN);
7.     setPinOutput(TX_PORT, TX_PIN);
8.     setPinHigh(TX_PORT, TX_PIN);
9.     setPinOutput(RE_DE_PORT, RE_DE_PIN);

Linia RE_DE jest odpowiedzialna za inicjalizacje trybu pracy, ustawienie albo dla nadawania bądź przygotowanie do odbioru danych. W programie ta linia będzie ustawiana w stan wysoki gdy dane będą miały być wysyłane. Domyślnie będzie w stanie niskim, czyli w trybie oczekiwania na odbiór danych.

Następnie należy włączyć UART z odpowiednimi ustawieniami. Obliczenie dla prędkości prezentują się następująco:

1.     /*
2.         * XTAL = 11,0592 MHz = 11059200
3.         * BSEL: ((11059200)/((2^0)*16*9600)) - 1 = 71
4.         * Calculation: Fbaud = ((11059200)/((2^0) * 16 * (71+1))) = 9600
5.     */

Włączenie układu natomiast wygląda w ten sposób:

1.     cli();
3.     USARTC0_BAUDCTRLB = 0;
4.     USARTC0_BAUDCTRLA = 71;
5.    
6.     USARTC0_CTRLC = USART_CHSIZE_8BIT_gc;
7.     USARTC0_CTRLA = USART_RXCINTLVL_HI_gc;
8.     USARTC0_CTRLB =  USART_RXEN_bm | USART_TXEN_bm;
10.     sei();

Na początku wyłączane są wszystkie przerwania, następuje wgranie ustawień po czym przerwania zostają ponownie włączone. Ustawione są ,idąc od początku, prędkości transmisji, format ramki, włączenie przerwać od RX oraz włączenie transmisji.

W celu przesłania pojedynczego znaku należy wykonać taką funkcję:

1. static void sendChar(char c)
2. {
3.     while(!(USARTC0.STATUS & USART_DREIF_bm)); //Wait until DATA buffer is empty
4.     USARTC0_DATA = c;
5. }

Właściwie aby pojedynczy znak mógł być wysłany należy jeszcze wykonać odpowiednie ustawienie portów. Ja tą czynność wykonuje podczas przesyłania ciągu wiadomości. Natomiast dla pojedyncze znaku wyglądało by to tak:

1. #define delayms(time)               _delay_ms(time)
2. #define delayus(time)               _delay_us(time)
4. static void sendChar2(char c)
5. {
6.     setPinHigh(RE_DE_PORT, RE_DE_PIN);
7.     setPinHigh(TX_PORT, TX_PIN);
8.    
9.     delayms(10);
10.    
11.     while(!(USARTC0.STATUS & USART_DREIF_bm)); //Wait until DATA buffer is empty
12.     USARTC0_DATA = c;
13.    
14.     delayms(10);
15.     setPinLow(RE_DE_PORT, RE_DE_PIN);
16. }

Funkcja opoźniająca jest tutaj niezwykle istotna, ponieważ bez niej porty mogą nie zostać poprawnie ustawione lub zresetowane aby cała wiadomość spokojnie została wysłana do drugiego układu.

Teraz funkcja wysyłająca ciąg znaków w oparciu o funkcję sendChar:

1. void sendString(char *text)
2. {
3.     setPinHigh(RE_DE_PORT, RE_DE_PIN);
4.     setPinHigh(TX_PORT, TX_PIN);
5.    
6.     delayms(10);
7.    
8.     while(*text)
9.     {
10.         sendChar(*text++);
11.     }
12.    
13.     delayms(10);
14.     setPinLow(RE_DE_PORT, RE_DE_PIN);
15. }

Wysłanie ciągu znaków z wybranym znakiem końcowym. Można to zrobić także bezpośrednio wpisując dane do funkcji wcześniejszej.

1. void sendStringWithEnd(char *text, uartEndSign_Typedef last_sign)
2. {
3.     setPinHigh(RE_DE_PORT, RE_DE_PIN);
4.     setPinHigh(TX_PORT, TX_PIN);
5.    
6.     delayms(10);
8.     while(*text)
9.     {
10.         sendChar(*text++);
11.     }
13.     if(last_sign==CR_Sign){
14.         sendChar('\r');
15.     }
16.     else if(last_sign==LF_Sign){
17.         sendChar('\n');
18.     }
19.     else if(last_sign==CR_LF_Sign){
20.         sendChar('\r');
21.         sendChar('\n');
22.     }
23.     else if(last_sign==LF_CR_Sign){
24.         sendChar('\n');
25.         sendChar('\r');
26.     }
27.     else if(last_sign==NONE_Sign){}
29.     delayms(10);
30.     setPinLow(RE_DE_PORT, RE_DE_PIN);
31. }

Obsługa przerwania RX może wyglądać następująco:

1. #define MAX_VALUE_UART 200
2. volatile uint8_t buffer_data[MAX_VALUE_UART];
4. char usart_getc(void)
5. {
6.     while (!(USARTC0_STATUS & USART_RXCIF_bm));
7.     return USARTC0.DATA;
8. }
9. //----------------------------------------------------
10. ISR(USARTC0_RXC_vect)
11. {  
12.     uint8_t dat;
13.     uint8_t counter;
15.     for(counter=0;counter<MAX_VALUE_UART;counter++)
16.     {
17.         buffer_data[counter] = (uint8_t)usart_getc();
18.         if(buffer_data[counter] == '\n') { break; }
19.     }
20. }

Odebrane dane zostają zapisane w zmiennej buffer_data. Odbiór danych będzie następował do momentu przepełnienia bufora bądź gdy na końcu zostanie odebrany znak nowej linii (LF - '\n'). Dane mogą być bezpośrednio przekazywane na ekran, bądź obrabiane w osobnej funkcji do której przekazany zostanie odebrany buffor.

Bibliografia:

[1] http://elektronikab2b.pl/technika/3404-czym-jest-rs-485-#.WTTxz-vyi70
[2] https://pl.wikipedia.org/wiki/EIA-485