Programowanie modułów ESP32 w środowisku ESP-IDF (2). Podstawy obsługi portów I/O, ADC, PWM, UART

Poniedziałek, 01 Lipiec 2024

W tym artykule omówione zostaną podstawy programowania układów ESP32 za pomocą środowiska ESP-IDF. Nasza uwaga skupiona będzie na procedurach, od których zazwyczaj rozpoczyna się pracę z nowym mikrokontrolerem czy środowiskiem programistycznym: dostępie do portów wejścia/wyjścia, obsłudze przetworników ADC oraz wyjść PWM czy też komunikacji ze światem zewnętrznym poprzez interfejs UART.

Obsługa portów I/O

Porty I/O, czyli porty wejścia/wyjścia, są najwdzięczniejszym interfejsem, ponieważ pozwalają w prosty sposób przetestować związany z nimi fragment oprogramowania. Wystarczy do wybranego portu podłączyć poprzez opornik zwykłą diodę LED, a jej świecenie będzie sygnalizować stan danego wyprowadzenia. Na niektórych płytach rozwojowych z ESP32 producenci zamontowali już tzw. LED-y użytkownika, doskonale nadające się do eksperymentów. W takim przypadku wystarczy jedynie odszukać w dokumentacji płytki numer portu I/O, do którego taka dioda jest podłączona.

Stworzenie programu testowego rozpoczynamy od uruchomienia edytora ze środowiskiem ESP-IDF. W opisie domyślnie będzie to edytor oparty na Eclipse, ESP-IDF v.4.4.

Klikamy File → New → Espressif IDF Project. Jeżeli zaznaczymy „Create a project using one of the templates”, będzie można otworzyć któryś z gotowych przykładów. Tym razem jednak stworzymy program od podstaw. W polu „Project name” należy wpisać nazwę tworzonego programu. W przykładzie użyję nazwy test-io-esp32-s3. Na liście „Select project target:” trzeba wybrać wariant procesora zamontowanego na używanej płycie rozwojowej, w omawianym przykładzie będzie to ESP32-S3. Po kliknięciu Finish zostanie utworzony projekt z plikiem main.c i pozostałymi plikami potrzebnymi w strukturze projektu.

Rysunek 1. Widok okna głównego środowiska Espressif-IDE

Ewentualne komunikaty o błędach w wygenerowanym projekcie znikną po przeprowadzeniu kompilacji w tym celu należy wybrać Project → Build Project lub nacisnąć ikonę młotka na pasku skrótów (patrz rysunek 1, oznaczenie strzałką nr 1). Teraz w pliku main.c – na miejsce automatycznie utworzonego kodu – proszę wpisać ten z listingu 1. W linii #define BLINK_GPIO podajemy numer portu I/O, do którego podłączona jest dioda LED. Należy wykonać powtórną kompilację i usunąć ewentualne błędy powstałe przy wpisywaniu kodu z listingu 1. Następnie podłączamy płytkę ewaluacyjną kablem do gniazda USB. W kolejnym kroku za pomocą narzędzi systemowych odczytujemy przydzielony podłączonej płycie numer portu. W edytorze należy kliknąć edycję listy Launch Target i w polu listy rozwijanej Serial Port: (rysunek 1, strzałka nr 3) ustawić numer portu. Po naciśnięciu przycisku Launch (rysunek 1, strzałka nr 2) płyta powinna zostać zaprogramowana, a dioda zacznie migotać z częstotliwością 1 Hz.

#include <unistd.h>

#include <stdio.h>
#include "driver/gpio.h"
#include "esp_log.h"
#include "sdkconfig.h"

static const char *TAG = "example";

/* wstaw w tej linii numer GPIO do którego
* jest podłączona dioda LED
*/
#define BLINK_GPIO 21

static uint8_t led_stan = 0;

static void configure_led(void)
{
ESP_LOGI(TAG, "Przykład konfiguracji wyjścia GPIO LED!");
gpio_reset_pin(BLINK_GPIO);
/* Ustaw tryb pracy GPIO jako push/pull output */
gpio_set_direction(BLINK_GPIO, GPIO_MODE_OUTPUT);
}

static void blink_led(void)
{
/* Set the GPIO level according to the state (LOW or HIGH)*/
gpio_set_level(BLINK_GPIO, led_stan);
led_stan =!led_stan;
}

void app_main(void)
{
ESP_LOGI(TAG, "Cześć tu program testowy GPIO LED!");
configure_led();

while (true) {
ESP_LOGI(TAG, "Stan LED=%s!", led_stan == true ? "ON" : "OFF");
blink_led();

sleep(1);
}
}

