[1] ESP32 - Komunikacja po UART

W tym poście chciałbym opisać sposób komunikacja przez ESP32 za pomocą UARTu.

[Źródło: www.banggood.com]

Do dyspozycji są następujące układy wraz z pinami:

• UART0 - RX - GPIO3; TX - GPIO1; CTS - n/a; RTS - n/a;
• UART1 - RX - GPIO9; TX - GPIO10; CTS - GPIO6; RTS - GPIO11;
• UART2 - RX - GPIO16; TX - GPIO17; CTS - GPIO8; RTS - GPIO7;

Funkcje:

Funkcje wykorzystywane w przykładach z bibliotek esp32 to:

uart_param_config() - funkcja używana do ustawiania parametrów UARTu. Pełne rozwinięcie funkcji:

esp_err_t uart_param_config(uart_port_t uart_num, const uart_config_t *uart_config)

Wartości zwracane to ESP_OK w przypadku poprawnego ustawienia, ESP_FAIL w przypadku błędu.
Jako parametr podawany jest numer portu od 0 do 2 lub jako makra UART_NUM_0, UART_NUM_1 lub UART_NUM_2. Drugi parametr odnosi się do struktury uart_config_t zawierające poszczególne pola do ustawienia. Wśród nich znajdują się:

• int baudrate
• uart_word_length_t data_bits
• uart_parity_t parity
• uart_stop_bits_t stop_bits
• uart_hw_flowcontrol_t flow_ctrl - wybranie trybu kontroli cts lub rts;
• uint8_t rx_flow_ctrl_tresh

uart_set_pin() - ustawienie pinów:

esp_err_t uart_set_pin(uart_port_t uart_num, int tx_io_num, int rx_io_num, int rts_io_num, int cts_io_num);

Podobnie jak poprzednie funkcje zwracają one status wykonania operacji. Jako parametry podaje się numer uruchomianego uarta a następnie piny. Najpierw TX potem odpowiednio RX, RTS oraz CTS.

uart_driver_install() - odpowiada za uruchomienie sterownika dla UARTu.

esp_err_t uart_driver_install(uart_port_t uart_num, int rx_buffer_size, int tx_buffer_size, int queue_size, QueueHandle_t* uart_queue, int intr_alloc_flags);

Parametry:

• uart_num - numer wykorzystywanego uartu,
• rx_buffer_size - rozmiar buffora. Musi być większy niż UART_FIFO_LEN,
• tx_buffer_size - rozmiar buffora dla TX. W przypadku podania tutaj wartości zero, dane z TX będą przesyłane w trybie blokowania.
• queue_size - wielkość kolejki
• uart_queue - jeśli jest jakaś wartość podana wtedy wykorzystywana jest dostęp do zdarzeń od UARTa. Ustawienie na NULL powoduje nie wykorzystywanie tej operacji.
• intr_alloc_flags - flagi stosowane do przypisania przerwań.

uart_read_bytes() - funkcja wykorzystywana do odczytu danych przychodzących:

int uart_read_bytes(uart_port_t uart_num, uint8_t* buf, uint32_t length, TickType_t ticks_to_wait);

Jako parametr podawany jest numer kanału, następnie wskaźnik na bufor do którego odebrane dane zostaną zapisane. Dalej wielkość tego bufora. Na końcu czas oczekiwania na odebranie danych. 

uart_write_bytes() - wysyła dane na wybrany port o podanej długości.

int uart_write_bytes(uart_port_t uart_num, const char* src, size_t size);

Tutaj podawany jest numer kanału, następnie adres do przechowywanych danych. Na samym końcu rozmiar danych do wysłania. Funkcja zwraca -1 jeśli nastąpi błąd. W przypadku poprawnego wykonania zwracana jest wartość większa od 0 informująca o liczbie danych jakie zostały przesłane.

Program:

Program został przeze mnie przygotowany w eclipsie. Poniżej znajdują się plik .h oraz c.

Plik h:

1. #ifndef MAIN_UART_SETTINGS_H_
2. #define MAIN_UART_SETTINGS_H_
4. /*
5.  * UART     RXIO    TXIO    CTS     RTS
6.  * UART0    GPIO3   GPIO1   n/a     n/a
7.  * UART1    GPIO9   GPIO10  GPIO6   GPIO11
8.  * UART2    GPIO16  GPIO17  GPIO8   GPIO7
9.  */
11. /* Include files */
12. #include "driver/gpio.h"
13. #include "driver/uart.h"
14. #include "soc/uart_struct.h"
15. #include "uart_settings.h"
17. /* Pin definitions */
18. #define UART0_PIN_RX    3
19. #define UART0_PIN_TX    1
20. //------------------------------
21. #define UART1_PIN_RX    9
22. #define UART1_PIN_TX    10
23. #define UART1_PIN_CTS   6
24. #define UART1_PIN_RTS   11
25. //------------------------------
26. #define UART2_PIN_RX    16
27. #define UART2_PIN_TX    17
28. #define UART2_PIN_CTS   8
29. #define UART2_PIN_RTS   7
30. //------------------------------
31. #define BUFFER_SIZE (1024)
32. //------------------------------
33. /* @brief: Initialization of UART1 */
34. void Uart1_Init(const int uartNumber, uint32_t baudrate);
35. /* @brief: Initialization of UART2 */
36. void Uart2_Init(const int uartNumber, uint32_t baudrate);
37. /* @brief: Send Data procedure */
38. void Uart_Send_Data(const int uartNumber, uint8_t *buffer);
39. /* @brief: send table of data over selected uart port */
40. void Uart_SendArray(const int uartNumber, uint8_t *dataTable, uint16_t cnt);
41. /* @brief: send single byte */
42. void Uart_SendByte(const int uartNumber,  uint8_t data);
43. /* @brief: send number in ASCII format */
44. void Uart_SendNumber(const int uartNumber, uint32_t x);
45. #endif /* MAIN_UART_SETTINGS_H_ */

Plik c:

1. #include "uart_settings.h"
2. //----------------------------------------------------------------------------
3. /*
4.  * @brief:  Initialization of UART0
5.  * @param:  uartNumber: Number of uart that will be initialzed
6.  * @param:  baudrate: speed of transmission
7.  * @ret:    none
8.  */
9. void Uart0_Init(const int uartNumber, uint32_t baudrate)
10. {
11.     uart_config_t uart0_config;
13.     uart0_config.baud_rate = baudrate;                      /*!< UART baudrate                      */
14.     uart0_config.data_bits = UART_DATA_8_BITS;              /*!< UART byte size                     */
15.     uart0_config.parity = UART_PARITY_DISABLE;              /*!< UART parity mode                   */
16.     uart0_config.stop_bits = UART_STOP_BITS_1;              /*!< UART stop bits                     */
17.     uart0_config.flow_ctrl = UART_HW_FLOWCTRL_DISABLE;      /*!< UART HW flow control mode(cts/rts) */
18.     uart0_config.rx_flow_ctrl_thresh = 122;                 /*!< UART HW RTS threshold              */
20.     uart_param_config(uartNumber, &uart0_config);
22.     uart_set_pin(uartNumber, UART1_PIN_TX, UART1_PIN_RX, UART_PIN_NO_CHANGE, UART_PIN_NO_CHANGE);
24.     uart_driver_install(uartNumber, BUFFER_SIZE * 2, 0, 20, NULL, 0);
25. }
26. //----------------------------------------------------------------------------
27. /*
28.  * @brief:  Initialization of UART1
29.  * @param:  uartNumber: Number of uart that will be initialzed
30.  * @param:  baudrate: speed of transmission
31.  * @ret:    none
32.  */
33. void Uart1_Init(const int uartNumber, uint32_t baudrate)
34. {
35.     uart_config_t uart1_config;
37.     uart1_config.baud_rate = baudrate;                      /*!< UART baudrate                      */
38.     uart1_config.data_bits = UART_DATA_8_BITS;              /*!< UART byte size                     */
39.     uart1_config.parity = UART_PARITY_DISABLE;              /*!< UART parity mode                   */
40.     uart1_config.stop_bits = UART_STOP_BITS_1;              /*!< UART stop bits                     */
41.     uart1_config.flow_ctrl = UART_HW_FLOWCTRL_DISABLE;      /*!< UART HW flow control mode(cts/rts) */
42.     uart1_config.rx_flow_ctrl_thresh = 122;                 /*!< UART HW RTS threshold              */
44.     uart_param_config(uartNumber, &uart1_config);
46.     uart_set_pin(uartNumber, UART1_PIN_TX, UART1_PIN_RX, UART_PIN_NO_CHANGE, UART_PIN_NO_CHANGE);
48.     uart_driver_install(uartNumber, BUFFER_SIZE * 2, 0, 20, NULL, 0);
49. }
50. //----------------------------------------------------------------------------
51. /*
52.  * @brief:  Initialization of UART2
53.  * @param:  uartNumber: Number of uart that will be initialzed
54.  * @param:  baudrate: speed of transmission
55.  * @ret:    none
56.  */
57. void Uart2_Init(const int uartNumber, uint32_t baudrate)
58. {
59.     uart_config_t uart2_config;
61.     uart2_config.baud_rate = baudrate;
62.     uart2_config.data_bits = UART_DATA_8_BITS;
63.     uart2_config.parity = UART_PARITY_DISABLE;
64.     uart2_config.stop_bits = UART_STOP_BITS_1;
65.     uart2_config.flow_ctrl = UART_HW_FLOWCTRL_DISABLE;
66.     uart2_config.rx_flow_ctrl_thresh = 122;
68.     uart_param_config(uartNumber, &uart2_config);
70.     uart_set_pin(uartNumber, UART2_PIN_TX, UART2_PIN_RX, UART_PIN_NO_CHANGE, UART_PIN_NO_CHANGE);
72.     uart_driver_install(uartNumber, BUFFER_SIZE * 2, 0, 80, NULL, 0);
73. }
74. //----------------------------------------------------------------------------
75. /*
76.  * @brief:  Initialization of UART1
77.  * @param:  uartNumber: Number of uart to send data
78.  * @param:  *buffer: pointer to buffer with data to send
79.  * @ret:    none
80.  */
81. void Uart_Send_Data(const int uartNumber, uint8_t *buffer)
82. {
83.     uint16_t length = 0;
85.     while(buffer[length] != '\0')   {
86.         length++;
87.     }
89.     uart_write_bytes(uartNumber, (const char*)buffer, length);
90. }
91. //----------------------------------------------------------------------------
92. /*
93.  * @brief:  send array of data through selected uart port
94.  * @param:  uartNumber: number of uart port over what data will be send
95.  * @param:  *dataTable: pointer to data table
96.  * @param:  cnt: number of data to send
97.  * @ret:    none
98.  *
99.  */
100.  void Uart_SendArray(const int uartNumber, uint8_t *dataTable, uint16_t cnt)
101.  {
102.      if(cnt == 0){
103.          return;
104.      }
106.      uart_write_bytes(uartNumber, (const char*)dataTable, cnt);
107.  }
108.  //----------------------------------------------------------------------------
109.  /*
110.   * @brief:     send single byte over selected uart
111.   * @param:     uartNumber: number of uart port over what data will be send
112.   * @param:     data: one byte of data to be send
113.   * @ret:   none
114.   *
115.   */
116.  void Uart_SendByte(const int uartNumber,  uint8_t data)
117.  {
118.      char toSend[1] = { data };
119.      uart_write_bytes(uartNumber, (char *)toSend, 1);
120.  }
121.  //----------------------------------------------------------------------------
122.  /*
123.   * @brief:     send number as ascii code
124.   * @param:     uartNumber: number of uart port over what data will be send
125.   * @param:     uint32_t: number to send
126.   * @ret:       none
127.   *
128.   */
129.  void Uart_SendNumber(const int uartNumber, uint32_t x)
130.  {
131.      char value[10];
132.      int i = 0;
134.      do{
135.          value[i++] = (char)(x%10) + '0';
136.          x/=10;
137.      }while(x);
139.      while(i)
140.      {
141.          Uart_SendByte(uartNumber, (char*)value[--i]);
142.      }
143.  }

