STM32L例程03--串口输出usart及其printf重定向(基于cola_os)

最新推荐文章于 2024-06-19 09:16:56 发布
最新推荐文章于 2024-06-19 09:16:56 发布
阅读量1.8k 收藏 7
点赞数
分类专栏： STM32
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ziqi5543/article/details/102581740
版权

一、实验目的

1.实现串口信息打印。

2.每1s钟打印一次信息。

3.串口接收到数据，然后打印出来

一、实验步骤

1.CubeMax配置

配置PA9，PA10为串口输出，导出工程。

2.usart驱动创建

串口驱动实现原理：

中断接收到数据后通过事件通知应用层。

stm32_usart.c

#include "config.h"
#include "stm32l0xx_hal.h"
#include "cola_device.h"
#include "cola_os.h"
#include "config.h"
#include "usart.h"



#ifdef USING_USART1 

static cola_device_t usart1_dev;         //串口驱动函数
static task_t * usart1_depen_task = NULL;//当前串口所在的应用任务
static uint8_t data = 0; //用来暂时存放数据的，正常使用缓冲区，后期给出



#ifdef USING_DEBUG
int fputc(int ch, FILE *f)
{      
    HAL_UART_Transmit(&huart1, (uint8_t *)&ch, 1, 0xFF);
    return ch;
}
#endif


static void uart1_configuration(uint32_t bund)
{
    MX_USART1_UART_Init();
    huart1.Init.BaudRate = bund;
    HAL_UART_Init(&huart1);
    __HAL_UART_ENABLE_IT(&huart1, UART_IT_RXNE);
    __HAL_UART_ENABLE_IT(&huart1, UART_IT_ERR);
}

static void uart1_sendnbyte(uint8_t *pData, uint16_t Length)
{
    HAL_UART_Transmit(&huart1,pData,Length,0xFF);
}
static int uart1_write(cola_device_t *dev,int pos, const void *buffer, int size)
{
	uart1_sendnbyte((uint8_t *)buffer,size);
	return size;
}
static int uart1_read(cola_device_t *dev,int pos, void *buffer, int size)
{
    uint8_t *index = (uint8_t *)buffer;
    index[0] = data;
    return 1;

}

static void USART1_RECV_IRQHandler(UART_HandleTypeDef *huart)
{
    //uint8_t c;
    data = (uint8_t)(huart->Instance->RDR);
    if(usart1_depen_task)
        cola_set_event(usart1_depen_task,SIG_DATA);
}

static int uart1_config(cola_device_t *dev,void *pos,void *args)
{
    struct serial_configure *cfg = (struct serial_configure *)args;
    uart1_configuration(cfg->baud_rate);
    usart1_depen_task = (task_t *)pos;
    return 0;
}

static struct cola_device_ops uart1_ops =
{
    .write  = uart1_write,
    .read   = uart1_read,
    .config = uart1_config,
};

