[Programowanie] Terminalowa aplikacja serwisowa do robota. Część 3 - UART w C

sosnus · Wrzesień 7, 2013

Program PuTTy i moduł BT już są przygotowane do pracy. Teraz ostatnia, lecz najważniejsza część tego kursu czyli przygotowanie uC do pracy z "apką serwisową". W tej części omówię bibliotekę do obsługi UART Kol. Antystatycznego. Przeprowadzimy też pierwsze testy komunikacji PC«-»uC, a na koniec opowiem o zakamarkach ustawień prędkości transmisji danych.

Mam nadzieję że wiesz mniej-więcej na czym polega transmisja UART. Myślę, że jeżeli opanowałeś już używanie LCD w standardzie HD44780 z gotowych bibliotek, to bez problemu zrozumiesz tą część artykułu.

Tak więc przedstawiam Wam biblioteki do sprzętowej obsługi UARTu Kol. Antystatycznego :

Plik uart.c

   /*
    * uart.c
    *
    *  Created on: 29-06-2013
    *  Author: Arkadiusz Pytlik
    */

   #include<avr/io.h>
   #include<avr/interrupt.h>
   #include<avr/pgmspace.h>
   #include<stdlib.h>
   #include"uart.h"

   /************************ USART0 ************************************/
   enum {locked, unlocked};
   #if(USART_NUMBER==0)||(USART_NUMBER==2)
   volatile uint8_t interrupt_init_semaphore0 = unlocked;

   volatile uint8_t rx0_first_byte, rx0_last_byte;
   volatile uint8_t tx0_first_byte, tx0_last_byte;

   char rx0_buffer[RX0_BUFFER_SIZE];
   char tx0_buffer[TX0_BUFFER_SIZE];
   #endif//USART_NUMBER

   /************************ USART1 ************************************/
   #if(USART_NUMBER==1)||(USART_NUMBER==2)
   volatile uint8_t interrupt_init_semaphore1 = unlocked;

   volatile uint8_t rx1_first_byte, rx1_last_byte;
   volatile uint8_t tx1_first_byte, tx1_last_byte;

   char rx1_buffer[RX1_BUFFER_SIZE];
   char tx1_buffer[TX1_BUFFER_SIZE];
   #endif//USART_NUMBER


   /***************************** Init ********************************/
   void uart_init(uint8_t usart_nr, uint16_t speed)
   {
   #if(USART_NUMBER==0)||(USART_NUMBER==2)
           if(usart_nr==0)
           {
                   UBRR0L_REGISTER = (uint8_t) speed;
                   UBRR0H_REGISTER = (speed>>8);
                   UCSR0B_REGISTER = (1<<TXCIE0_BIT)|(1<<RXCIE0_BIT)|(1<<TXEN0_BIT)|(1<<RXEN0_BIT);
           }
   #endif//USART_NUMBER

   #if(USART_NUMBER==1)||(USART_NUMBER==2)
           if(usart_nr==1)
           {
                   UBRR1L_REGISTER = (uint8_t) speed;
                   UBRR1H_REGISTER = (speed>>8);
                   UCSR1B_REGISTER = (1<<TXCIE1_BIT)|(1<<RXCIE1_BIT)|(1<<TXEN1_BIT)|(1<<RXEN1_BIT);
           }
   #endif//USART_NUMBER
   }

   /********************************** TX ****************************/
   void uart_put_char(uint8_t usart_nr, char data)
   {
   #if(USART_NUMBER==0)||(USART_NUMBER==2)
           if(usart_nr == 0)
           {
                   tx0_buffer[tx0_last_byte] = data;//pakujemy bajt do bufora
                   tx0_last_byte = (tx0_last_byte + 1) & TX0_BUFFER_MASK;

                   while(tx0_first_byte == tx0_last_byte);//niech przerwanie cokolwiek wysle w swiat

                   if(interrupt_init_semaphore0 == unlocked)
                   {
                           interrupt_init_semaphore0 = locked;
                           UDR0_REGISTER = tx0_buffer[tx0_first_byte];//wywolujemy pierwsze przerwanie
                   }
           }
   #endif//USART_NUMBER

   #if(USART_NUMBER==1)||(USART_NUMBER==2)
           if(usart_nr == 1)
           {
                   tx1_buffer[tx1_last_byte] = data;//pakujemy bajt do bufora
                   tx1_last_byte = (tx1_last_byte + 1) & TX1_BUFFER_MASK;

                   while(tx1_first_byte == tx1_last_byte);//niech przerwanie cokolwiek wysle w swiat

                   if(interrupt_init_semaphore1 == unlocked)
                   {
                           interrupt_init_semaphore1 = locked;
                           UDR1_REGISTER = tx1_buffer[tx1_first_byte];//wywolujemy pierwsze przerwanie
                   }
           }
   #endif//USART_NUMBER
   }

   #if USE_INT == 1
   void uart_put_int(uint8_t usart_nr, int16_t data)
   {
           char temp_buffer[7];//znak wiodacy, 5 bajtow na cyfry oraz NULL
           itoa(data, temp_buffer, 10);
           switch(usart_nr)
           {

   #if(USART_NUMBER==0)||(USART_NUMBER==2)
           case 0:
                   uart_put_string(0, temp_buffer);
                   break;
   #endif//USART_NUMBER

   #if(USART_NUMBER==1)||(USART_NUMBER==2)
           case 1:
                   uart_put_string(1, temp_buffer);
                   break;
   #endif//USART_NUMBER

   #if(USART_NUMBER==1)||(USART_NUMBER==2)
           case 2:
                   uart_put_string(0, temp_buffer);
                   uart_put_string(1, temp_buffer);
                   break;
   #endif//USART_NUMBER
           }
   }
   #endif//USE_INT

   #if USE_HEX == 1
   void uart_put_hex(uint8_t usart_nr, int16_t data)
   {
           char temp_buffer[6];//znak wiodacy, 4 bajty na cyfry oraz NULL
           itoa(data, temp_buffer, 16);
           switch(usart_nr)
           {

   #if(USART_NUMBER==0)||(USART_NUMBER==2)
           case 0:
                   uart_put_string(0, temp_buffer);
                   break;
   #endif//USART_NUMBER

   #if(USART_NUMBER==1)||(USART_NUMBER==2)
           case 1:
                   uart_put_string(1, temp_buffer);
                   break;
   #endif//USART_NUMBER

   #if(USART_NUMBER==1)||(USART_NUMBER==2)
           case 2:
                   uart_put_string(0, temp_buffer);
                   uart_put_string(1, temp_buffer);
                   break;
   #endif//USART_NUMBER
           }
   }
   #endif//USE_HEX

   void uart_put_string(uint8_t usart_nr, char *string)
   {
           switch(usart_nr)
           {
   #if(USART_NUMBER==0)||(USART_NUMBER==2)
           case 0:
                   while(*string) uart_put_char(0, *string++);
                   break;
   #endif//USART_NUMBER

   #if(USART_NUMBER==1)||(USART_NUMBER==2)
           case 1:
                   while(*string) uart_put_char(1, *string++);
                   break;
   #endif//USART_NUMBER

   #if(USART_NUMBER==2)
           case 2:
                   while(*string) uart_put_char(0, *string++);
                   while(*string) uart_put_char(1, *string++);
                   break;
   #endif//USART_NUMBER
           }
   }

   #if USE_PROGMEM == 1
   void uart_put_string_P(uint8_t usart_nr, const char *string)
   {
           switch(usart_nr)
           {
   #if (USART_NUMBER==0)||(USART_NUMBER==2)
           case 0:
                   while(pgm_read_byte(string)) uart_put_char(0, pgm_read_byte(string++));
                   break;
   #endif//USART_NUMBER

   #if (USART_NUMBER==1)||(USART_NUMBER==2)
           case 1:
                   while(pgm_read_byte(string)) uart_put_char(1, pgm_read_byte(string++));
                   break;
   #endif//USART_NUMBER

   #if (USART_NUMBER==2)
           case 2:
                   while(pgm_read_byte(string)) uart_put_char(0, pgm_read_byte(string++));
                   while(pgm_read_byte(string)) uart_put_char(1, pgm_read_byte(string++));
                   break;
   #endif//USART_NUMBER
           }
   }
   #endif//USE_PROGMEM

   /**************************** RX ***********************/
   char uart_get_char(uint8_t usart_nr)
   {
           register char temp = 0;
           switch(usart_nr)
           {
   #if (USART_NUMBER==0)||(USART_NUMBER==2)
           case 0:
                   temp = (rx0_first_byte == rx0_last_byte)?   0:rx0_buffer[rx0_first_byte];
                   if(rx0_first_byte != rx0_last_byte) rx0_first_byte = (rx0_first_byte+1) & RX0_BUFFER_MASK;
                   break;
   #endif//USART_NUMBER

   #if (USART_NUMBER==1)||(USART_NUMBER==2)
           case 1:
                   temp = (rx1_first_byte == rx1_last_byte)?   0:rx1_buffer[rx1_first_byte];
                   if(rx1_first_byte != rx1_last_byte) rx1_first_byte = (rx1_first_byte+1) & RX1_BUFFER_MASK;
                   break;
   #endif//USART_NUMBER
           }
           return temp;
   }

   #if USE_GET_STRING == 1
   void uart_get_string(uint8_t usart_nr, char *buffer)
   {
           switch(usart_nr)
           {
   #if(USART_NUMBER==0)||(USART_NUMBER==2)
           case 0:
                   do *buffer = uart_get_char(0);
                   while(*buffer++);
                   break;
   #endif//USART_NUMBER

   #if(USART_NUMBER==1)||(USART_NUMBER==2)
           case 1:
                   do *buffer = uart_get_char(1);
                   while(*buffer++);
                   break;
   #endif//USART_NUMBER
           }
   }
   #endif//USE_GET_STRING

   #if(USART_NUMBER==0)||(USART_NUMBER==2)

   //*************************** Interrupts *************************************
   ISR(TX0_INTERRUPT)
   {
           tx0_first_byte = (tx0_first_byte + 1) & TX0_BUFFER_MASK;
           if(tx0_first_byte != tx0_last_byte)
           {
                   UDR0_REGISTER = tx0_buffer[tx0_first_byte];
           }
           else
           {
                   interrupt_init_semaphore0 = unlocked;
           }
   }
   #endif//USART_NUMBER

   #if(USART_NUMBER==1)||(USART_NUMBER==2)
   ISR(TX1_INTERRUPT)
   {
           tx1_first_byte = (tx1_first_byte + 1) & TX1_BUFFER_MASK;
           if(tx1_first_byte != tx1_last_byte)
           {
                   UDR1_REGISTER = tx1_buffer[tx1_first_byte];
           }
           else
           {
                   interrupt_init_semaphore1 = unlocked;
           }
   }
   #endif//USART_NUMBER

   #if(USART_NUMBER==0)||(USART_NUMBER==2)
   ISR(RX0_INTERRUPT)
   {
           register char rx0_temp;

           rx0_temp = UDR0_REGISTER;

           if(rx0_first_byte != (rx0_last_byte+1))
           {
                   if((rx0_temp != '\r') && (rx0_temp != '\n'))
                   {
                           rx0_buffer[rx0_last_byte] = rx0_temp;//txt
                           rx0_last_byte = (rx0_last_byte+1) & RX0_BUFFER_MASK;
                   }
                   if(rx0_temp == '\r')
                   {
                           rx0_buffer[rx0_last_byte] = 0;//null
                           rx0_last_byte = (rx0_last_byte+1) & RX0_BUFFER_MASK;
                   }
           }
   }
   #endif//USART_NUMBER

   #if(USART_NUMBER==1)||(USART_NUMBER==2)
   ISR(RX1_INTERRUPT)
   {
           register char rx1_temp;

           rx1_temp = UDR1_REGISTER;

           if(rx1_first_byte != (rx1_last_byte+1))
           {
                   if((rx1_temp != '\r') && (rx1_temp != '\n'))
                   {
                           rx1_buffer[rx1_last_byte] = rx1_temp;//txt
                           rx1_last_byte = (rx1_last_byte+1) & RX1_BUFFER_MASK;
                   }
                   if(rx1_temp == '\r')
                   {
                           rx1_buffer[rx1_last_byte] = 0;//null
                           rx1_last_byte = (rx1_last_byte+1) & RX1_BUFFER_MASK;
                   }
           }
   }
   #endif//USART_NUMBER