Listing 1. Program umożliwiający najprostsze miganie diodą LED

Działanie programu oparto na najprostszym sposobie sterowania portem I/O. W funkcji configure_led(void) port został ustawiony jako wyjściowy, a funkcja blink_led(void) zmienia poziom na wyjściu, do którego podłączona została dioda LED.

W celu przetestowania I/O pracującego w trybie wejścia należy wybrać drugi dostępny port na płycie rozwojowej. Ponieważ w czasie testu będzie on zwierany do masy, najlepiej wybrać taki, który nie ma przypisanej dodatkowej ważnej funkcji systemowej – czyli np. port o numeracji wyższej niż 17. Ponadto trzeba wprowadzić zmiany widoczne na listingu 2. Polegają one na zdefiniowaniu wybranego drugiego portu jako SW_GPIO, dodaniu funkcji ustawienia go jako wejściowego configure_sw(void) i modyfikacji funkcji main(). Po przesłaniu nowej wersji oprogramowania na płytę rozwojową i zwarciu do masy portu SW_GPIO, częstotliwość migotania diody LED zwiększa się do około 5 Hz.

(…)
#define SW_GPIO 47

(…)
static void configure_sw(void)
{
gpio_reset_pin(SW_GPIO);
if (gpio_set_pull_mode ( SW_GPIO , GPIO_PULLUP_ONLY) !=ESP_OK)
{
ESP_LOGE(TAG, "SW LED nie został prawidłowo skonfigurowany!");
}ESP_LOGI(TAG, "Przykład konfiguracji wejścia SW_GPIO");
gpio_set_direction(SW_GPIO, GPIO_MODE_INPUT);
}

(…)
void app_main(void)
{
uint8_t status_SW=true;

ESP_LOGI(TAG, "Cześć tu program testowy GPIO LED!");
configure_led();
configure_sw();

while (true) {
blink_led();
status_SW =gpio_get_level(SW_GPIO);
ESP_LOGI(TAG, "Stan LED=%s, f=%s", led_stan == true ? "ON" : "OFF", status_SW ==true ? "1Hz" : "5Hz");
if (status_SW!=0){
sleep(1);
}else usleep(200000);
led_stan =!led_stan;
}
}

Listing 2. Rozszerzenie programu z listingu 1 o odczyt stanu wejścia cyfrowego

Makra ESP_LOGI i ESP_LOGE powodują wysłanie odpowiednich komunikatów do terminalu wywoływanego z pulpitu edytora (rysunek 1, strzałka nr 4). Po naciśnięciu ikony terminalu wyświetla się tablica, na której w polu „Project Name:” trzeba ustawić nazwę projektu, a w polu „Serial port:” wybrać numer przydzielonego płycie portu. Po zatwierdzeniu powinna otworzyć się zakładka terminalu odbierającego komunikaty wysyłane przez nasze oprogramowanie. Takie zastosowanie terminalu pozwala na proste debugowanie programu.

W przykładzie pokazano najprostszy sposób sterowania portami I/O. API środowiska ESP-IDF umożliwia bardziej zaawansowane manipulacje, np. dołączanie wewnętrznych oporników podciągających, współpracę z systemem przerwań, zatrzaskiwanie ustawień portu nawet na czas resetu czy grupowe ustawianie parametrów wielu portów jednocześnie. Szczegółowy opis odpowiedni dla wersji IDF-4.4 można znaleźć w [1].

Obsługa przetworników ADC

W większości wersji ESP32 do dyspozycji użytkownika są dwa niezależne przetworniki analogowo-cyfrowe, każdy z kilkoma multipleksowanymi wejściami. Jako wejścia używa się portów I/O pracujących w trybie analogowym. W dokumentacji technicznej dotyczącej używanej wersji układu ESP32 opisane zostało przyporządkowanie dostępnych wejść przetwornika do portów I/O. Także w dokumentacji podane będą informacje o rozdzielczości bitowej, nieliniowości przetwarzania i ograniczeniach w użyciu przetworników ADC.

Na listingu 3 pokazany został prosty program, używający przetwornika ADC do odczytu bezpośredniego w trybie próbkowania. Listing oparto na przykładzie esp-idf-v4.4/examples/peripherals/adc/single_read/single_read. Klikamy File → New → Espressif IDF Project, zaznaczamy „Create a project using one of the templates” i na wyświetlonej liście klikamy przykład single_read.

