【G32A1465测评】CFGIO_UART_Echo

只看该作者 · 2024-12-15 09:39

```
/*!
* @file       readme.txt
*
* @brief    示例描述
*
* @version    V1.0.0
*
* @date       2024-03-20
*
* @attention
*
*  版权所有 (C) 2024 Geehy 半导体
*
*  除非符合 GEEHY COPYRIGHT NOTICE (GEEHY SOFTWARE PACKAGE LICENSE)，否则您不得使用此文件。
*
*  本程序仅供参考，旨在希望对客户开发自己的软件有所帮助和指导。除非适用法律要求或书面同意，否则本程序按“原样”分发，没有任何明示或暗示的保证或条件。
*  有关许可下的权限和限制，请参阅 GEEHY SOFTWARE PACKAGE LICENSE。
*/

&par 示例描述

此示例展示了 CFGIO_UART 驱动程序的使用。
它使用 CFGIO_D2 和 CFGIO_D3 作为 UART 端口（波特率为 115200，8N1）。
它在启动时打印欢迎信息，并接受用户输入的命令以打开 LED。用户可以输入 "blue"、"green"、"red" 命令，然后蓝色、绿色或红色 LED 将被打开。

为了使此示例正常工作，必须进行以下连接：
  - RX: PTA1  (CFGIO_D3)
  - TX: PTA0  (CFGIO_D2)
  - GND

&par 硬件描述

&par 目录内容

&par IDE 环境

  - MDK-ARM V5.36.0.0
  - EWARM V8.50.5.26295

&par 硬件和软件环境

  - 此示例运行在 G32A1465 EVAL 设备上。中文逐行翻译结束。
```

```c
/* Includes */
#include "user_config.h"
#include "board.h"
#include <stdio.h>
#include <string.h>

/**
* @brief 宏定义，用于选择DMA或中断进行数据传输
*/
#define CFGIO_UART_USE_DMA 1

/**
* @brief 消息定义
*/
#define MSG_WELCOME "\r\nHello Gehy!\r\n"
#define MSG_NEW_LINE "\r\n> "
#define MSG_ERROR "\r\nUnknown command!"
#define MSG_HELP "\r\nEnter the following commands to switch on LED:\r\n red\r\n green\r\n blue\r\n"
#define MSG_RED_ON "\r\nSwitched on red LED"
#define MSG_GREEN_ON "\r\nSwitched on green LED"
#define MSG_BLUE_ON "\r\nSwitched on blue LED"

/**
* @brief 命令定义
*/
#define CMD_RED "red\r"
#define CMD_GREEN "green\r"
#define CMD_BLUE "blue\r"

/**
* @brief 接收缓冲区大小
*/
#define RX_BUFFER_SIZE 256
uint8_t g_rxBuffer[RX_BUFFER_SIZE];

/**
* @brief 当前接收缓冲区的索引
*/
uint32_t g_rxIndex = 0;

/**
* @brief 设备状态变量
*/
CFGIO_DEVICE_STATE_T g_cfgioDeviceState;
CFGIO_UART_STATE_T g_uartStateRx;
CFGIO_UART_STATE_T g_uartStateTx;

/**
* @brief 初始化时钟
*/
void main(void)
{
STATUS_T result = STATUS_ERROR;
bool stop = false;

// 初始化时钟
CLOCK_SYS_Init(g_clockConfigsArr, CLOCK_CONFIG_NUMS, g_clockCallbacksArr, CLOCK_CALLBACK_NUMS);
CLOCK_SYS_UpdateConfiguration(0U, CLOCK_MANAGER_POLICY_FORCIBLE);

// 初始化引脚和LED
PINS_Init(NUM_OF_CONFIGURED_PINS0, g_pinsConfig);
LED_Init();

#if CFGIO_UART_USE_DMA /* 如果使用DMA进行数据传输 */
/* 初始化DMA */
DMA_Init(&g_dmaController, &g_dmaConfig);
g_uartRxConfig.transferType = CFGIO_USE_DMA;
g_uartRxConfig.dmaChannel = 0;
g_uartTxConfig.transferType = CFGIO_USE_DMA;
g_uartTxConfig.dmaChannel = 1;
#endif /* CFGIO_UART_USE_DMA */

// 初始化CFGIO UART。115200波特率，8N1
CFGIO_InitDevice(CFGIO_UART_INSTANCE, &g_cfgioDeviceState);
CFGIO_UART_Init(CFGIO_UART_INSTANCE, &g_uartRxConfig, &g_uartStateRx);
CFGIO_UART_Init(CFGIO_UART_INSTANCE, &g_uartTxConfig, &g_uartStateTx);

// 发送欢迎信息、帮助信息和新行提示符
CFGIO_UART_TxDataBlocking(&g_uartStateTx, (uint8_t *)MSG_WELCOME, strlen(MSG_WELCOME), 100);
CFGIO_UART_TxDataBlocking(&g_uartStateTx, (uint8_t *)MSG_HELP, strlen(MSG_HELP), 100);
CFGIO_UART_TxDataBlocking(&g_uartStateTx, (uint8_t *)MSG_NEW_LINE, strlen(MSG_NEW_LINE), 100);

while (!stop)
{
      // 开始接收数据
      result = CFGIO_UART_RxDataBlocking(&g_uartStateRx, &g_rxBuffer[g_rxIndex], 1, 1000);

      // 超时，继续等待
      if (result == STATUS_TIMEOUT)
      {
         continue;
      }

      // 收到新字节的数据
      uint8_t rxByte = g_rxBuffer[g_rxIndex];
      if (rxByte == '\r')
      {
         // 如果按下回车键，处理接收到的命令并清空接收缓冲区
         ProcessCommand();
         ClearRxBuffer();
      }
      else
      {
         // 否则，发送回显字符并增加接收缓冲区索引
         CFGIO_UART_TxDataBlocking(&g_uartStateTx, &rxByte, 1, 100);
         g_rxIndex++;
      }

      // 如果接收缓冲区已满，清空接收缓冲区
      if (g_rxIndex == RX_BUFFER_SIZE)
      {
         ClearRxBuffer();
      }
}

// 关闭UART接口并点亮红色LED
CFGIO_UART_Deinit(&g_uartStateTx);
CFGIO_UART_Deinit(&g_uartStateRx);
LED_On(LED_RED);
}

/**
* @brief UART Rx回调函数
*/
void CFGIOUartRxCallback(void *driverState, UART_EVENT_T event, void *userData)
{
switch (event)
{
case UART_EVENT_RX_BUFFER_FULL:
      // Rx缓冲区满
      break;
case UART_EVENT_RX_TRANSFER_COMPLETE:
      // Rx完成
      break;
default:
      break;
}
}

/**
* @brief UART Tx回调函数
*/
void CFGIOUartTxCallback(void *driverState, UART_EVENT_T event, void *userData)
{
switch (event)
{
case UART_EVENT_TX_BUFFER_EMPTY:
      // Tx缓冲区空
      break;
case UART_EVENT_TX_TRANSFER_COMPLETE:
      // Tx完成
      break;
default:
      break;
}
}

/**
* @brief 处理命令函数
*/
void ProcessCommand(void)
{
if (strncmp((char *)g_rxBuffer, CMD_RED, strlen(CMD_RED)) == 0)
{
      // 切换红色LED亮起状态
      LED_On(LED_RED);
      LED_Off(LED_GREEN);
      LED_Off(LED_BLUE);
      CFGIO_UART_TxDataBlocking(&g_uartStateTx, (uint8_t *)MSG_RED_ON, strlen(MSG_RED_ON), 100);
}
else if (strncmp((char *)g_rxBuffer, CMD_GREEN, strlen(CMD_GREEN)) == 0)
{
      // 切换绿色LED亮起状态
      LED_On(LED_GREEN);
      LED_Off(LED_RED);
      LED_Off(LED_BLUE);
      CFGIO_UART_TxDataBlocking(&g_uartStateTx, (uint8_t *)MSG_GREEN_ON, strlen(MSG_GREEN_ON), 100);
}
else if (strncmp((char *)g_rxBuffer, CMD_BLUE, strlen(CMD_BLUE)) == 0)
{
      // 切换蓝色LED亮起状态
      LED_On(LED_BLUE);
      LED_Off(LED_RED);
      LED_Off(LED_GREEN);
      CFGIO_UART_TxDataBlocking(&g_uartStateTx, (uint8_t *)MSG_BLUE_ON, strlen(MSG_BLUE_ON), 100);
}
else if (g_rxBuffer[0] == '\r')
{
      // 直接按下回车键，不做任何操作
}
else
{
      // 未知命令，切换红色和绿色LED亮起状态，并发送错误信息
      LED_On(LED_RED);
      LED_On(LED_GREEN);
      LED_Off(LED_BLUE);
      CFGIO_UART_TxDataBlocking(&g_uartStateTx, (uint8_t *)MSG_ERROR, strlen(MSG_ERROR), 100);
}
// 打印新行提示符
CFGIO_UART_TxDataBlocking(&g_uartStateTx, (uint8_t *)MSG_NEW_LINE, strlen(MSG_NEW_LINE), 100);
}

/**
* @brief 清除接收缓冲区函数
*/
void ClearRxBuffer(void)
{
for (uint32_t i = 0; i < RX_BUFFER_SIZE; i++)
{
      g_rxBuffer = 0x00; // 将接收缓冲区清零
}
g_rxIndex = 0; // 重置接收缓冲区索引
}
```