Plik uart.h :



   /*
    * uart.h
    *
    *  Created on: 29-06-2013
    *  Author: Arkadiusz Pytlik
    */

   #ifndef UART_H_
   #define UART_H_
   /************************************************************************************
    *                                      Compilation options                                             *
    ************************************************************************************/

   /************************************************************************************
    * Enable/disable transmitting strings from flash memory                            *
    * 0 - Disabled                                                                     *
    * 1 - Enabled                                                                      *
    */ //                                                                              *
   #define USE_PROGMEM     1                                                       //  *
   //***********************************************************************************

   /************************************************************************************
    * Enable/disable transmitting integers in decimal format (ASCII transmission)      *
    * 0 - Disabled                                                                     *
    * 1 - Enabled                                                                      *
    * By disabling this function you can save ca. 200 bytes of flash.                  *
    *///                                                                               *
   #define USE_INT 1                                                           //      *
   //***********************************************************************************

   /************************************************************************************
    * Enable/disable transmitting integers in hexadecimal format (ASCII transmission)  *
    * 0 - Disabled                                                                     *
    * 1 - Enabled                                                                      *
    * By disabling this function you can save ca. 200 bytes of flash.                  *
    *///                                                                               *
   #define USE_HEX 1                                                               //  *
   //***********************************************************************************

   /************************************************************************************
    * Enable/disable string receiving                                                  *
    * 0 - Disabled                                                                     *
    * 1 - Enabled                                                                      *
    *///                                                                               *
   #define USE_GET_STRING 1                                                    //      *
   //***********************************************************************************

   /************************************************************************************
    * In some MCU's like ie. ATmega644 you can use usart0,usart1 or both of them.      *
    * Available options:                                                               *
    * 0 - For USART0                                                                   *
    * 1 - For USART1                                                                   *
    * 2 - For USART0 and USART1                                                        *
    *///                                                                               *
   #define USART_NUMBER 0                                                      //      *
   //***********************************************************************************

   /************************* Buffers and speeds ***************************************
    * Below you can change size of usart buffers                                       *
    * Available sizes: 4, 8, 16, 32, 64, 128, 256 bytes.                               *
    ************************************************************************************/
   #if(USART_NUMBER==0)||(USART_NUMBER==2)
   /************************************************************************************
    *                                              USART0 receiver                                             *
    ************************************************************************************/
   #define RX0_BUFFER_SIZE 16
   #define RX0_BUFFER_MASK (RX0_BUFFER_SIZE-1)//do not change

   /************************************************************************************
    *                                              USART0 transmitter                                          *
    ************************************************************************************/
   #define TX0_BUFFER_SIZE 16
   #define TX0_BUFFER_MASK (TX0_BUFFER_SIZE-1)//do not change

   /************************************************************************************
    *                                              Define USART0 speed                                         *
    ************************************************************************************/
   #define USART0_BAUD 9600
   #define __UBRR0 ((F_CPU+USART0_BAUD*8UL) / (16UL*USART0_BAUD)-1)//do not change
   #endif//USART_NUMBER

   #if(USART_NUMBER==1)||(USART_NUMBER==2)
   /************************************************************************************
    *                                              USART1 receiver                                             *
    ************************************************************************************/
   #define RX1_BUFFER_SIZE 16
   #define RX1_BUFFER_MASK (RX1_BUFFER_SIZE-1)//do not change

   /************************************************************************************
    *                                              USART1 transmitter                                                                                      *
    ************************************************************************************/
   #define TX1_BUFFER_SIZE 16
   #define TX1_BUFFER_MASK (TX1_BUFFER_SIZE-1)//do not change

   /************************************************************************************
    *                                              Define USART1 speed                                         *
    ************************************************************************************/
   #define USART1_BAUD 9600
   #define __UBRR1 ((F_CPU+USART1_BAUD*8UL) / (16UL*USART1_BAUD)-1)//do not change
   #endif//USART_NUMBER

   /************************************************************************************
    *                                              Transmitter functions                                       *
    ************************************************************************************/
   void uart_init(uint8_t usart_nr, uint16_t speed);
   void uart_put_char(uint8_t usart_nr, char data);
   void uart_put_string(uint8_t usart_nr, char * string);

   #if USE_PROGMEM == 1
   void uart_put_string_P(uint8_t usart_nr, const char *string);
   #endif //USE_PROGMEM
   #if USE_INT == 1
   void uart_put_int(uint8_t usart_nr, int16_t data);
   #endif//USE_INT
   #if USE_HEX == 1
   void uart_put_hex(uint8_t usart_nr, int16_t data);
   #endif//USE_HEX

   /************************************************************************************
    *                                              Receiver functions                                                  *
    ************************************************************************************/
   char uart_get_char(uint8_t usart_nr);

   #if USE_GET_STRING == 1
   void uart_get_string(uint8_t usart_nr, char *buffer);
   #endif//USE_GET_STRING
   /************************* MCU dependent section ************************************/

   #if defined(__AVR_ATtiny2313__)||defined(__AVR_ATtiny2313A__)||defined(__AVR_ATtiny4313)
   #define RX0_INTERRUPT USART_RX_vect
   #define TX0_INTERRUPT USART_TX_vect
   #define UDR0_REGISTER UDR
   #define UBRR0L_REGISTER UBRRL
   #define UBRR0H_REGISTER UBRRH
   #define UCSR0B_REGISTER UCSRB
   #define TXCIE0_BIT              TXCIE
   #define RXCIE0_BIT              RXCIE
   #define TXEN0_BIT               TXEN
   #define RXEN0_BIT               RXEN
   #endif

   #if   defined(__AVR_ATmega48__)||defined(__AVR_ATmega88__)||defined(__AVR_ATmega168__)\
           ||defined(__AVR_ATmega328__)||defined(__AVR_ATmega328P__)
   #define RX0_INTERRUPT USART_RX_vect
   #define TX0_INTERRUPT USART_TX_vect
   #define UDR0_REGISTER UDR0
   #define UBRR0L_REGISTER UBRR0L
   #define UBRR0H_REGISTER UBRR0H
   #define UCSR0B_REGISTER UCSR0B
   #define TXCIE0_BIT              TXCIE0
   #define RXCIE0_BIT              RXCIE0
   #define TXEN0_BIT               TXEN0
   #define RXEN0_BIT               RXEN0
   #endif

   #if defined(__AVR_ATmega8__)||defined(__AVR_ATmega8P__)||defined(__AVR_ATmega16__)\
           ||defined(__AVR_ATmega32__)
   #define RX0_INTERRUPT USART_RXC_vect
   #define TX0_INTERRUPT USART_TXC_vect
   #define UDR0_REGISTER UDR
   #define UBRR0L_REGISTER UBRRL
   #define UBRR0H_REGISTER UBRRH
   #define UCSR0B_REGISTER UCSRB
   #define TXCIE0_BIT              TXCIE
   #define RXCIE0_BIT              RXCIE
   #define TXEN0_BIT               TXEN
   #define RXEN0_BIT               RXEN
   #endif

   #if defined(__AVR_ATmega644__)||defined(__AVR_ATmega644P__)||defined(__AVR_ATmega644PA__)\
           ||defined(__AVR_ATmega1284P__)||defined(__AVR_ATmega128__)
   #if(USART_NUMBER==0)||(USART_NUMBER==2)
   #define RX0_INTERRUPT USART0_RX_vect
   #define TX0_INTERRUPT USART0_TX_vect
   #define UDR0_REGISTER UDR0
   #define UBRR0L_REGISTER UBRR0L
   #define UBRR0H_REGISTER UBRR0H
   #define UCSR0B_REGISTER UCSR0B
   #define TXCIE0_BIT              TXCIE0
   #define RXCIE0_BIT              RXCIE0
   #define TXEN0_BIT               TXEN0
   #define RXEN0_BIT               RXEN0
   #endif//USART_NUMBER
   #if(USART_NUMBER==1)||(USART_NUMBER==2)
   #define RX1_INTERRUPT USART1_RX_vect
   #define TX1_INTERRUPT USART1_TX_vect
   #define UDR1_REGISTER UDR1
   #define UBRR1L_REGISTER UBRR1L
   #define UBRR1H_REGISTER UBRR1H
   #define UCSR1B_REGISTER UCSR1B
   #define TXCIE1_BIT              TXCIE1
   #define RXCIE1_BIT              RXCIE1
   #define TXEN1_BIT               TXEN1
   #define RXEN1_BIT               RXEN1
   #endif//USART_NUMBER
   #endif//MCU def's
   #endif /* UART_H_ */

