5. STM32. Программирование STM32F103. USART

18.08.2016

Мы уже использовали последовательный порт для программирования микроконтроллера. Теперь применим его по прямому назначению. У STM32F103 есть 3 последовательных USART порта. Мы рассмотрим пример с USART1. Остальные порты работают аналогично. В этом примере мы подключим микроконтроллер к компьютеру с помощью UART-USB переходника и будем использовать терминальную программу для передачи команд микроконтроллеру.

Схема

STM32F103_UART

На компьютере будем использовать терминальную программу Putty. Можно любую другую, которая работает с последовательным портом. Рассмотрим пример для STM32, который будет работать как простенький терминал: принимать команды с компьютера и обрабатывать их. Команды будут две: ON, OFF. Конечно, они будут включать и выключать светодиод на плате. Полный текст программы приведен в конце статьи, а сейчас разберем как это работает.

Инициализация USART1

Инициализация USART1 выполняется следующим образом:
  • Включаем тактирование модуля USART1 и порта GPIOA (ноги TX и RX USART1 подключены к - PA9, PA10). О тактировании говорилось в предыдущей статье.
  • Конфигурируем NVIC. NVIC - контроллер приоритетных векторных прерываний. О нем будет отдельный разговор. Сегодня надо усвоить, что все прерывания настраиваются в NVIC.
  • Конфигурируем GPIO (PA9, PA10). Это ноги TX и RX.
  • Конфигурируем USART1
  • Включаем USART1
  • Включаем прерывания, которое срабатывает при поступлении байта в USART1.
Код инициализации (см. функцию usart_init):


void usart_init(void)
{
	/* Enable USART1 and GPIOA clock */
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1 | RCC_APB2Periph_GPIOA, ENABLE);

	/* NVIC Configuration */
	NVIC_InitTypeDef NVIC_InitStructure;
	/* Enable the USARTx Interrupt */
	NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn;
	NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
	NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
	NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
	NVIC_Init(&NVIC_InitStructure);

	/* Configure the GPIOs */
	GPIO_InitTypeDef GPIO_InitStructure;

	/* Configure USART1 Tx (PA.09) as alternate function push-pull */
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_Init(GPIOA, &GPIO_InitStructure);

	/* Configure USART1 Rx (PA.10) as input floating */
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
	GPIO_Init(GPIOA, &GPIO_InitStructure);

	/* Configure the USART1 */
	USART_InitTypeDef USART_InitStructure;

	/* USART1 configuration ------------------------------------------------------*/
	/* USART1 configured as follow:
		- BaudRate = 115200 baud
		- Word Length = 8 Bits
		- One Stop Bit
		- No parity
		- Hardware flow control disabled (RTS and CTS signals)
		- Receive and transmit enabled
		- USART Clock disabled
		- USART CPOL: Clock is active low
		- USART CPHA: Data is captured on the middle
		- USART LastBit: The clock pulse of the last data bit is not output to
			the SCLK pin
	 */
	USART_InitStructure.USART_BaudRate = 115200;
	USART_InitStructure.USART_WordLength = USART_WordLength_8b;
	USART_InitStructure.USART_StopBits = USART_StopBits_1;
	USART_InitStructure.USART_Parity = USART_Parity_No;
	USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
	USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;

	USART_Init(USART1, &USART_InitStructure);

	/* Enable USART1 */
	USART_Cmd(USART1, ENABLE);

	/* Enable the USART1 Receive interrupt: this interrupt is generated when the
		USART1 receive data register is not empty */
	USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);
}

Как видно из кода инициализации, порт USART1 будет работать на скорости 115200. В настройке консольной программы нужно указать такую же скорость порта.

Разбор программы

Теперь посмотрим что происходит, когда микроконтроллер получает от компьютера байт (см. USART1_IRQHandler).


void USART1_IRQHandler(void)
{
    if ((USART1->SR & USART_FLAG_RXNE) != (u16)RESET)
	{
    		RXc = USART_ReceiveData(USART1);
    		RX_BUF[RXi] = RXc;
    		RXi++;

    		if (RXc != 13) {
    			if (RXi > RX_BUF_SIZE-1) {
    				clear_RXBuffer();
    			}
    		}
    		else {
    			RX_FLAG_END_LINE = 1;
    		}

			//Echo
    		USART_SendData(USART1, RXc);
	}
}

Прежде всего мы проверяем, флаг USART_FLAG_RXNE


if ((USART1->SR & USART_FLAG_RXNE) != (u16)RESET)

и убеждаемся, что прилетел байт. Обработчик прерываний USART1_IRQHandler может вызываться и другими событиями. Затем полученный символ сохраняем в RX_BUF, проверяя переполнения буфера. Если прилетает конец строки (символ с кодом 13), то есть в консоли терминала нажали клавишу Enter, тогда выставляем наш флажок RX_FLAG_END_LINE. По нему мы будем знать, что нужно разобрать строку набранную в консоли терминала (то есть, пришло время разобрать содержимое буфера RX_BUF), и, если в буфере будет известная команда (ON или OFF) - выполнить ее.

Обратите внимание, что в обработчике прерываний USART1_IRQHandler мы не будем выполнять довольно тяжелую процедуру обработки команд. Мы только установим флажок, а обработку будем делать в основном цикле программы. Это делается для того, чтобы как можно быстрее завершить обработку прерывания, так как могут ждать обработки другие прерывания. STM32 имеет приоритеты прерываний и обработка прерывания может быть прервана прерыванием с большим приоритетом. Но, несмотря на это, лучше, чтобы обработка прерываний выполнялась так быстро, как это возможно.

Последняя команда в процедуре обработки прерывания:


...
USART_SendData(USART1, RXc);
...

отправляет принятый символ обратно в терминал, то есть выполняет функцию Echo.

Теперь рассмотрим что происходит в главном цикле программы.


...
    while (1)
    {
        if (RX_FLAG_END_LINE == 1) {
            // Reset END_LINE Flag
            RX_FLAG_END_LINE = 0;
 
            USARTSend("\r\nI has received a line:\r\n");
            USARTSend(RX_BUF);
            USARTSend("\r\n");
 
            if (strncmp(strupr(RX_BUF), "ON\r", 3) == 0) {
                USARTSend("\r\nTHIS IS A COMMAND \"ON\"!!!\r\n");
                GPIO_ResetBits(GPIOC, GPIO_Pin_13);
            }
 
            if (strncmp(strupr(RX_BUF), "OFF\r", 4) == 0) {
                USARTSend("\r\nTHIS IS A COMMAND \"OFF\"!!!\r\n");
                GPIO_SetBits(GPIOC, GPIO_Pin_13);
            }
 
            clear_RXBuffer();
        }
    }
...

Мы ожидаем, когда будет нажат Enter, проверяя наш флаг RX_FLAG_END_LINE:


if (RX_FLAG_END_LINE == 1)

Когда он прилетает, в консоль терминала выводится строка которую мы будем анализировать:


USARTSend(RX_BUF);

А потом проверяем принятую строку и, если это одна из известных команд, - включаем или выключаем светодиод:


if (strncmp(strupr(RX_BUF), "ON\r", 3) == 0) {



if (strncmp(strupr(RX_BUF), "OFF\r", 4) == 0) {

Полный текст программы


#include "stm32f10x.h"
#include "stm32f10x_gpio.h"
#include "stm32f10x_rcc.h"
#include "stm32f10x_usart.h"
#include "misc.h"
#include <string.h>
 
#define RX_BUF_SIZE 80
volatile char RX_FLAG_END_LINE = 0;
volatile char RXi;
volatile char RXc;
volatile char RX_BUF[RX_BUF_SIZE] = {'\0'};
volatile char buffer[80] = {'\0'};
 
void clear_RXBuffer(void) {
    for (RXi=0; RXi<RX_BUF_SIZE; RXi++)
        RX_BUF[RXi] = '\0';
    RXi = 0;
}
 
void usart_init(void)
{
    /* Enable USART1 and GPIOA clock */
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1 | RCC_APB2Periph_GPIOA, ENABLE);
 
    /* NVIC Configuration */
    NVIC_InitTypeDef NVIC_InitStructure;
    /* Enable the USARTx Interrupt */
    NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn;
    NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
    NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
    NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    NVIC_Init(&NVIC_InitStructure);
 
    /* Configure the GPIOs */
    GPIO_InitTypeDef GPIO_InitStructure;
 
    /* Configure USART1 Tx (PA.09) as alternate function push-pull */
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_Init(GPIOA, &GPIO_InitStructure);
 
    /* Configure USART1 Rx (PA.10) as input floating */
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
    GPIO_Init(GPIOA, &GPIO_InitStructure);
 
    /* Configure the USART1 */
    USART_InitTypeDef USART_InitStructure;
 
    /* USART1 configuration ------------------------------------------------------*/
    /* USART1 configured as follow:
        - BaudRate = 115200 baud
        - Word Length = 8 Bits
        - One Stop Bit
        - No parity
        - Hardware flow control disabled (RTS and CTS signals)
        - Receive and transmit enabled
        - USART Clock disabled
        - USART CPOL: Clock is active low
        - USART CPHA: Data is captured on the middle
        - USART LastBit: The clock pulse of the last data bit is not output to
            the SCLK pin
     */
    USART_InitStructure.USART_BaudRate = 115200;
    USART_InitStructure.USART_WordLength = USART_WordLength_8b;
    USART_InitStructure.USART_StopBits = USART_StopBits_1;
    USART_InitStructure.USART_Parity = USART_Parity_No;
    USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
    USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;
 
    USART_Init(USART1, &USART_InitStructure);
 
    /* Enable USART1 */
    USART_Cmd(USART1, ENABLE);
 
    /* Enable the USART1 Receive interrupt: this interrupt is generated when the
        USART1 receive data register is not empty */
    USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);
}
 
void USART1_IRQHandler(void)
{
    if ((USART1->SR & USART_FLAG_RXNE) != (u16)RESET)
    {
            RXc = USART_ReceiveData(USART1);
            RX_BUF[RXi] = RXc;
            RXi++;
 
            if (RXc != 13) {
                if (RXi > RX_BUF_SIZE-1) {
                    clear_RXBuffer();
                }
            }
            else {
                RX_FLAG_END_LINE = 1;
            }
 
            //Echo
            USART_SendData(USART1, RXc);
    }
}
 
void USARTSend(const unsigned char *pucBuffer)
{
    while (*pucBuffer)
    {
        USART_SendData(USART1, *pucBuffer++);
        while(USART_GetFlagStatus(USART1, USART_FLAG_TC) == RESET)
        {
        }
    }
}
 
void SetSysClockTo72(void)
{
    ErrorStatus HSEStartUpStatus;
    /* SYSCLK, HCLK, PCLK2 and PCLK1 configuration -----------------------------*/
    /* RCC system reset(for debug purpose) */
    RCC_DeInit();
 
    /* Enable HSE */
    RCC_HSEConfig( RCC_HSE_ON);
 
    /* Wait till HSE is ready */
    HSEStartUpStatus = RCC_WaitForHSEStartUp();
 
    if (HSEStartUpStatus == SUCCESS)
    {
        /* Enable Prefetch Buffer */
        //FLASH_PrefetchBufferCmd( FLASH_PrefetchBuffer_Enable);
 
        /* Flash 2 wait state */
        //FLASH_SetLatency( FLASH_Latency_2);
 
        /* HCLK = SYSCLK */
        RCC_HCLKConfig( RCC_SYSCLK_Div1);
 
        /* PCLK2 = HCLK */
        RCC_PCLK2Config( RCC_HCLK_Div1);
 
        /* PCLK1 = HCLK/2 */
        RCC_PCLK1Config( RCC_HCLK_Div2);
 
        /* PLLCLK = 8MHz * 9 = 72 MHz */
        RCC_PLLConfig(0x00010000, RCC_PLLMul_9);
 
        /* Enable PLL */
        RCC_PLLCmd( ENABLE);
 
        /* Wait till PLL is ready */
        while (RCC_GetFlagStatus(RCC_FLAG_PLLRDY) == RESET)
        {
        }
 
        /* Select PLL as system clock source */
        RCC_SYSCLKConfig( RCC_SYSCLKSource_PLLCLK);
 
        /* Wait till PLL is used as system clock source */
        while (RCC_GetSYSCLKSource() != 0x08)
        {
        }
    }
    else
    { /* If HSE fails to start-up, the application will have wrong clock configuration.
     User can add here some code to deal with this error */
 
        /* Go to infinite loop */
        while (1)
        {
        }
    }
}
 
int main(void)
{
    // Set System clock
    SetSysClockTo72();
 
    /* Initialize LED which connected to PC13 */
    GPIO_InitTypeDef  GPIO_InitStructure;
    // Enable PORTC Clock
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOC, ENABLE);
    /* Configure the GPIO_LED pin */
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_13;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_Init(GPIOC, &GPIO_InitStructure);
 
    GPIO_ResetBits(GPIOC, GPIO_Pin_13); // Set C13 to Low level ("0")
 
    // Initialize USART
    usart_init();
    USARTSend(" Hello.\r\nUSART1 is ready.\r\n");
 
    while (1)
    {
        if (RX_FLAG_END_LINE == 1) {
            // Reset END_LINE Flag
            RX_FLAG_END_LINE = 0;
 
            USARTSend("\r\nI has received a line:\r\n");
            USARTSend(RX_BUF);
            USARTSend("\r\n");
 
            if (strncmp(strupr(RX_BUF), "ON\r", 3) == 0) {
                USARTSend("\r\nTHIS IS A COMMAND \"ON\"!!!\r\n");
                GPIO_ResetBits(GPIOC, GPIO_Pin_13);
            }
 
            if (strncmp(strupr(RX_BUF), "OFF\r", 4) == 0) {
                USARTSend("\r\nTHIS IS A COMMAND \"OFF\"!!!\r\n");
                GPIO_SetBits(GPIOC, GPIO_Pin_13);
            }
 
            clear_RXBuffer();
        }
    }
}

Желаю успехов!

Смотри также:

Коментарі:

Додати коментар

* - обов'язкові поля

Категорії

Недавні записи

Tags

bldc brushless stm32 motor web html css flask atmega foc git java-script pmsm raspberry-pi python websocket mongodb esp8266 nodemcu st-link tim timer docker ngnix programmator ssd1331 ssd1306 wifi uart meteo bme280 bmp280 i2c gps mpu-6050 mpu-9250 sensors 3d-printer options usb barometer remap watchdog flash eeprom rtc bkp encoder pwm servo capture examples dma adc nvic usart gpio books battery dc-dc sms max1674 avr lcd dht11 piezo rs-232 rfid solar exti bluetooth eb-500 displays ethernet led smd soldering mpx4115a hih-4000

Архіви