#include <stdio.h>
#include <stdlib.h>
#include "esp_log.h"
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "driver/adc.h"
#include "esp_adc_cal.h"

//ADC Channels
#if CONFIG_IDF_TARGET_ESP32
#define ADC1_EXAMPLE_CHAN0 ADC_CHANNEL_6//ADC1_CHANNEL_6
#define ADC2_EXAMPLE_CHAN0 ADC2_CHANNEL_0
static const char *TAG_CH[2][10] = {{"ADC1_CH6"}, {"ADC2_CH0"}};
#else
#define ADC1_EXAMPLE_CHAN0 ADC1_CHANNEL_2
//#define ADC2_EXAMPLE_CHAN0 ADC2_CHANNEL_0
static const char *TAG_CH[2][10] = {{"ADC1_CH2"}, {"ADC2_CH0"}};
#endif

//ADC Attenuation
#define ADC_EXAMPLE_ATTEN ADC_ATTEN_DB_11

//ADC Calibration
#if CONFIG_IDF_TARGET_ESP32
#define ADC_EXAMPLE_CALI_SCHEME ESP_ADC_CAL_VAL_EFUSE_VREF
#elif CONFIG_IDF_TARGET_ESP32S2
#define ADC_EXAMPLE_CALI_SCHEME ESP_ADC_CAL_VAL_EFUSE_TP
#elif CONFIG_IDF_TARGET_ESP32C3
#define ADC_EXAMPLE_CALI_SCHEME ESP_ADC_CAL_VAL_EFUSE_TP
#elif CONFIG_IDF_TARGET_ESP32S3
#define ADC_EXAMPLE_CALI_SCHEME ESP_ADC_CAL_VAL_EFUSE_TP_FIT
#endif

static int adc_raw[2][10];
//static const char *TAG = "ADC SINGLE";

static esp_adc_cal_characteristics_t adc1_chars;
static esp_adc_cal_characteristics_t adc2_chars;

static bool adc_calibration_init(void)
{
esp_err_t ret;
bool cali_enable = false;

ret = esp_adc_cal_check_efuse(ADC_EXAMPLE_CALI_SCHEME);
if (ret == ESP_ERR_NOT_SUPPORTED) {
ESP_LOGW(TAG, "Calibration scheme not supported, skip software calibration");
} else if (ret == ESP_ERR_INVALID_VERSION) {
ESP_LOGW(TAG, "eFuse not burnt, skip software calibration");
} else if (ret == ESP_OK) {
cali_enable = true;
esp_adc_cal_characterize(ADC_UNIT_1, ADC_EXAMPLE_ATTEN, ADC_WIDTH_BIT_DEFAULT, 0, &adc1_chars);
// esp_adc_cal_characterize(ADC_UNIT_2, ADC_EXAMPLE_ATTEN, ADC_WIDTH_BIT_DEFAULT, 0, &adc2_chars);
} else {
ESP_LOGE(TAG, "Invalid arg");
}

return cali_enable;
}

void app_main(void)
{
// esp_err_t ret = ESP_OK;
uint32_t voltage = 0;
bool cali_enable = adc_calibration_init();

//ADC1 config
ESP_ERROR_CHECK(adc1_config_width(ADC_WIDTH_BIT_DEFAULT));
ESP_ERROR_CHECK(adc1_config_channel_atten(ADC1_EXAMPLE_CHAN0, ADC_EXAMPLE_ATTEN));
//ADC2 config
// ESP_ERROR_CHECK(adc2_config_channel_atten(ADC2_EXAMPLE_CHAN0, ADC_EXAMPLE_ATTEN));
vTaskDelay(pdMS_TO_TICKS(5000));
while (1) {
adc_raw[0][0] = adc1_get_raw(ADC1_EXAMPLE_CHAN0);
ESP_LOGI(TAG_CH[0][0], "raw data: %d", adc_raw[0][0]);
if (cali_enable) {
voltage = esp_adc_cal_raw_to_voltage(adc_raw[0][0], &adc1_chars);
ESP_LOGI(TAG_CH[0][0], "cali data: %d mV", voltage);
}
vTaskDelay(pdMS_TO_TICKS(1000));
/*
do {
ret = adc2_get_raw(ADC2_EXAMPLE_CHAN0, ADC_WIDTH_BIT_DEFAULT, &adc_raw[1][0]);
} while (ret == ESP_ERR_INVALID_STATE);
ESP_ERROR_CHECK(ret);

ESP_LOGI(TAG_CH[1][0], "raw data: %d", adc_raw[1][0]);
if (cali_enable) {
voltage = esp_adc_cal_raw_to_voltage(adc_raw[1][0], &adc2_chars);
ESP_LOGI(TAG_CH[1][0], "cali data: %d mV", voltage);
}
vTaskDelay(pdMS_TO_TICKS(1000));
*/
}
}