static void USER_UART1_IRQHandler(UART_HandleTypeDef *huart)
{
  uint32_t isrflags   = READ_REG(huart->Instance->ISR);
  uint32_t cr1its     = READ_REG(huart->Instance->CR1);
  uint32_t cr3its     = READ_REG(huart->Instance->CR3);

  uint32_t errorflags;
  uint32_t errorcode;

  /* If no error occurs */
  errorflags = (isrflags & (uint32_t)(USART_ISR_PE | USART_ISR_FE | USART_ISR_ORE | USART_ISR_NE));
  if (errorflags == 0U)
  {
    /* UART in mode Receiver ---------------------------------------------------*/
    if (((isrflags & USART_ISR_RXNE) != 0U)
        && ((cr1its & USART_CR1_RXNEIE) != 0U))
    {
      if (huart->RxISR != NULL)
      {
        huart->RxISR(huart);
        
      }
      USART1_RECV_IRQHandler(huart);
      return;
    }
  }

  /* If some errors occur */
  if ((errorflags != 0U)
      && (((cr3its & USART_CR3_EIE) != 0U)
          || ((cr1its & (USART_CR1_RXNEIE | USART_CR1_PEIE)) != 0U)))
  {
    /* UART parity error interrupt occurred -------------------------------------*/
    if (((isrflags & USART_ISR_PE) != 0U) && ((cr1its & USART_CR1_PEIE) != 0U))
    {
      __HAL_UART_CLEAR_FLAG(huart, UART_CLEAR_PEF);

      huart->ErrorCode |= HAL_UART_ERROR_PE;
    }

    /* UART frame error interrupt occurred --------------------------------------*/
    if (((isrflags & USART_ISR_FE) != 0U) && ((cr3its & USART_CR3_EIE) != 0U))
    {
      __HAL_UART_CLEAR_FLAG(huart, UART_CLEAR_FEF);

      huart->ErrorCode |= HAL_UART_ERROR_FE;
    }

    /* UART noise error interrupt occurred --------------------------------------*/
    if (((isrflags & USART_ISR_NE) != 0U) && ((cr3its & USART_CR3_EIE) != 0U))
    {
      __HAL_UART_CLEAR_FLAG(huart, UART_CLEAR_NEF);

      huart->ErrorCode |= HAL_UART_ERROR_NE;
    }

    /* UART Over-Run interrupt occurred -----------------------------------------*/
    if (((isrflags & USART_ISR_ORE) != 0U)
        && (((cr1its & USART_CR1_RXNEIE) != 0U) ||
            ((cr3its & USART_CR3_EIE) != 0U)))
    {
      __HAL_UART_CLEAR_FLAG(huart, UART_CLEAR_OREF);

      huart->ErrorCode |= HAL_UART_ERROR_ORE;
    }

    /* Call UART Error Call back function if need be --------------------------*/
    if (huart->ErrorCode != HAL_UART_ERROR_NONE)
    {
      /* UART in mode Receiver ---------------------------------------------------*/
      if (((isrflags & USART_ISR_RXNE) != 0U)
          && ((cr1its & USART_CR1_RXNEIE) != 0U))
      {
        if (huart->RxISR != NULL)
        {
          huart->RxISR(huart);
        }
      }

      /* If Overrun error occurs, or if any error occurs in DMA mode reception,
         consider error as blocking */
      errorcode = huart->ErrorCode;
      if ((HAL_IS_BIT_SET(huart->Instance->CR3, USART_CR3_DMAR)) ||
          ((errorcode & HAL_UART_ERROR_ORE) != 0U))
      {
        /* Blocking error : transfer is aborted
           Set the UART state ready to be able to start again the process,
           Disable Rx Interrupts, and disable Rx DMA request, if ongoing */
        //UART_EndRxTransfer(huart);

        /* Disable the UART DMA Rx request if enabled */
        if (HAL_IS_BIT_SET(huart->Instance->CR3, USART_CR3_DMAR))
        {
          CLEAR_BIT(huart->Instance->CR3, USART_CR3_DMAR);

          /* Abort the UART DMA Rx channel */
          if (huart->hdmarx != NULL)
          {
            /* Set the UART DMA Abort callback :
               will lead to call HAL_UART_ErrorCallback() at end of DMA abort procedure */
           // huart->hdmarx->XferAbortCallback = UART_DMAAbortOnError;

            /* Abort DMA RX */
            if (HAL_DMA_Abort_IT(huart->hdmarx) != HAL_OK)
            {
              /* Call Directly huart->hdmarx->XferAbortCallback function in case of error */
              huart->hdmarx->XferAbortCallback(huart->hdmarx);
            }
          }
          else
          {
            /* Call user error callback */
#if (USE_HAL_UART_REGISTER_CALLBACKS == 1)
            /*Call registered error callback*/
            huart->ErrorCallback(huart);
#else
            /*Call legacy weak error callback*/
            HAL_UART_ErrorCallback(huart);
#endif /* USE_HAL_UART_REGISTER_CALLBACKS */

          }
        }
        else
        {
          /* Call user error callback */
#if (USE_HAL_UART_REGISTER_CALLBACKS == 1)
          /*Call registered error callback*/
          huart->ErrorCallback(huart);
#else
          /*Call legacy weak error callback*/
          HAL_UART_ErrorCallback(huart);
#endif /* USE_HAL_UART_REGISTER_CALLBACKS */
        }
      }
      else
      {
        /* Non Blocking error : transfer could go on.
           Error is notified to user through user error callback */
#if (USE_HAL_UART_REGISTER_CALLBACKS == 1)
        /*Call registered error callback*/
        huart->ErrorCallback(huart);
#else
        /*Call legacy weak error callback*/
        HAL_UART_ErrorCallback(huart);
#endif /* USE_HAL_UART_REGISTER_CALLBACKS */
        huart->ErrorCode = HAL_UART_ERROR_NONE;
      }
    }
    return;

  } /* End if some error occurs */

  /* UART wakeup from Stop mode interrupt occurred ---------------------------*/
  if (((isrflags & USART_ISR_WUF) != 0U) && ((cr3its & USART_CR3_WUFIE) != 0U))
  {
    __HAL_UART_CLEAR_FLAG(huart, UART_CLEAR_WUF);

    /* UART Rx state is not reset as a reception process might be ongoing.
       If UART handle state fields need to be reset to READY, this could be done in Wakeup callback */

#if (USE_HAL_UART_REGISTER_CALLBACKS == 1)
    /* Call registered Wakeup Callback */
    huart->WakeupCallback(huart);
#else
    /* Call legacy weak Wakeup Callback */
    HAL_UARTEx_WakeupCallback(huart);
#endif /* USE_HAL_UART_REGISTER_CALLBACKS */
    return;
  }

  /* UART in mode Transmitter ------------------------------------------------*/
  if (((isrflags & USART_ISR_TXE) != 0U)
      && ((cr1its & USART_CR1_TXEIE) != 0U))
  {
    if (huart->TxISR != NULL)
    {
      huart->TxISR(huart);
    }
    return;
  }

  /* UART in mode Transmitter (transmission end) -----------------------------*/
  if (((isrflags & USART_ISR_TC) != 0U) && ((cr1its & USART_CR1_TCIE) != 0U))
  {
   // UART_EndTransmit_IT(huart);
    return;
  }

}

void USART1_IRQHandler(void)
{
  /* USER CODE BEGIN USART1_IRQn 0 */

  /* USER CODE END USART1_IRQn 0 */
  USER_UART1_IRQHandler(&huart1);
  /* USER CODE BEGIN USART1_IRQn 1 */

  /* USER CODE END USART1_IRQn 1 */
}

void usart_register(void)
{
#ifdef USING_USART1
    uart1_configuration(115200);
    
    usart1_dev.name = "usart1";
    usart1_dev.dops = &uart1_ops;
    cola_device_register(&usart1_dev);
#endif
}
device_initcall(usart_register);
#endif

3.usart应用

#include "cola_device.h"
#include "cola_os.h"
#include "example.h"


#ifdef APP_USART
static task_t timer_1s;
static task_t usart_task;
static cola_device_t *app_usart_dev;

//led每1s状态改变一次
static void timer_1s_cb(uint32_t event)
{
    os_log("app_usart running...\r\n");
}

//usart 主函数任务管理
static void usart_task_event(uint32_t event)
{
    uint8_t tmp[32] = {0};
    int err = 0;
    if(event & SIG_DATA)
    {
        err = cola_device_read(app_usart_dev,0,tmp,1);
        if(err)
        {
            cola_device_write(app_usart_dev,0,tmp,err);
        }
    }
    
}
static void usart_config(void)
{
    app_usart_dev = cola_device_find("usart1");
    assert(app_usart_dev);
    struct  serial_configure cfg;
    cfg.baud_rate = 9600;
    cola_device_config(app_usart_dev,&usart_task,&cfg);
}


void app_usart_init(void)
{
    cola_timer_create(&timer_1s,timer_1s_cb);
    cola_timer_start(&timer_1s,TIMER_ALWAYS,1000);
    cola_task_create(&usart_task,usart_task_event);
    usart_config();
}

#endif

四、运行调试

五、总结

串口使用115200时，接收打印时会出现丢包，串口接收最好配合环形缓冲区使用，加缓冲区方式会在后期例程中讲解。

gitHub:https://github.com/sckuck-bit/stm32l0_demo

sunny.Bit
关注
专栏目录
STM32 USART——printf重定向
晓暮落枫的博客
01-09 1726
串口通信：是一种设备间常用的串行，以比特位形式收发数据，电子工程师经常使用这种方式调试。 程序设计 PA9（TX），PA10（RX） 参考帮助文档STM32F4xx_StdPeriph_Examples/USART/USART_Printf/main.c 需要修改 Edit->Options for Target->target->Code Generation->Use ...
stm32l151c8t6开发板全套例程
04-28
stm32l151c8t6开发板全套程序，包含ADC、GPIO低功耗模式，网卡控制等功能。keil5可以直接编译不加任何修改，其他版本没试过。
STM32L例程
01-08
STM32L的官方例程，包括ADC,DAC,EXTI,I2C,GPIO,USART等26个例程
STM32l0XX示例代码
08-02
STM32l0XX示例代码，基于HAL库（这个很少） 17个大类，接近100个示例 包括了ADC,DAC,PWR,CRC等
STM32学习笔记（九）--串口 UART/USART详解
最新发布
weixin_64593595的博客
06-19 725
UART (Universal Asynchronous Receiver/Transmitter) 是一种异步串行通信协议，不依赖于共享时钟信号。 USART (Universal Synchronous/Asynchronous Receiver/Transmitter) 支持同步和异步两种通信模式，比UART功能更强大。
STM32L0系列例程.zip
04-24
STM32L0系列官方例程库，包含了所有外设的例程 包含有Freertos操作系统，方便二次开发移植。。 该例程库支持以下型号 STM32L053xx,STM32L052xx,STM32L051xx and STM32L063xx,STM32L062xx,STM32L061xx STM32L073xx,STM32L072xx,STM32L071xx and STM32L083xx,STM32L082xx,STM32L081xx STM32L031xx and STM32L041xx
USART.rar_STM32串口例程_USART STM32_stm32 usart_stm32 串口输入_stm32串口
09-19
STM32串口，全称为通用同步/异步收发传输器（Universal Synchronous/Asynchronous Receiver/Transmitter），是微控制器中常见的通信接口之一，广泛应用于数据传输和设备调试。在STM32系列微控制器中，USART功能强大...
探索者 串口实验USART3收发.zip_STM32 F4 串口_Stm32-USART3_stm32 USART3_stm32
07-14
USART3（通用同步/异步收发传输器3）是STM32芯片中的一种串行通信接口，支持全双工操作，允许同时进行发送和接收。 配置USART3时，我们需要注意以下关键步骤： 1. **时钟使能**：确保USART3的时钟被正确使能。在...
21-USART—串口通信.rar_STM32 串口例程_STM32串口通信_burnlt2_goldenw4s_stm32 R
09-21
野火STM32开发板USART串口通信例程
STM32L051C8T6-STOP模式-按键、串口可唤醒_stm32l051例程_st.stop按键_STM32L051低功耗
10-08
在本例程中，我们将探讨如何使用STM32L051C8T6进入STOP模式并实现通过按键和串口两种方式的唤醒功能。 STOP模式是STM32的一种低功耗运行模式，其中CPU停止工作，内核电压降低，但SRAM和寄存器中的数据得以保留。...
Stm32Usart.zip_STM32 串口例程_STM32USART_STM32串口例程
09-14
在STM32的众多外设中，通用异步收发传输器（USART）是进行串行通信的重要接口，适用于数据交换和调试。本文将详细阐述STM32串口（USART）的工作原理、配置步骤以及如何在Keil开发环境中实现串口通信。 1. **STM32...
STM32L151标准库例程.rar
06-09
资料里面包含的有10个标准库例程的代码，每一个都经过验证，可以直接下载使用，为你省去繁琐的移植过程。
stm32L151例程库函数版
06-06
STM32L151开发例程，库函数版（V1.1.0），方便大家学习参考。
stm32L151c8t6 USART1例程
08-27
stm32L151c8t6 USART1例程 可以参考，因为发现L系列的资料比较少， 所以分享给大家，这是第一次在csdn上传资料，自感惭愧，
STM32L476串口收发程序
03-12
STM32L476串口收发程序，本程序可以实现与电脑互相收发通讯；如有疑问请假1163834435提问
cola_os_lora.zip
02-01
LoRa开发|LoRa（SX1276/8）串口透传代码-将LoRa封装成单独的驱动,目前网络上的代码很多也很多，根本不适合学习或者是项目使用，很有有代码对程序框架有所追求。
STM32L051使用HAL库操作实例（4）-串口实验
cheng_nnan的博客
04-16 5691
一、STM32CubeMX配置（本文使用的STM32CubeMX版本为5.6.0） 思路：使用中断控制方式，当串口接收到数据时，再将接收到的数据发送出去1.MCU选型 本例程使用的为STM32L051C8T6型号2.使能时钟3.设置GPIO口（本例使用的为串口1，板载自带USB转串口芯片）4.引脚配置 实现步骤：按下KEY1点亮LED1，按下KEY2点亮LED2,按下KEY3点亮LED3，再按下K...
STM32学习笔记（5）：调试信息输出
JasonLi的博客
01-18 1104
将printf和log函数重定向绑定串口收发，使得在调试过程中更方便。
重定向printf函数到串口输出的多种方法
热门推荐
guan19981003的博客
10-08 1万+
本文详细的介绍了如何重定向printf输出到串口输出的多种方法，包括调用MDK微库（MicroLib）的方法，调用标准库的方法，以及适用于 GNUC 系列编译器的方法。 1.printf与fputc 对于 printf 函数相信大家都不陌生，第一个C语言程序就是使用 printf 函数在屏幕上的控制台打印出Hello World，之后使用 printf 函数输出各种类型的数据，使用格式控制输出各种长度的字符，甚至输出各种各样的图案。 除此之外，在程序出错的时候，懒得调试，直接简单粗暴的加个 print
STM32L053开发板串口printf程序实战与GPIO配置
本文主要介绍了如何在STM32L053开发板上使用printf函数编写串口程序。作者首先强调了STM32L053官方例程在处理串口通信方面可能存在不便，并分享了自己的修改方案以适应F1系列常见的编程风格。以下是文章的关键知识点...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值