STM32快速实现USB虚拟串口+回环测试+USB转TTL的功能

心已赠人 2022-10-22 13:57 673阅读 0赞

# STM32快速实现USB虚拟串口+回环测试+USB转TTL的功能 #

--------------------

### 目录 ###

*  STM32快速实现USB虚拟串口+回环测试+USB转TTL的功能
 *   *   *   *  1、配置时钟
             *  2、开启USB
             *  3、开启USB设备：虚拟串口
             *  4、生成工程
             *  5、修改代码实现回环收发数据测试
             *  6、实现USB转串口功能

**环境：**

*  STM32F103RB
 *  STM32CUBEIDE1.5.1

--------------------

#### 1、配置时钟 ####

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxMTUzNDcxNTAz_size_16_color_FFFFFF_t_70]

#### 2、开启USB ####

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxMTUzNDcxNTAz_size_16_color_FFFFFF_t_70 1]

#### 3、开启USB设备：虚拟串口 ####

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxMTUzNDcxNTAz_size_16_color_FFFFFF_t_70 2]

#### 4、生成工程 ####

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxMTUzNDcxNTAz_size_16_color_FFFFFF_t_70 3]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxMTUzNDcxNTAz_size_16_color_FFFFFF_t_70 4]

#### 5、修改代码实现回环收发数据测试 ####

在`usbd_cdc_if.c`文件中新定义一个结构体：

USBD_CDC_LineCodingTypeDef USBD_CDC_LineCoding =
    { 
    	115200,      // 默认波特率
    	0X00,        // 1位停止位
    	0X00,        // 无奇偶校
    	0X08,        // 无流控，8bit数据位
    };

找到`CDC_Control_FS`函数，找到`CDC_SET_LINE_CODING`和`CDC_GET_LINE_CODING`分支，添加以下代码：  
（CDC\_SET\_LINE\_CODING：你在用串口助手选择波特率时候，STM32就会调用这个分支进行修改USB波特率）  
（CDC\_GET\_LINE\_CODING：获取STM32的USB波特率）

case CDC_SET_LINE_CODING:
        	USBD_CDC_LineCoding.bitrate = (pbuf[3] << 24) | (pbuf[2] << 16) | (pbuf[1] << 8) | pbuf[0];
        	USBD_CDC_LineCoding.format = pbuf[4];
        	USBD_CDC_LineCoding.paritytype = pbuf[5];
        	USBD_CDC_LineCoding.datatype = pbuf[6];
        break;
    
        case CDC_GET_LINE_CODING:
        	pbuf[0] = (uint8_t)(USBD_CDC_LineCoding.bitrate);
        	pbuf[1] = (uint8_t)(USBD_CDC_LineCoding.bitrate >> 8);
        	pbuf[2] = (uint8_t)(USBD_CDC_LineCoding.bitrate >> 16);
        	pbuf[3] = (uint8_t)(USBD_CDC_LineCoding.bitrate >> 24);
        	pbuf[4] = USBD_CDC_LineCoding.format;
        	pbuf[5] = USBD_CDC_LineCoding.paritytype;
        	pbuf[6] = USBD_CDC_LineCoding.datatype;
        break;

如下图所示：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxMTUzNDcxNTAz_size_16_color_FFFFFF_t_70 5]

找到`CDC_Receive_FS`函数，这个函数如果USB虚拟串口数据收到就会被调用，我们在这个函数中将收到的数据在发回去，只需要添加`CDC_Transmit_FS(Buf, *Len);`这一句即可，如下图：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxMTUzNDcxNTAz_size_16_color_FFFFFF_t_70 6]  
然后编译工程并下载，接上USB之后，设备管理器COM出现一个新的端口：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxMTUzNDcxNTAz_size_16_color_FFFFFF_t_70 7]

我们使用串口调试助手给它发数据：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxMTUzNDcxNTAz_size_16_color_FFFFFF_t_70 8]

#### 6、实现USB转串口功能 ####

发数据流程：串口调试助手发送数据->STM32的USB数据接收->STM32转发到串口3  
收数据流程：STM32的串口3收到数据->转发到USB->STM32的USB发送到串口调试助手

第一步先在这里加入串口3的初始化操作：  
![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxMTUzNDcxNTAz_size_16_color_FFFFFF_t_70 9][]