Listing 3. Prosty przykład obsługi przetwornika ADC

Zmiany w programie polegają na uproszczeniu kodu i odczycie tylko z kanału 6 przetwornika nr 1. Na listingu 3 niepotrzebne fragmenty kodu zostały ujęte w komentarze.

Jako pierwsza wywoływana jest funkcja adc_calibration_init(), której procedury służą do kalibracji przetwornika ADC. W ESP32 niektóre stałe kalibracyjne mogą być zapisywane na etapie produkcji układu w specjalnym obszarze pamięci „eFuse bits”. Jeżeli procedura esp_adc_cal_check_efuse nie odnajdzie poszukiwanej wartości kalibracyjnej, do korekty odczytów z przetwornika zostaną użyte wartości domyślne. Funkcja esp_adc_cal_characterize() mierzy napięcie Vref i temperaturę, czyli parametry używane do korekty obliczeń. Kolejne wywoływane funkcje: adc1_config_width() i adc1_config_channel_atten(), ustawiają parametry pracy wybranego kanału przetwornika 1 zgodnie z definicjami umieszczonymi na początku listingu 3. Potem w nieskończonej pętli następuje odczyt surowych danych z przetwornika i ich konwersja na wartość napięcia w mV, z zastosowaniem obliczonej wcześniej korekcji (funkcje adc1_get_raw(), esp_adc_cal_raw_to_voltage()). Obie wartości – opakowane w stosowny komunikat – po każdym odczycie wysyłane są do terminalu.

Opis bardziej rozbudowanych funkcji API do obsługi przetwornika ADC można znaleźć w dokumentacji [2].

LEDC – sterowanie jasnością LED w trybie PWM

Funkcje z grupy API LEDC przeznaczone są do sterowania jasnością diod LED przez zmianę wypełnienia impulsu PWM. Można je także zastosować ogólnie – jako sposób generowania impulsów o zmiennym współczynniku wypełnienia. Sposób użycia funkcji pokazany zostanie na przykładzie, w którym jasność świecenia diody LED będzie zmieniana proporcjonalnie do wartości napięcia podawanego na wejście przetwornika ADC. W tym celu zmodyfikujemy przykład z listingu 3, dodając funkcje LEDC. Dodatkowe linie programu zawiera listing 4.

(…)
//LEDC PWM
#include "driver/ledc.h"

(…)
//LEDC PWM
#define LEDC_TIMER LEDC_TIMER_0
#define LEDC_MODE LEDC_LOW_SPEED_MODE
#define LEDC_OUTPUT_IO (2) // Define the output GPIO
#define LEDC_CHANNEL LEDC_CHANNEL_0
#define LEDC_DUTY_RES LEDC_TIMER_13_BIT // Set duty resolution to 13 bits
#define LEDC_FREQUENCY (5000) // Frequency in Hertz. Set frequency at 5 kHz

(…)
//LEDC PWM
static void example_ledc_init(void)
{
// Prepare and then apply the LEDC PWM timer configuration
ledc_timer_config_t ledc_timer = {
.speed_mode = LEDC_MODE,
.timer_num = LEDC_TIMER,
.duty_resolution = LEDC_DUTY_RES,
.freq_hz = LEDC_FREQUENCY, // Set output frequency at 5 kHz
.clk_cfg = LEDC_AUTO_CLK
};
ESP_ERROR_CHECK(ledc_timer_config(&ledc_timer));

// Prepare and then apply the LEDC PWM channel configuration
ledc_channel_config_t ledc_channel = {
.speed_mode = LEDC_MODE,
.channel = LEDC_CHANNEL,
.timer_sel = LEDC_TIMER,
.intr_type = LEDC_INTR_DISABLE,
.gpio_num = LEDC_OUTPUT_IO,
.duty = 0, // Set duty to 0%
.hpoint = 0
};
ESP_ERROR_CHECK(ledc_channel_config(&ledc_channel));
}