Idąc od góry, funkcje zawierają inicjalizacje wszystkich uartów, funkcje przesyłająca dane np. ciąg znaków. Wykonuje się on aż do momentu znalezienie znaku 0x00. Następnie wysłanie znaków o określonej długości. To z kolei jest przydatne przy wyświetlaniu jakiejś tablicy np. z zdekodowanymi danymi z odpowiedzią od czujników bądź modułów. Kolejna funkcja przesyła pojedynczy bajt. Ostatnia dekoduje numer i przesyła go w formacie ASCII.

Przykładowa funkcja main, w której UART1 działa w trybie echo wygląda następująco:

1. void uart1Task(void)
2. {
3.     const int uart1_num = UART_NUM_1;
4.     char line[1] = { 0x66 };
5.     char *ptr = line;
6.     Uart1_Init(uart1_num, 115200);
8.     uint8_t *uart1Buffer = (uint8_t*)malloc(BUFFER_SIZE);
10.     Uart_Send_Data(uart1_num, (uint8_t*)"Uart1 works\r\n");
12.     Uart_SendByte(uart1_num,  line[0]);
13.     Uart_SendNumber(uart1_num, 567832);
15.     while(1){
16.         int len1 = uart_read_bytes(uart1_num, uart1Buffer, BUFFER_SIZE, 20 / portTICK_RATE_MS);
17.         uart_write_bytes(uart1_num, (const char*)uart1Buffer, len1);
18.     }
20. }

Pozostałe uarty uruchamiane są w ten sam sposób.

Obsługa zadania dla UARTu 1 zawiera przykładowy sposób działania udostępnionych funkcji. Wszystkie zadania dla poszczególnych uartów zostały umieszczone w osobnych funkcjach.

UART0 jest udostępniony jako port domyślny używany do debugowania oraz wgrywania oprogramowania. Dlatego aby wysłać dane na niego można używać funkcji printf.

Biblioteki do projektu można pobrać pod tym linkiem.