贴一下串口3的初始化代码，这里我用到了队列，因为实际测试发现串口3接收数据量比较大的话，那么转发到USB虚拟串口的时候会丢数据，所以这里采用了缓存队列，当串口接收到的数据到达一定数据量之后才做一次转发到USB的操作，并且开启了空闲中断，作用是转发最后一包数据：

关于队列的使用可以查看我的另一篇博客：[C/C++语言实现的一个缓存队列][C_C]

/* * myusart.c * * Created on: Mar 22, 2021 * Author: hello */
    #include "myusart.h"
    #include "myqueue.h"
    
    // 队列大小，定义为USB_CDC的发送包大小
    #define QUEUE_SIZE APP_TX_DATA_SIZE
    
    // 队列数据空间。请使用宏QALIGN4，目的是为了根据队列大小计算实际需要的队列存储空间大小并对齐4字节
    uint8_t QueueBuffer[QALIGN4(QUEUE_SIZE)];
    
    // 队列句柄
    Queue Uart3QueueHandle = { 0};
    #define UART3_QUEUE_Handle (&Uart3QueueHandle)
    
    // 串口转发到USB的缓冲，定义为USB包的一半大小
    static uint8_t buffer[APP_RX_DATA_SIZE >> 1];
    
    void UART3_Init(const USBD_CDC_LineCodingTypeDef *USBD_CDC_LineCoding)
    { 
    	__HAL_UART_DISABLE_IT(&huart3, UART_IT_RXNE);
    
    	__HAL_UART_DISABLE_IT(&huart3, UART_IT_IDLE);
    
    	HAL_UART_DeInit(&huart3);
    
    	huart3.Instance = USART3;
    	huart3.Init.BaudRate = USBD_CDC_LineCoding->bitrate;
    	huart3.Init.HwFlowCtl = UART_HWCONTROL_NONE;
    	huart3.Init.Mode = UART_MODE_TX_RX;
    	huart3.Init.OverSampling = UART_OVERSAMPLING_16;
    
    	switch (USBD_CDC_LineCoding->paritytype)
    	{ 
    	case 0:
    		huart3.Init.Parity = UART_PARITY_NONE;
    		break;
    	case 1:
    		huart3.Init.Parity = UART_PARITY_ODD;
    		break;
    	case 2:
    		huart3.Init.Parity = UART_PARITY_EVEN;
    		break;
    	default:
    		huart3.Init.Parity = UART_PARITY_NONE;
    		break;
    	}
    
    	switch (USBD_CDC_LineCoding->datatype)
    	{ 
    	case 0x07:
    		huart3.Init.WordLength = UART_WORDLENGTH_8B;
    		break;
    	case 0x08:
    		if (huart3.Init.Parity == UART_PARITY_NONE)
    		{ 
    			huart3.Init.WordLength = UART_WORDLENGTH_8B;
    		}
    		else
    		{ 
    			huart3.Init.WordLength = UART_WORDLENGTH_9B;
    		}
    		break;
    	default:
    		huart3.Init.WordLength = UART_WORDLENGTH_8B;
    		break;
    	}
    
    	switch (USBD_CDC_LineCoding->format)
    	{ 
    	case 0:
    		huart3.Init.StopBits = UART_STOPBITS_1;
    		break;
    	case 2:
    		huart3.Init.StopBits = UART_STOPBITS_2;
    		break;
    	default:
    		huart3.Init.StopBits = UART_STOPBITS_1;
    		break;
    	}
    
    	HAL_UART_Init(&huart3);
    
    	Queue_Init(UART3_QUEUE_Handle, QUEUE_SIZE, QueueBuffer);
    
    	__HAL_UART_ENABLE_IT(&huart3, UART_IT_RXNE);
    
    	__HAL_UART_ENABLE_IT(&huart3, UART_IT_IDLE);
    }
    
    void USART3_IRQHandler(void)
    { 
    	static uint32_t nsent = 0;
    	static uint8_t dat = 0;
    
    	if (__HAL_UART_GET_FLAG(&huart3, UART_FLAG_RXNE) != RESET)
    	{ 
    		__HAL_UART_CLEAR_FLAG(&huart3, UART_FLAG_RXNE);
    		dat = huart3.Instance->DR & 0XFF;
    		Queue_PutByte(UART3_QUEUE_Handle, dat);                     // 入队一个字节的数据
    		if (Queue_GetUsed(UART3_QUEUE_Handle) >= sizeof(buffer))
    		{ 
    			Queue_Read(UART3_QUEUE_Handle, buffer, sizeof(buffer));
    			CDC_Transmit_FS(buffer, sizeof(buffer));                // 转发到USB
    		}
    	}
    
    	if (__HAL_UART_GET_FLAG(&huart3, UART_FLAG_IDLE) != RESET)
    	{ 
    		nsent = Queue_GetUsed(UART3_QUEUE_Handle);
    		if (nsent != 0)
    		{ 
    			Queue_Read(UART3_QUEUE_Handle, buffer, nsent);
    			CDC_Transmit_FS(buffer, nsent);               // 转发到USB
    		}
    		__HAL_UART_CLEAR_IDLEFLAG(&huart3);
    	}
    }
    
    void UART3_SendData(const void *buf, uint32_t len)
    { 
    	const uint8_t *p = (const uint8_t*) buf;
    	while (len--)
    	{ 
    		while (__HAL_UART_GET_FLAG(&huart3, UART_FLAG_TXE) != SET);
    		huart3.Instance->DR = (uint8_t) (*p++ & 0XFF);
    		while (__HAL_UART_GET_FLAG(&huart3, UART_FLAG_TC) != SET);
    	}
    }
    
    //#ifdef __GNUC__
    //#define PUTCHAR_PROTOTYPE int __io_putchar(int ch)
    //#else
    //#define PUTCHAR_PROTOTYPE int fputc(int ch, FILE *f)
    //#endif
    //PUTCHAR_PROTOTYPE
    //{ 
    // while (__HAL_UART_GET_FLAG(&huart3, UART_FLAG_TXE) != SET);
    // huart3.Instance->DR = (uint8_t) (ch & 0XFF);
    // while (__HAL_UART_GET_FLAG(&huart3, UART_FLAG_TC) != SET);
    // return ch;
    //}

然后在添加USB转发到串口的操作：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxMTUzNDcxNTAz_size_16_color_FFFFFF_t_70 10]

这样就实现了一个类似于USB转TTL模块的功能！

--------------------

ends…

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxMTUzNDcxNTAz_size_16_color_FFFFFF_t_70]: /images/20221022/a3b6445e11f64b83a60941255b5f3150.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxMTUzNDcxNTAz_size_16_color_FFFFFF_t_70 1]: /images/20221022/03d2da206e9049548fec2750ebdff003.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxMTUzNDcxNTAz_size_16_color_FFFFFF_t_70 2]: /images/20221022/c5e2195e57e544fabea3250db58827f2.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxMTUzNDcxNTAz_size_16_color_FFFFFF_t_70 3]: /images/20221022/bfe1506cce4d4ac08efc35749ccf4718.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxMTUzNDcxNTAz_size_16_color_FFFFFF_t_70 4]: /images/20221022/405e10c68598466484838d7eb53b1de6.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxMTUzNDcxNTAz_size_16_color_FFFFFF_t_70 5]: /images/20221022/8a3bf38a0d404634b29f212e7abbed74.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxMTUzNDcxNTAz_size_16_color_FFFFFF_t_70 6]: /images/20221022/8a7eb8eac3eb4c16b3b7f62093988e37.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxMTUzNDcxNTAz_size_16_color_FFFFFF_t_70 7]: /images/20221022/935e3ac343114e79b47cd5be13b20d9f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxMTUzNDcxNTAz_size_16_color_FFFFFF_t_70 8]: /images/20221022/68ac4d0df01849b6b3857e97b067264e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxMTUzNDcxNTAz_size_16_color_FFFFFF_t_70 9]: /images/20221022/26b9b40c58c641018407dd7ae0ab091a.png
[C_C]: https://blog.csdn.net/qq153471503/article/details/82352271?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522161915731216780265427752%2522%252C%2522scm%2522%253A%252220140713.130102334.pc%255Fblog.%2522%257D&request_id=161915731216780265427752&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2~blog~first_rank_v2~rank_v29-1-82352271.pc_v2_rank_blog_default&utm_term=%E7%BC%93%E5%AD%98%E9%98%9F%E5%88%97
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxMTUzNDcxNTAz_size_16_color_FFFFFF_t_70 10]: /images/20221022/e6cf94f68d144e39b5dddcf218f64018.png