void app_main(void)
{
(…)
example_ledc_init();

while(1)
{
(…)
//LEDC PWM
// Set duty to 50%
uint32_t ledc_duty=(8192)-1;
ledc_duty *=voltage;
ledc_duty /=3300;
ESP_LOGI(TAG_CH[0][0],"LEDC PWM %d",ledc_duty);
ESP_ERROR_CHECK(ledc_set_duty(LEDC_MODE, LEDC_CHANNEL, ledc_duty/*LEDC_DUTY*/));
// Update duty to apply the new value
ESP_ERROR_CHECK(ledc_update_duty(LEDC_MODE, LEDC_CHANNEL));

}
}
Listing 4. Rozbudowa przykładu z listingu 3 o obsługę wyjścia PWM

Najpierw należy dodać plik nagłówkowy biblioteki ledc.h. Następnie w sekcji definicji dodajemy nowe definicje: LEDC_TIMER – numer timera (0...3), LEDC_MODE – tryb pracy (wolny lub szybki), LEDC_OUTPUT_IO – numer portu I/O, na który ma być wyprowadzony przebieg PWM i do którego będzie podłączona dioda LED, LEDC_CHANNEL – numer kanału (0...7), LEDC_DUTY_RES – rozdzielczość (w bitach) generowanego przebiegu PWM, LEDC_FREQUENCY – częstotliwość generowanego przebiegu PWM. Należy także dodać funkcję example_ledc_init(), która inicjuje generowanie przebiegu PWM, używając do tego zdefiniowanych powyżej parametrów. Funkcje inicjujące mogą wygenerować komunikat błędu, jeżeli podane parametry przekraczają dopuszczalne zakresy rozdzielczości i częstotliwości. I tak dla niskich częstotliwości można ustawić wysoką rozdzielczość (do 20 bitów), natomiast dla najwyższej częstotliwości (40 MHz) rozdzielczość może być tylko 1-bitowa.

Wywołanie funkcji example_ledc_init() powinno zostać umieszczone na początku funkcji main(). Dalej – w pętli while – odczytana z przetwornika wartość napięcia voltage stosowana jest do obliczenia proporcjonalnej do niej wartości wypełnienia, umieszczanej w zmiennej ledc_duty. W każdym przebiegu pętli while funkcje ledc_set_duty() i ledc_update_duty() aktualizują wypełnienie przebiegu PWM. Opis funkcji i parametrów interfejsu LEDC można znaleźć w [3]. Na rysunku 2 pokazano schemat podłączenia do płyty rozwojowej dodatkowych elementów, takich jak dioda LED i potencjometr.

Rysunek 2. Schemat podłączenia dodatkowych elementów zewnętrznych do płyty rozwojowej

UART – obsługa interfejsu transmisji szeregowej

Protokół UART zapewnia obsługę asynchronicznych interfejsów komunikacji szeregowej, takich jak RS232, RS422 czy RS485. Układ ESP32 ma trzy identyczne kontrolery UART (UART0, UART1 i UART2). W przypadku płyt rozwojowych jeden z nich, zazwyczaj UART0, używany jest do przesyłania danych w czasie zapisu programu do pamięci FLASH, pozostałe mogą zostać użyte do komunikacji z urządzeniami zewnętrznymi.

Pokazany na listingu 5 program jest przykładem dostępnym w katalogu esp-idf-v4.4/examples/peripherals/uart/uart_echo. Program działa na zasadzie odpytywania (pollingu) danych wejściowych interfejsu UART. Po odebraniu jakichkolwiek danych zostaną one natychmiast odesłane tym samym kanałem UART. Procedura odpytywania działa w osobnym wątku echo_task(). Na początku wywoływane są procedury konfigurujące interfejs UART. Do konfiguracji używa się parametrów zdefiniowanych w pliku sdkonfig, znajdującym się w drzewie projektu. Plik sdkonfig można edytować po zaznaczeniu jego pozycji w zakładce Project Explorer i dwukrotnym kliknięciu lewym przyciskiem myszy. Po otwarciu okna konfiguratora i wybraniu pozycji Echo Example Configuration można ustawić takie parametry, jak: numer używanego interfejsu UART, wstępnie ustawiana szybkość transmisji, przypisanie wybranych portów I/O jako wyprowadzeń RXD i TXD. Procedura uart_driver_install() instaluje sterownik wybranego interfejsu UART, w przykładzie określa ona rozmiar pierścieniowego bufora odbiorczego na BUF_SIZE * 2 i wyłącza bufor nadawczy. Procedura uart_param_config() ustawia parametry komunikacji UART-a przekazywane strukturą uart_config. Z kolei procedura uart_set_pin() konfiguruje fizyczne piny GPIO, do których będzie podłączony interfejs UART. Jeżeli jakieś wyprowadzenia nie będą używane (tak jak w przykładzie RTS i CTS), należy zamiast numeru użyć makra UART_PIN_NO_CHANGE.