Powyższa biblioteka nie jest zbyt optymalna, lecz ma jedną ogromną zaletę, jest bardzo łatwa w obsłudze i konfiguracji, na przykład jeżeli chcesz zmienić uC, to nie musisz wcale konfigurować plików uart.c oraz uart.h, ponieważ dzięki makrodefinicjom, pliki te same się dostosują do innego procesora.

Teraz czas utworzyć plik main.c w którym wykorzystamy tą bibliotekę.

Poniżej podaję plik main.c dosyć mocno skomentowany 😉

main.c

/*
* main.c
*
*  Created on: 24-08-2013
*  File: main.c
*  Author: Stanisław "Sosnus" Puławski
*/

#include <avr/io.h>
#include <avr/interrupt.h> // przerwania
#include <util/delay.h>		// delaye
#include <avr/pgmspace.h>	// napisy w pamięci FLASH
#include"UART/uart.h"  // biblioteka Antystatycznego do obsługi transmisji UART

int zmienna_int = 193 ;
char zmienna_char = 100 ;   // psrawdz w tabelach ASCI za co odpowiada kod "100"


//char work_buffer0[RX0_BUFFER_SIZE];

// ### DEKLARACJE F-CJI ###
//void hardware_init(void);

int main(void) {
//hardware_init();// inicjalizacja wszelkich podzespołów sprzętowych (timery, adc, pwm, itp.)
uart_init(0, __UBRR0);    // inicjalizacja UART
sei();		// globalne uruchomienie przerwań

while (1) {
	// główna część programu
	uart_put_string_P(0, (PSTR("\r\n"))); // enter, nowa linia

	uart_put_string_P(0,(PSTR("STRING_FLASH"))); // ta funkcja wysyła tekst z pamięci flash uC
	// za pomocą powyzszej f-cji bedziemy wysylac tabelke  oraz napisy wyswietlajace sie przy starcie programu

	uart_put_string_P(0, (PSTR("\r\n"))); // enter, nowa linia

	uart_put_dec(0, zmienna_int ) ;  // f-cja wysle liczbę: 193
	//za pomoca powyzszej f-cji bedziemy wysylac np. wartosci adc z czujnikow linii, badz wartosci PWM podane na silniki

	uart_put_string_P(0, (PSTR("\r\n"))); // enter, nowa linia

	uart_put_char(0, zmienna_char ); // ta funkcja wysyła 1 znak ASCII z pamięci RAM uC
	// za pomoca powyzszej f-cji bedziemy wysylac informacje np. jaki znak zostal nacisniety na klawiaturze w trybie zdalnego sterowania bt

	uart_put_string_P(0, (PSTR("\r\n"))); // enter, nowa linia
	uart_put_char(0, uart_get_char(0)) ;// ta funkcja odsyła nam spowrotem to co wysłalismy z kompa

	zmienna_int++ ;

	_delay_ms(500);

		}

}			// ### KONEC F-CJI MAIN()

W pliku main.c pokazałem jak zainicjalizować obsługę UARTu, oraz pokazałem jak wygląda w praktyce użycie najważniejszych funkcji. Wszystko jest ładnie okomentowane więc myślę że nie będzie problemu ze zrozumieniem kodu. Tak więc tworzymy nowy projekt w eclipse, kopiujemy i wklejamy plik main.c z tej strony, następnie obok tego pliku tworzymy folder "UART" do którego pakujemy pliki "uart.c" oraz "uart.h". Następnie kompilujemy, wgrywamy podłączamy moduł BT (oczywiście skonfigurowany wcześniej według części drugiej tego artykułu), odpalamy program PuTTy, i cieszymy się działającym UARTem 😃 .

W terminalu efekt pracy tego wsadu powinien wyglądać tak:

Teraz czas na "Zakamarki ustawień prędkości transmisji UART"

Na wstępie powiem, że we wszystkich miejscach które wymientaktowaniię, prędkość ma być ustawiona na 19200 (chyba że Ty chcesz używać innej prędkości, wtedy wszędzie w miejsce 19200 wstaw inną prędkość). Natomiast pozostałe parametry transmisji wynoszą: 8,n,1 czyli: 8 bitów danych, brak (none) bitów parzystości, oraz 1 bit stopu.

Miejsca w których należy ustawiać prędkość transmisji to:

1. Moduł Bluetooth - jak go przygotować, pisałem w drugiej części kursu.

2. Wirtualny port COM - jak znaleźć to okienko pisałem też w drugiej części kursu.

3. Ustawienia programu PuTTy - zakładka Connection»Serial

4. Program - zajrzyj do pliku uart.h i upewnij się, że w tej linijce wpisana jest odpowiednia prędkość

Należy jeszcze pamiętać o poprawnych ustawieniach taktowania procesora.

5. Fusebity - ustawione odpowiednie opcje dot. taktowanie mikroprocesora

6. Eclipse - ustawienia - taktowanie procesora

7. Fizyczny kwarc (ja mam kwarc w podstawce, często go wymieniam, a potem zastanawiam się, dlaczego UART krzaczy 🙄 )

Jak widzimy, zakamarków jest dużo i łatwo jest o czymś zapomnieć, tak więc jeżeli terminal wyświetla Ci krzaczki, posprawdzaj te ustawienia.

Dziękuję za uwagę, w następnej części zajmiemy się rysowaniem tabelek (kodowaniem CP866) oraz przemieszczaniem kursora (dzięki komendom VT100).

Po więcej informacji na temat biblioteki do obsługi UART, zapraszam tutaj: http://forum.atnel.pl/topic3461.html

W załączniku do tej części artykułu dodaję gotowy do pracy projekt eclipse, oraz biblioteki do obsługi uartu.

UART_Projekt_Eclipse.zip

UART.rar

[Programowanie] Terminalowa aplikacja serwisowa do robota. Część 3 - UART w C

Pomocna odpowiedź

sosnus

Link do komentarza

Share on other sites

Dołącz do dyskusji, napisz odpowiedź!

Quizy

Najnowsze posty w innych tematach

Kurs elektroniki II - #4 - komparatory napięć 1 2 3 4 15

Prośba o sprawdzenie schematu obrotomierza

Kurs elektroniki – #9 – elementy stykowe, przekaźniki 1 2 3 4 15

Aktywny System Monitorujący 1 2 3 4 14

ESP32 CAM - programowanie, zasilanie, obraz z kilku kamer/modułów jednocześnie

Inne