RT Thread Studio创建USB虚拟串口工程

最新推荐文章于 2025-06-13 00:15:00 发布

原创最新推荐文章于 2025-06-13 00:15:00 发布 · 598 阅读

11 ·

CC 4.0 BY-SA版权

文章标签：

#stm32

MCU型号：STM32F103RET6

1.生成一个带串口输出的工程文件，新建RT-Thread项目工程文件。
在这里插入图片描述
2.查看电路图中的串口输出管脚，根据STMCubeMx软件可知此串口为USART1，选择芯片型号为STM32F103RET6，控制台串口选择UART1，发送脚：PB6，接收脚：PB7

3.设置下载bin文件的下载地址为：0x08000000。

4.代码编译后下载到电路板，连上串口调试助手可看到调试信息。
在这里插入图片描述
5.打开RT-Thread Settings设置设备驱动中的USB，USB设置如图所示，设置完成之后，记得保存，否则设置无效。

6.查看原理图中的外部晶振大小，由图可知为8MHz。

7.打开CubeMx_Settings配置USB虚拟串口。

8.配置外部晶振，配置USB，重新配置外部时钟，配置完之后生成工程文件
在这里插入图片描述

9.删除usb_device.h，usbd_cdc_if.h，usbd_conf.h，usbd_desc.h文件，去掉main.c文件中的#include “usb_device.h”

在这里插入图片描述

10.在stm32f1xx_hal_conf.h打开宏定义HAL_UART_MODULE_ENABLED.
在这里插入图片描述
11.1.将usbd_conf.c文件中的void HAL_PCD_MspInit(PCD_HandleTypeDef* pcdHandle)和HAL_PCD_MspDeInit(PCD_HandleTypeDef* pcdHandle)拷贝到stm32f1xx_hal_msp.c文件中。

void HAL_PCD_MspInit(PCD_HandleTypeDef* pcdHandle)
{
  if(pcdHandle->Instance==USB)
  {
  /* USER CODE BEGIN USB_MspInit 0 */

  /* USER CODE END USB_MspInit 0 */
    /* Peripheral clock enable */
    __HAL_RCC_USB_CLK_ENABLE();

    /* Peripheral interrupt init */
    HAL_NVIC_SetPriority(USB_HP_CAN1_TX_IRQn, 5, 0);
    HAL_NVIC_EnableIRQ(USB_HP_CAN1_TX_IRQn);
    HAL_NVIC_SetPriority(USB_LP_CAN1_RX0_IRQn, 5, 0);
    HAL_NVIC_EnableIRQ(USB_LP_CAN1_RX0_IRQn);
  /* USER CODE BEGIN USB_MspInit 1 */

  /* USER CODE END USB_MspInit 1 */
  }
}

void HAL_PCD_MspDeInit(PCD_HandleTypeDef* pcdHandle)
{
  if(pcdHandle->Instance==USB)
  {
  /* USER CODE BEGIN USB_MspDeInit 0 */

  /* USER CODE END USB_MspDeInit 0 */
    /* Peripheral clock disable */
    __HAL_RCC_USB_CLK_DISABLE();

    /* Peripheral interrupt Deinit*/
    HAL_NVIC_DisableIRQ(USB_HP_CAN1_TX_IRQn);

    HAL_NVIC_DisableIRQ(USB_LP_CAN1_RX0_IRQn);

  /* USER CODE BEGIN USB_MspDeInit 1 */

  /* USER CODE END USB_MspDeInit 1 */
  }
}

12.在board.h文件中开启BSP_USING_USBDEVICE，#define BSP_USING_USBDEVICE。
在这里插入图片描述
13.编译程序，烧录到电路板中，插上USB，在电脑中可显示端口号。

14.新建usbd_vcom.h和usbd_vcom.c文件，实现USB虚拟串口数据的发送和接收。
usbd_vcom.h

#ifndef __USBD_VCOM_H__
#define __USBD_VCOM_H__

#include <rtthread.h>

typedef struct
{
#define USBD_VCOM_THREAD_STACK_SIZE   1024
#define USBD_VCOM_THREAD_PRIO         15
#define USBD_VCOM_THREAD_TICK         10
    struct rt_semaphore sem_rx;
    rt_thread_t thread_rx;
    uint8_t is_running_rx;
}usbd_vcom_rtos_t;

typedef struct
{
    rt_device_t dev;
    usbd_vcom_rtos_t rtos;
}usbd_vcom_t;

extern usbd_vcom_t usbd_vcom;

#define usbd_vcom_get_dev() usbd_vcom.dev

rt_err_t usbd_vcom_drive_init(void);
rt_err_t usbd_vcom_rx_call(rt_device_t dev, rt_size_t size);
rt_err_t usbd_vcom_init(void);
void usbd_vcom_thread_rx(void *para);
#endif

usbd_vcom.c文件

#include "usbd_vcom.h"

usbd_vcom_t usbd_vcom;

rt_err_t usbd_vcom_drive_init(void)
{
    rt_device_t *ps_dev=&usbd_vcom.dev;
    rt_err_t result = RT_EOK;

    *ps_dev = rt_device_find("vcom");
    if (!(*ps_dev))
    {
        return RT_ERROR;
    }

    result = rt_device_open(*ps_dev, RT_DEVICE_FLAG_RDWR | RT_DEVICE_FLAG_INT_RX);
    if (result != RT_EOK)
    {
        return RT_ERROR;
    }

    rt_device_set_rx_indicate(*ps_dev, usbd_vcom_rx_call);

    return RT_EOK;
}

rt_err_t usbd_vcom_rx_call(rt_device_t dev, rt_size_t size)
{
    usbd_vcom_rtos_t *ps_rtos=&usbd_vcom.rtos;

    if (0 == ps_rtos->is_running_rx)
    {
        return RT_ERROR;
    }

    rt_sem_release(&ps_rtos->sem_rx);

    return RT_EOK;
}

rt_err_t usbd_vcom_init(void)
{
    usbd_vcom_t *ps_handle=&usbd_vcom;
    usbd_vcom_rtos_t *ps_rtos=&ps_handle->rtos;
    rt_err_t result = RT_EOK;

    memset(ps_handle,0,sizeof(usbd_vcom_t));
    result = usbd_vcom_drive_init();
    if(result!=RT_EOK)
    {
        return RT_ERROR;
    }

    result = rt_sem_init(&ps_rtos->sem_rx, "usbd_vcom_sem_rx", 0, RT_IPC_FLAG_FIFO);
    if(result!=RT_EOK)
    {
        return RT_ERROR;
    }

    ps_rtos->thread_rx = rt_thread_create("usbd_vcom_thread_rx", usbd_vcom_thread_rx, ps_handle, USBD_VCOM_THREAD_STACK_SIZE, USBD_VCOM_THREAD_PRIO, USBD_VCOM_THREAD_TICK);
    if (ps_rtos->thread_rx == RT_NULL)
    {
        return RT_ERROR;
    }

    rt_thread_startup(ps_rtos->thread_rx);
}

void usbd_vcom_thread_rx(void *para)
{
    usbd_vcom_t *ps_handle=(usbd_vcom_t*)para;
    usbd_vcom_rtos_t *ps_rtos=&ps_handle->rtos;
    uint8_t b_data=0;

    ps_rtos->is_running_rx=1;

    while (ps_rtos->is_running_rx)
    {
        while (rt_device_read(ps_handle->dev, -1, &b_data, 1) != 1)
        {
            rt_sem_take(&ps_rtos->sem_rx, RT_WAITING_FOREVER);
        }
        rt_device_write(ps_handle->dev, 0, &b_data, 1);
    }
}