#include <stdio.h>
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "driver/uart.h"
#include "driver/gpio.h"
#include "sdkconfig.h"

/**
* This is an example which echos any data it receives on configured UART back to the sender,
* with hardware flow control turned off. It does not use UART driver event queue.
*
* – Port: configured UART
* – Receive (Rx) buffer: on
* – Transmit (Tx) buffer: off
* – Flow control: off
* – Event queue: off
* – Pin assignment: see defines below (See Kconfig)
*/

#define ECHO_TEST_TXD (CONFIG_EXAMPLE_UART_TXD)
#define ECHO_TEST_RXD (CONFIG_EXAMPLE_UART_RXD)
#define ECHO_TEST_RTS (UART_PIN_NO_CHANGE)
#define ECHO_TEST_CTS (UART_PIN_NO_CHANGE)

#define ECHO_UART_PORT_NUM (CONFIG_EXAMPLE_UART_PORT_NUM)
#define ECHO_UART_BAUD_RATE (CONFIG_EXAMPLE_UART_BAUD_RATE)
#define ECHO_TASK_STACK_SIZE (CONFIG_EXAMPLE_TASK_STACK_SIZE)

#define BUF_SIZE (1024)

static void echo_task(void *arg)
{
/* Configure parameters of an UART driver,
* communication pins and install the driver */
uart_config_t uart_config = {
.baud_rate = ECHO_UART_BAUD_RATE,
.data_bits = UART_DATA_8_BITS,
.parity = UART_PARITY_DISABLE,
.stop_bits = UART_STOP_BITS_1,
.flow_ctrl = UART_HW_FLOWCTRL_DISABLE,
.source_clk = UART_SCLK_APB,
};
int intr_alloc_flags = 0;

#if CONFIG_UART_ISR_IN_IRAM
intr_alloc_flags = ESP_INTR_FLAG_IRAM;
#endif

ESP_ERROR_CHECK(uart_driver_install(ECHO_UART_PORT_NUM, BUF_SIZE * 2, 0, 0, NULL, intr_alloc_flags));
ESP_ERROR_CHECK(uart_param_config(ECHO_UART_PORT_NUM, &uart_config));
ESP_ERROR_CHECK(uart_set_pin(ECHO_UART_PORT_NUM, ECHO_TEST_TXD, ECHO_TEST_RXD, ECHO_TEST_RTS, ECHO_TEST_CTS));

// Configure a temporary buffer for the incoming data
uint8_t *data = (uint8_t *) malloc(BUF_SIZE);

while (1) {
// Read data from the UART
int len = uart_read_bytes(ECHO_UART_PORT_NUM, data, BUF_SIZE, 20 / portTICK_RATE_MS);
// Write data back to the UART
uart_write_bytes(ECHO_UART_PORT_NUM, (const char *) data, len);
if (len !=0)uart_write_bytes(ECHO_UART_PORT_NUM, (const char *) "echo ok\r\n", 9);
}
}

void app_main(void)
{
xTaskCreate(echo_task, "uart_echo_task", ECHO_TASK_STACK_SIZE, NULL, 10, NULL);
}

Listing 5. Program do przetestowania interfejsu UART w trybie echa

Od tej chwili możliwy jest odbiór przesyłanych portem UART danych, które można odczytywać cyklicznie wywoływaną funkcją uart_read_bytes(). Funkcja przepisuje odebrane dane z pierścieniowego bufora odbiorczego – do utworzonego w programie bufora data[], do którego wskaźnik podany został jako parametr w wywołaniu funkcji. Funkcja zwraca także liczbę odebranych bajtów danych, wartość 0 oznacza brak nowych danych. W programie przykładowym odebrane bajty zapisane w buforze data[] odsyłane są tym samym UART-em jako echo, przy użyciu funkcji uart_write_bytes(). Następnie realizowany jest kolejny cykl odpytywania w pętli while(1).

W przykładzie pokazano najprostszy sposób korzystania z interfejsu UART. Informacje o bardziej wyrafinowanych metodach, opartych między innymi na przerwaniach, można znaleźć w dokumentacji [4] oraz w innych przykładach.

Ryszard Szymaniak, EP

Literatura: