void Uart_Printf(char *fmt,...) 解释

最新推荐文章于 2023-11-06 19:29:20 发布
转载 最新推荐文章于 2023-11-06 19:29:20 发布 · 4.3k 阅读 · 6
文章标签：

#string #list

本文详细解析了一个用于串口输出的可变参数打印函数voidUart_Printf的实现原理及过程。该函数通过va_list、va_start、vsprintf等宏和函数处理可变数量和类型的参数，并将其格式化输出。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

void Uart_Printf(char *fmt,...) //...表示可变参数（多个可变参数组成一个列表，后面有专门的指针指向他），不限定个数和类型， { va_list ap;//初始化指向可变参数列表的指针 char string[256]; va_start(ap,fmt);//将第一个可变参数的地址付给ap，即ap指向可变参数列表的开始 vsprintf(string,fmt,ap);//将参数fmt、ap指向的可变参数一起转换成格式化字符串，放string数组中，其作用同 sprintf（），只是参数类型不同 Uart_SendString(string); //把格式化字符串从开发板串口送出去 va_end(ap); //ap付值为0，没什么实际用处，主要是为程序健壮性 }

leexinrui
关注
c语言重定向printf函数,printf函数的重定向实现
weixin_36058685的博客
05-19 2327
printf函数的重定向实现(2014-09-05 13:50:29)标签：佛学在嵌入式系统中，串口常用来辅助调试输出一些调试信息。所以有必要实现串口的格式化输出功能,这可以由3种方法实现(就我目所知).1)使用系统库函数printf(),这就需要重载输入,输出函数int fputc(int ch, FILE *f);int fgetc(FILE *f).2)使用sprintf()函数将数据格式化...
void OutputDebugStringf(char *fmt, ...)
chinabinlang的专栏
10-24 1320
这是来自xvid中的一个函数： #include "debug.h" #include #include #include  /* vsprintf */ #define DPRINTF_BUF_SZ  1024 void OutputDebugStringf(char *fmt, ...) { #ifdef _DEBUG  va_list args;  char buf[
int printf(const char* fmt,...)
leijiongbin的专栏
04-06 1万+
int printf(const char* fmt,...) 可变参数最典型的函数就是printf，它的函数原型是 int printf(const char* fmt,...)，后边的省略号就是可变参数，所以使用printf的时候可以写不定数目的参数。下边是gcc中printf的源代码. int printf(const char *fmt, ...) {
void Uart_Printf(char *fmt,...)
chengqingting的专栏
05-03 1万+
void Uart_Printf(char *fmt,...) //...表示可变参数（多个可变参数组成一个列表，后面有专门的指针指向他），不限定个数和类型， { va_list ap;//初始化指向可变参数列表的指针 char string[256]; va_start(ap,fmt);//将第一个可变参数的地址付给ap，即ap指向可变参数
void u1_printf(char *fmt,...) { uint8_t tempbuff[256]; uint16_t i; va_list ap;//相当于定义的参数列表 va_start(ap,fmt); vsprintf((char *)tempbuff,fmt,ap);//把ap以fmt的格式放入到tempbuff中 va_end(ap); for(i=0;i<strlen((char *)tempbuff);i++) { while(!__HAL_UART_GET_FLAG(&huart1, UART_FLAG_TXE)); huart1.Instance->DR = tempbuff[i]; } while(!__HAL_UART_GET_FLAG(&huart1, UART_FLAG_TC)); }
03-25
好的，我现在需要帮用户解决关于STM32 HAL库自定义u1_printf函数的问题，涉及到使用vsprintf和UART发送字符，以及__HAL_UART_GET_FLAG宏的应用。首先，我得回忆一下STM32 HAL库中UART相关的函数和机制。 用户提到了...
/* USER CODE BEGIN Header */ /** ****************************************************************************** * @file usart.c * @brief This file provides code for the configuration * of the USART instances. ****************************************************************************** * @attention * * Copyright (c) 2022 STMicroelectronics. * All rights reserved. * * This software is licensed under terms that can be found in the LICENSE file * in the root directory of this software component. * If no LICENSE file comes with this software, it is provided AS-IS. * ****************************************************************************** */ /* USER CODE END Header */ /* Includes ------------------------------------------------------------------*/ #include "usart.h" /* USER CODE BEGIN 0 */ #include "HX711.h" #include <stdarg.h> #include "timeSet.h" #include "ds1302.h" char RxBuffer[RXBUFFERSIZE]; uint8_t usart1_RxBuffer; uint8_t usart2_RxBuffer; uint8_t usart3_RxBuffer; uint8_t Uart1_Rx_Cnt = 0; uint8_t Uart2_Rx_Cnt = 0; uint8_t Uart3_Rx_Cnt = 0; SEND_DATA Send_Data; SEND_DATA usart2_Send_Data; SEND_DATA usart3_Send_Data; RECEIVE_DATA Receive_Data; RECEIVE_DATA usart2_Receive_Data; RECEIVE_DATA usart3_Receive_Data; GPS_DATA GpsData; // global variable extern float filteredVoltage; extern uint8_t enableFollowRun; void printf_usart2(const char *fmt, ...); /* USER CODE END 0 */ UART_HandleTypeDef huart1; UART_HandleTypeDef huart2; UART_HandleTypeDef huart3; DMA_HandleTypeDef hdma_usart1_rx; DMA_HandleTypeDef hdma_usart1_tx; /* USART1 init function */ void MX_USART1_UART_Init(void) { /* USER CODE BEGIN USART1_Init 0 */ /* USER CODE END USART1_Init 0 */ /* USER CODE BEGIN USART1_Init 1 */ /* USER CODE END USART1_Init 1 */ huart1.Instance = USART1; huart1.Init.BaudRate = 115200; huart1.Init.WordLength = UART_WORDLENGTH_8B; huart1.Init.StopBits = UART_STOPBITS_1; huart1.Init.Parity = UART_PARITY_NONE; huart1.Init.Mode = UART_MODE_TX_RX; huart1.Init.HwFlowCtl = UART_HWCONTROL_NONE; huart1.Init.OverSampling = UART_OVERSAMPLING_16; if (HAL_UART_Init(&huart1) != HAL_OK) { Error_Handler(); } /* USER CODE BEGIN USART1_Init 2 */ /* USER CODE END USART1_Init 2 */ } /* USART2 init function */ void MX_USART2_UART_Init(void) { /* USER CODE BEGIN USART2_Init 0 */ /* USER CODE END USART2_Init 0 */ /* USER CODE BEGIN USART2_Init 1 */ /* USER CODE END USART2_Init 1 */ huart2.Instance = USART2; huart2.Init.BaudRate = 9600; huart2.Init.WordLength = UART_WORDLENGTH_8B; huart2.Init.StopBits = UART_STOPBITS_1; huart2.Init.Parity = UART_PARITY_NONE; huart2.Init.Mode = UART_MODE_TX_RX; huart2.Init.HwFlowCtl = UART_HWCONTROL_NONE; huart2.Init.OverSampling = UART_OVERSAMPLING_16; if (HAL_UART_Init(&huart2) != HAL_OK) { Error_Handler(); } /* USER CODE BEGIN USART2_Init 2 */ /* USER CODE END USART2_Init 2 */ } /* USART3 init function */ void MX_USART3_UART_Init(void) { /* USER CODE BEGIN USART3_Init 0 */ /* USER CODE END USART3_Init 0 */ /* USER CODE BEGIN USART3_Init 1 */ /* USER CODE END USART3_Init 1 */ huart3.Instance = USART3; huart3.Init.BaudRate = 9600; huart3.Init.WordLength = UART_WORDLENGTH_8B; huart3.Init.StopBits = UART_STOPBITS_1; huart3.Init.Parity = UART_PARITY_NONE; huart3.Init.Mode = UART_MODE_TX_RX; huart3.Init.HwFlowCtl = UART_HWCONTROL_NONE; huart3.Init.OverSampling = UART_OVERSAMPLING_16; if (HAL_UART_Init(&huart3) != HAL_OK) { Error_Handler(); } /* USER CODE BEGIN USART3_Init 2 */ /* USER CODE END USART3_Init 2 */ } void HAL_UART_MspInit(UART_HandleTypeDef* uartHandle) { GPIO_InitTypeDef GPIO_InitStruct = {0}; if(uartHandle->Instance==USART1) { /* USER CODE BEGIN USART1_MspInit 0 */ /* USER CODE END USART1_MspInit 0 */ /* USART1 clock enable */ __HAL_RCC_USART1_CLK_ENABLE(); __HAL_RCC_GPIOA_CLK_ENABLE(); /**USART1 GPIO Configuration PA9 ------> USART1_TX PA10 ------> USART1_RX */ GPIO_InitStruct.Pin = GPIO_PIN_9; GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH; HAL_GPIO_Init(GPIOA, &GPIO_InitStruct); GPIO_InitStruct.Pin = GPIO_PIN_10; GPIO_InitStruct.Mode = GPIO_MODE_INPUT; GPIO_InitStruct.Pull = GPIO_NOPULL; HAL_GPIO_Init(GPIOA, &GPIO_InitStruct); /* USART1 DMA Init */ /* USART1_RX Init */ hdma_usart1_rx.Instance = DMA1_Channel5; hdma_usart1_rx.Init.Direction = DMA_PERIPH_TO_MEMORY; hdma_usart1_rx.Init.PeriphInc = DMA_PINC_DISABLE; hdma_usart1_rx.Init.MemInc = DMA_MINC_ENABLE; hdma_usart1_rx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE; hdma_usart1_rx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE; hdma_usart1_rx.Init.Mode = DMA_NORMAL; hdma_usart1_rx.Init.Priority = DMA_PRIORITY_LOW; if (HAL_DMA_Init(&hdma_usart1_rx) != HAL_OK) { Error_Handler(); } __HAL_LINKDMA(uartHandle,hdmarx,hdma_usart1_rx); /* USART1_TX Init */ hdma_usart1_tx.Instance = DMA1_Channel4; hdma_usart1_tx.Init.Direction = DMA_MEMORY_TO_PERIPH; hdma_usart1_tx.Init.PeriphInc = DMA_PINC_DISABLE; hdma_usart1_tx.Init.MemInc = DMA_MINC_ENABLE; hdma_usart1_tx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE; hdma_usart1_tx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE; hdma_usart1_tx.Init.Mode = DMA_NORMAL; hdma_usart1_tx.Init.Priority = DMA_PRIORITY_LOW; if (HAL_DMA_Init(&hdma_usart1_tx) != HAL_OK) { Error_Handler(); } __HAL_LINKDMA(uartHandle,hdmatx,hdma_usart1_tx); /* USART1 interrupt Init */ HAL_NVIC_SetPriority(USART1_IRQn, 5, 0); HAL_NVIC_EnableIRQ(USART1_IRQn); /* USER CODE BEGIN USART1_MspInit 1 */ /* USER CODE END USART1_MspInit 1 */ } else if(uartHandle->Instance==USART2) { /* USER CODE BEGIN USART2_MspInit 0 */ /* USER CODE END USART2_MspInit 0 */ /* USART2 clock enable */ __HAL_RCC_USART2_CLK_ENABLE(); __HAL_RCC_GPIOA_CLK_ENABLE(); /**USART2 GPIO Configuration PA2 ------> USART2_TX PA3 ------> USART2_RX */ GPIO_InitStruct.Pin = GPIO_PIN_2; GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH; HAL_GPIO_Init(GPIOA, &GPIO_InitStruct); GPIO_InitStruct.Pin = GPIO_PIN_3; GPIO_InitStruct.Mode = GPIO_MODE_INPUT; GPIO_InitStruct.Pull = GPIO_NOPULL; HAL_GPIO_Init(GPIOA, &GPIO_InitStruct); /* USART2 interrupt Init */ HAL_NVIC_SetPriority(USART2_IRQn, 5, 0); HAL_NVIC_EnableIRQ(USART2_IRQn); /* USER CODE BEGIN USART2_MspInit 1 */ /* USER CODE END USART2_MspInit 1 */ } else if(uartHandle->Instance==USART3) { /* USER CODE BEGIN USART3_MspInit 0 */ /* USER CODE END USART3_MspInit 0 */ /* USART3 clock enable */ __HAL_RCC_USART3_CLK_ENABLE(); __HAL_RCC_GPIOB_CLK_ENABLE(); /**USART3 GPIO Configuration PB10 ------> USART3_TX PB11 ------> USART3_RX */ GPIO_InitStruct.Pin = GPIO_PIN_10; GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH; HAL_GPIO_Init(GPIOB, &GPIO_InitStruct); GPIO_InitStruct.Pin = GPIO_PIN_11; GPIO_InitStruct.Mode = GPIO_MODE_INPUT; GPIO_InitStruct.Pull = GPIO_NOPULL; HAL_GPIO_Init(GPIOB, &GPIO_InitStruct); /* USART3 interrupt Init */ HAL_NVIC_SetPriority(USART3_IRQn, 5, 0); HAL_NVIC_EnableIRQ(USART3_IRQn); /* USER CODE BEGIN USART3_MspInit 1 */ /* USER CODE END USART3_MspInit 1 */ } } void HAL_UART_MspDeInit(UART_HandleTypeDef* uartHandle) { if(uartHandle->Instance==USART1) { /* USER CODE BEGIN USART1_MspDeInit 0 */ /* USER CODE END USART1_MspDeInit 0 */ /* Peripheral clock disable */ __HAL_RCC_USART1_CLK_DISABLE(); /**USART1 GPIO Configuration PA9 ------> USART1_TX PA10 ------> USART1_RX */ HAL_GPIO_DeInit(GPIOA, GPIO_PIN_9|GPIO_PIN_10); /* USART1 DMA DeInit */ HAL_DMA_DeInit(uartHandle->hdmarx); HAL_DMA_DeInit(uartHandle->hdmatx); /* USART1 interrupt Deinit */ HAL_NVIC_DisableIRQ(USART1_IRQn); /* USER CODE BEGIN USART1_MspDeInit 1 */ /* USER CODE END USART1_MspDeInit 1 */ } else if(uartHandle->Instance==USART2) { /* USER CODE BEGIN USART2_MspDeInit 0 */ /* USER CODE END USART2_MspDeInit 0 */ /* Peripheral clock disable */ __HAL_RCC_USART2_CLK_DISABLE(); /**USART2 GPIO Configuration PA2 ------> USART2_TX PA3 ------> USART2_RX */ HAL_GPIO_DeInit(GPIOA, GPIO_PIN_2|GPIO_PIN_3); /* USART2 interrupt Deinit */ HAL_NVIC_DisableIRQ(USART2_IRQn); /* USER CODE BEGIN USART2_MspDeInit 1 */ /* USER CODE END USART2_MspDeInit 1 */ } else if(uartHandle->Instance==USART3) { /* USER CODE BEGIN USART3_MspDeInit 0 */ /* USER CODE END USART3_MspDeInit 0 */ /* Peripheral clock disable */ __HAL_RCC_USART3_CLK_DISABLE(); /**USART3 GPIO Configuration PB10 ------> USART3_TX PB11 ------> USART3_RX */ HAL_GPIO_DeInit(GPIOB, GPIO_PIN_10|GPIO_PIN_11); /* USART3 interrupt Deinit */ HAL_NVIC_DisableIRQ(USART3_IRQn); /* USER CODE BEGIN USART3_MspDeInit 1 */ /* USER CODE END USART3_MspDeInit 1 */ } } /* USER CODE BEGIN 1 */ #ifdef enableROS void data_transition(void) { } #endif // Modified code in usart2_data_transition() void usart2_data_transition(void) { // usart2_Send_Data.buffer[0] = FRAME_HEADER; // Frame header // usart2_Send_Data.buffer[1] = GpsData.isUseful; // GPS data identifier // // Copy UTC time (6 bytes) to buffer positions 2-7 // strncpy((char *)&usart2_Send_Data.buffer[2], GpsData.UTCTime, 6); // // Convert latitude to 16-bit integer (scaled by 100) // int latitude = (int)(GpsData.latitude * 100); // 直接使用 float 值 // usart2_Send_Data.buffer[8] = (latitude >> 8) & 0xFF; // usart2_Send_Data.buffer[9] = latitude & 0xFF; // int longitude = (int)(GpsData.longitude * 100); // 直接使用 float 值 // usart2_Send_Data.buffer[10] = (longitude >> 8) & 0xFF; // usart2_Send_Data.buffer[11] = longitude & 0xFF; // // Direction indicators (North/South, East/West) // usart2_Send_Data.buffer[12] = GpsData.N_S[0]; // N/S indicator // usart2_Send_Data.buffer[13] = GpsData.E_W[0]; // E/W indicator // // Data validity flag (1 byte) // usart2_Send_Data.buffer[14] = GpsData.isUseful ? 0x01 : 0x00; // // Add filtered voltage (16-bit scaled value) // usart2_Send_Data.buffer[15] = ((int)filteredVoltage >> 8) & 0xFF; // High byte // usart2_Send_Data.buffer[16] = (int)filteredVoltage & 0xFF; // Low byte // // Add weight information (16-bit scaled value) // usart2_Send_Data.buffer[17] = (Weight_Shiwu >> 8) & 0xFF; // High byte // usart2_Send_Data.buffer[18] = Weight_Shiwu & 0xFF; // Low byte // // Clear remaining bytes (positions 19-21) // memset(&usart2_Send_Data.buffer[19], 0, 3); // // Calculate checksum and append frame tail // usart2_Send_Data.buffer[22] = Check_Sum(22, 1); // XOR checksum of first 22 bytes // usart2_Send_Data.buffer[23] = FRAME_TAIL; // Frame trailer // USART2_SEND(); // Trigger transmission /****************************************************** 字节索引 内容说明 数据类型 ------------------------------------------------------- 0 帧头 (FRAME_HEADER) 固定标识符 1 数据类型标识符 (GPS_DATA_ID) 固定标识符 2-7 UTC时间（6字节字符串） 字符串 8-9 纬度（16位整数，缩放系数100） 整数 10-11 经度（16位整数，缩放系数100） 整数 12 方向（N/S） 单字符 13 方向（E/W） 单字符 14 数据有效性标志 布尔值 15-16 电压（16位整数，缩放系数100） 整数 17-18 物料重量（16位整数，缩放系数100） 整数 19-21 空闲字节（保留或清零） 保留字段 22 校验和（XOR校验） 校验字段 23 帧尾 (FRAME_TAIL) 固定标识符 -------------------------------------------------------- set encoding:GB2312(simplified) ******************************************************/ // printf("UTC Time: %s\n", GpsData.UTCTime); // UTC time // printf("Latitude: %.2f%c\n", GpsData.latitude, GpsData.N_S[0]); // Latitude // printf("Longitude: %.2f%c\n", GpsData.longitude, GpsData.E_W[0]); // Longitude // printf("Valid: %d\n", GpsData.isUseful); // Data validity // printf("Voltage: %d percent\n", (int)(Voltage_Percent)); // Filtered voltage // printf("Weight: %d g\n", Weight_Shiwu); // Material weight } void USART1_SEND(void) { unsigned char i = 0; for(i=0; i<24; i++) { usart1_send(Send_Data.buffer[i]); } } void USART2_SEND(void) { unsigned char i = 0; for(i=0; i<24; i++) { usart2_send(usart2_Send_Data.buffer[i]); } } void USART3_SEND(void) { unsigned char i = 0; for(i=0; i<24; i++) { usart3_send(usart3_Send_Data.buffer[i]); } } float XYZ_Target_Speed_transition(uint8_t High,uint8_t Low) { //Data conversion intermediate variable short transition; //The high 8 and low 8 bits are integrated into a 16-bit short data transition=((High<<8)+Low); return transition/1000+(transition%1000)*0.001; //Unit conversion, mm/s->m/s } void usart1_send(uint8_t data) { USART1->DR = data; while((USART1->SR&0x40)==0); } void usart2_send(uint8_t data) { USART2->DR = data; while((USART2->SR&0x40)==0); } void usart3_send(uint8_t data) { USART3->DR = data; while((USART3->SR&0x40)==0); } uint8_t Check_Sum(unsigned char Count_Number,unsigned char Mode) { unsigned char check_sum=0,k; if(Mode==1) for(k=0;k<Count_Number;k++) { check_sum=check_sum^Send_Data.buffer[k]; } if(Mode==0) for(k=0;k<Count_Number;k++) { check_sum=check_sum^Receive_Data.buffer[k]; } return check_sum; } void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart) { /* Prevent unused argument(s) compilation warning */ UNUSED(huart); /* NOTE: This function Should not be modified, when the callback is needed, the HAL_UART_TxCpltCallback could be implemented in the user file */ if(huart == &huart2) { static u8 usart2_Count=0; usart2_Receive_Data.buffer[usart2_Count]=usart2_RxBuffer; // Ensure that the first data in the array is FRAME_HEADER if(usart2_RxBuffer == FRAME_HEADER||usart2_Count>0) usart2_Count++; else usart2_Count=0; if (usart2_Count == 11) //Verify the length of the packet { usart2_Count=0; //Prepare for the serial port data to be refill into the array if(usart2_Receive_Data.buffer[10] == FRAME_TAIL) //Verify the frame tail of the packet { //Data exclusionary or bit check calculation, mode 0 is sent data check //if(Receive_Data.buffer[9] ==Check_Sum(9,0)) { if(firstTimeTakeTime) { hour = TimeData.hour; min = TimeData.minute; sec = TimeData.second; firstTimeTakeTime = 0; } if(usart2_Receive_Data.buffer[1] == 2) min += 30; if(usart2_Receive_Data.buffer[1] == 3) hour += 1; if(usart2_Receive_Data.buffer[1] == 4) hour += 2; if(usart2_Receive_Data.buffer[1] == 5) sec += 10; if(usart2_Receive_Data.buffer[1] == 6) min += 1; if(usart2_Receive_Data.buffer[1] == 7) hour += 3; startup_time_sec = (hour * 3600 + min * 60 + sec) - (TimeData.hour * 3600 + TimeData.minute * 60 + TimeData.second); countdown_start_time = osKernelGetTickCount(); state = 14; showFlagEnable = 1; firstTimeTakeTime = 1; } } } HAL_UART_Receive_IT(&huart2, (uint8_t *)&usart2_RxBuffer, 1); } if(huart == &huart3) { HAL_UART_Receive_IT(&huart3, (uint8_t *)&usart3_RxBuffer, 1); } } bool readBluetoothState(void) { // Read Bluetooth connection status bool isConnected = (HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_8) == GPIO_PIN_SET); return isConnected; } void printf_usart2(const char *fmt, ...) { char buffer[256]; va_list args; va_start(args, fmt); // 1. 初始化参数列表 vsnprintf(buffer, sizeof(buffer), fmt, args); // 2. 格式化字符串到 buffer va_end(args); // 3. 清理参数列表 // 发送 buffer 内容到 UART2 for (int i = 0; buffer[i] != '\0'; i++) { HAL_UART_Transmit(&huart2, (uint8_t*)&buffer[i], 1, HAL_MAX_DELAY); } } /* USER CODE END 1 */ 解释代码
05-14
以下是对代码的详细解释： --- ### **1. USART 初始化** #### **`MX_USART1_UART_Init`, `MX_USART2_UART_Init`, `MX_USART3_UART_Init`** 这些函数用于初始化 USART1、USART2 和 USART3 的配置参数。 ```c huart...
void cli_printf(const char *fmt, ...) { char info[CLI_DBG_INFO_LEN] = {0}; va_list args; va_start(args, fmt); vsnprintf(info, CLI_DBG_INFO_LEN - 1, fmt, args); va_end(args); printf(info); }代码分析
06-13
void cli_printf(const char *fmt, ...) { va_list args; // 定义参数列表指针 va_start(args, fmt); // 初始化：args指向fmt后的第一个参数 // ... va_end(args); // 清理参数列表 } ``` - **`va_start`**：...
/** ****************************************************************************** * @file usart.c * @brief This file provides code for the configuration * of the USART instances. ****************************************************************************** * @attention * * <h2><center>© Copyright (c) 2022 CSTX. * All rights reserved.</center></h2> * * This software component is licensed by ST under BSD 3-Clause license, * the "License"; You may not use this file except in compliance with the * License. You may obtain a copy of the License at: * leigong opensource.org/licenses/BSD-3-Clause * ****************************************************************************** */ /* Includes ------------------------------------------------------------------*/ #include "usart.h" /* USER CODE BEGIN 0 */ #include "stdio.h" #include "string.h" uint8_t rxConut = 0; //数据长度 uint8_t regConut = 0; uint16_t USART_RX_STA=0; //接收状态标记 uint16_t USART2_RX_STA=0; uint8_t USART_RX_BUF[USART_REC_LEN]; //接收缓冲,最大USART_REC_LEN个字节. uint8_t USART2_RX_BUF[USART_REC_LEN]; __align(8) char usart_txBuff[USART_REC_LEN]; //字节对齐缓冲区 #ifdef __GNUC__ /* With GCC/RAISONANCE, small printf (option LD Linker->Libraries->Small printf set to 'Yes') calls __io_putchar() */ #define PUTCHAR_PROTOTYPE int __io_putchar(int ch) #else #define PUTCHAR_PROTOTYPE int fputc(int ch, FILE *f) #endif /* __GNUC__ */ /** * @brief Retargets the C library printf function to the USART. * @param None * @retval None */ PUTCHAR_PROTOTYPE { /* Place your implementation of fputc here */ /* e.g. write a character to the EVAL_COM1 and Loop until the end of transmission */ HAL_UART_Transmit(&huart1, (uint8_t *)&ch, 1, 0xFFFF); return ch; } //usart2的printf() void USART2_printf(char *fmt,...) { uint32_t i,length; va_list ap; va_start(ap,fmt); vsprintf(usart_txBuff,fmt,ap); va_end(ap); length=strlen((const char*)usart_txBuff); while((USART2->ISR&0x40)==0); for(i=0;i<length;i++) { USART2->TDR=usart_txBuff[i]; while((USART2->ISR&0x40)==0); } } /* USER CODE END 0 */ UART_HandleTypeDef huart1; UART_HandleTypeDef huart2; /* USART1 init function */ void MX_USART1_UART_Init(void) { /* USER CODE BEGIN USART1_Init 0 */ /* USER CODE END USART1_Init 0 */ /* USER CODE BEGIN USART1_Init 1 */ /* USER CODE END USART1_Init 1 */ huart1.Instance = USART1; huart1.Init.BaudRate = 115200; huart1.Init.WordLength = UART_WORDLENGTH_8B; huart1.Init.StopBits = UART_STOPBITS_1; huart1.Init.Parity = UART_PARITY_NONE; huart1.Init.Mode = UART_MODE_TX_RX; huart1.Init.HwFlowCtl = UART_HWCONTROL_NONE; huart1.Init.OverSampling = UART_OVERSAMPLING_16; huart1.Init.OneBitSampling = UART_ONE_BIT_SAMPLE_DISABLE; huart1.Init.ClockPrescaler = UART_PRESCALER_DIV1; huart1.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT; if (HAL_UART_Init(&huart1) != HAL_OK) { Error_Handler(); } if (HAL_UARTEx_SetTxFifoThreshold(&huart1, UART_TXFIFO_THRESHOLD_1_8) != HAL_OK) { Error_Handler(); } if (HAL_UARTEx_SetRxFifoThreshold(&huart1, UART_RXFIFO_THRESHOLD_1_8) != HAL_OK) { Error_Handler(); } if (HAL_UARTEx_DisableFifoMode(&huart1) != HAL_OK) { Error_Handler(); } /* USER CODE BEGIN USART1_Init 2 */ /* USER CODE END USART1_Init 2 */ } /* USART2 init function */ void MX_USART2_UART_Init(void) { /* USER CODE BEGIN USART2_Init 0 */ /* USER CODE END USART2_Init 0 */ /* USER CODE BEGIN USART2_Init 1 */ /* USER CODE END USART2_Init 1 */ huart2.Instance = USART2; huart2.Init.BaudRate = 9600; huart2.Init.WordLength = UART_WORDLENGTH_8B; huart2.Init.StopBits = UART_STOPBITS_1; huart2.Init.Parity = UART_PARITY_NONE; huart2.Init.Mode = UART_MODE_TX_RX; huart2.Init.HwFlowCtl = UART_HWCONTROL_NONE; huart2.Init.OverSampling = UART_OVERSAMPLING_16; huart2.Init.OneBitSampling = UART_ONE_BIT_SAMPLE_DISABLE; huart2.Init.ClockPrescaler = UART_PRESCALER_DIV1; huart2.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT; if (HAL_UART_Init(&huart2) != HAL_OK) { Error_Handler(); } /* USER CODE BEGIN USART2_Init 2 */ /* USER CODE END USART2_Init 2 */ } void HAL_UART_MspInit(UART_HandleTypeDef* uartHandle) { GPIO_InitTypeDef GPIO_InitStruct = {0}; if(uartHandle->Instance==USART1) { /* USER CODE BEGIN USART1_MspInit 0 */ /* USER CODE END USART1_MspInit 0 */ /* USART1 clock enable */ __HAL_RCC_USART1_CLK_ENABLE(); __HAL_RCC_GPIOB_CLK_ENABLE(); /**USART1 GPIO Configuration PB7 ------> USART1_RX PB6 ------> USART1_TX */ GPIO_InitStruct.Pin = GPIO_PIN_7|GPIO_PIN_6; GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; GPIO_InitStruct.Pull = GPIO_NOPULL; GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW; GPIO_InitStruct.Alternate = GPIO_AF0_USART1; HAL_GPIO_Init(GPIOB, &GPIO_InitStruct); /* USART1 interrupt Init */ HAL_NVIC_SetPriority(USART1_IRQn, 0, 0); HAL_NVIC_EnableIRQ(USART1_IRQn); /* USER CODE BEGIN USART1_MspInit 1 */ /* USER CODE END USART1_MspInit 1 */ } else if(uartHandle->Instance==USART2) { /* USER CODE BEGIN USART2_MspInit 0 */ /* USER CODE END USART2_MspInit 0 */ /* USART2 clock enable */ __HAL_RCC_USART2_CLK_ENABLE(); __HAL_RCC_GPIOA_CLK_ENABLE(); /**USART2 GPIO Configuration PA2 ------> USART2_TX PA3 ------> USART2_RX */ GPIO_InitStruct.Pin = GPIO_PIN_2|GPIO_PIN_3; GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; GPIO_InitStruct.Pull = GPIO_NOPULL; GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW; GPIO_InitStruct.Alternate = GPIO_AF1_USART2; HAL_GPIO_Init(GPIOA, &GPIO_InitStruct); /* USART2 interrupt Init */ HAL_NVIC_SetPriority(USART2_IRQn, 0, 0); HAL_NVIC_EnableIRQ(USART2_IRQn); /* USER CODE BEGIN USART2_MspInit 1 */ /* USER CODE END USART2_MspInit 1 */ } } void HAL_UART_MspDeInit(UART_HandleTypeDef* uartHandle) { if(uartHandle->Instance==USART1) { /* USER CODE BEGIN USART1_MspDeInit 0 */ /* USER CODE END USART1_MspDeInit 0 */ /* Peripheral clock disable */ __HAL_RCC_USART1_CLK_DISABLE(); /**USART1 GPIO Configuration PB7 ------> USART1_RX PB6 ------> USART1_TX */ HAL_GPIO_DeInit(GPIOB, GPIO_PIN_7|GPIO_PIN_6); /* USART1 interrupt Deinit */ HAL_NVIC_DisableIRQ(USART1_IRQn); /* USER CODE BEGIN USART1_MspDeInit 1 */ /* USER CODE END USART1_MspDeInit 1 */ } else if(uartHandle->Instance==USART2) { /* USER CODE BEGIN USART2_MspDeInit 0 */ /* USER CODE END USART2_MspDeInit 0 */ /* Peripheral clock disable */ __HAL_RCC_USART2_CLK_DISABLE(); /**USART2 GPIO Configuration PA2 ------> USART2_TX PA3 ------> USART2_RX */ HAL_GPIO_DeInit(GPIOA, GPIO_PIN_2|GPIO_PIN_3); /* USART2 interrupt Deinit */ HAL_NVIC_DisableIRQ(USART2_IRQn); /* USER CODE BEGIN USART2_MspDeInit 1 */ /* USER CODE END USART2_MspDeInit 1 */ } } /* USER CODE BEGIN 1 */ void USART_Interupt_Enable(void) { __HAL_UART_ENABLE_IT(&huart1,UART_IT_IDLE); //空闲中断使能 __HAL_UART_ENABLE_IT(&huart1,UART_IT_RXNE); //接收中断使能 __HAL_UART_CLEAR_IDLEFLAG(&huart1); __HAL_UART_ENABLE_IT(&huart2,UART_IT_IDLE); //空闲中断使能 __HAL_UART_ENABLE_IT(&huart2,UART_IT_RXNE); //接收中断使能 __HAL_UART_CLEAR_IDLEFLAG(&huart2); } //void USART1_IdleCallback(uint8_t*pData,uint16_t len) //{ // while(__HAL_UART_GET_FLAG(&huart1,UART_FLAG_TC)!=SET); // HAL_UART_Transmit(&huart2,pData,len,1000); //} //void USART2_IdleCallback(uint8_t*pData,uint16_t len) //{ // while(__HAL_UART_GET_FLAG(&huart2,UART_FLAG_TC)!=SET); // HAL_UART_Transmit(&huart1,pData,len,1000); //} /*串口中断处理函数*/ void USER_UartHandler(UART_HandleTypeDef* huart) { uint8_t res = 0; static uint8_t OnPow = 1,OnPow2 = 1; if(huart->Instance == USART1) { //接收中断 if(__HAL_UART_GET_FLAG(&huart1,UART_FLAG_RXNE)!=RESET) { HAL_UART_Receive(&huart1,&res,1,1000); //将数据放入缓冲区 if(rxConut<USART_REC_LEN) { USART_RX_BUF[rxConut]=res; rxConut++; } USART_RX_STA = REC_WAIT ; __HAL_UART_CLEAR_FLAG(&huart1,UART_FLAG_RXNE); } //空闲中断 if(__HAL_UART_GET_FLAG(&huart1,UART_FLAG_IDLE)!=RESET) { //一帧数据接收完成 if(OnPow) { USART_RX_STA = REC_WAIT ; OnPow = 0; }else {USART_RX_STA = REC_OK;} //USART1_IdleCallback(USART_RX_BUF,rxConut); rxConut =0; __HAL_UART_CLEAR_IDLEFLAG(&huart1); } }else if(huart->Instance == USART2) { //接收中断 if(__HAL_UART_GET_FLAG(&huart2,UART_FLAG_RXNE)!=RESET) { HAL_UART_Receive(&huart2,&res,1,1000); //将数据放入缓冲区 if(rxConut<USART_REC_LEN) { USART2_RX_BUF[rxConut]=res; rxConut++; regConut++; } USART2_RX_STA = REC_WAIT ; __HAL_UART_CLEAR_FLAG(&huart2,UART_FLAG_RXNE); } //空闲中断 if(__HAL_UART_GET_FLAG(&huart2,UART_FLAG_IDLE)!=RESET) { //一帧数据接收完成 if(OnPow2) { USART2_RX_STA = REC_WAIT ; OnPow2 = 0; }else {USART2_RX_STA = REC_OK;} //USART2_IdleCallback(USART2_RX_BUF,rx2Conut); rxConut =0; __HAL_UART_CLEAR_IDLEFLAG(&huart2); } } } //发送len个字节. //buf:发送区首地址 //len:发送的字节数(为了和本代码的接收匹配,这里建议不要超过64个字节) void CS_Reg_Send_Data(unsigned char *buf,unsigned char len) { unsigned char t; while((USART2->ISR&0x40)==0); for(t=0;t<len;t++) //循环发送数据 { USART2->TDR=buf[t]; while((USART2->ISR&0x40)==0); } regConut=0; memset(USART2_RX_BUF,0,USART_REC_LEN); } //查询接收到的数据 //buf:接收缓存首地址 //len:读到的数据长度 void cstx_reg_Receive_Data(unsigned char *buf,unsigned char *len) { unsigned char rxlen=regConut; unsigned char i=0; *len=0; //默认为0 if(USART2_RX_BUF[0]==0XC1)//接收到了数据,且接收完成了 { for(i=0;i<rxlen;i++) { buf[i]=USART2_RX_BUF[i]; } *len=regConut; //记录本次数据长度 } // regConut=0; //清零 memset(USART2_RX_BUF,0,USART_REC_LEN); } /* USER CODE END 1 */ /************************ (C) COPYRIGHT CSTX *****END OF FILE****/ 这是我的串口模块
最新发布
07-05
void cstx_reg_Receive_Data(unsigned char *buf, unsigned char *len) { unsigned char rxlen = regConut; unsigned char i = 0; *len = 0; if(USART2_RX_BUF[0] == 0xC1) { for(i = 0; i ; i++) { buf[i]...
44b0 之 Uart_Printf(char *fmt,...)
noneexist的专栏
10-26 1458
void Uart_Printf(char *fmt,...){    va_list ap;    char string[256];    va_start(ap,fmt);    vsprintf(string,fmt,ap);    Uart_SendString(string);    va_end(ap);}1> vsprintf2>可变参数 1> vsprintf
C语言 printf
书山有路勤为径
01-08 1093
一）实现自己的printf #include <stdio.h> #include <string.h> #include <stdarg.h> // printf with format void my_printf(char *fmt, ...) { va_list ap; //char * int d; char c, *s...
printf 应用
muyepiao1的博客
09-08 841
正点原子，一段串口程序： void u2_printf(char* fmt,...)  {      va_list ap; //定义一具VA_LIST型的变量ap,这个变量是指向参数的指针     va_start(ap,fmt);//初始化变量ap     vsprintf((char*)USART2_TX_BUF,fmt,ap);//将
STM32F103 中 USART简介
qq_67808371的博客
11-06 457
1.USART（Universal Synchronous/Asynchronous Receiver/Transmitter）通用同步/异步收发器2.USART是STM32内部集成的，可根据数据寄存器的一个字节数据自动生成数据帧时序，从TX引脚发送出去，也可自动接收RX引脚的数据帧时序，拼接为一个字节数据，存放在数据寄存器里3.自带波特率发生器，最高达4.5Mbits/s4.可配置数据位长度（8/9）、停止位长度（0.5/1/1.5/2）5.可选校验位（无校验/奇校验/偶校验）
C语言的void*指针使用
VictorZhang
08-21 2825
#include #include //void *可以是任意类型的数据，任意类型都可以存储，也可以转换任意类型 int main(){ //例1：将普通指针变量赋值给void*指针并打印输出 int pa = 100; int *p = &pa; void * v = p; printf("v=%d \n",*((int*)v)); //例2：通过void*指针修改
嵌入式C语言自我修养 (08)：变参函数的格式检查
宅学部落-王利涛
01-26 894
8.1 属性声明：format GNU 通过 attribute 扩展的 format 属性，用来指定变参函数的参数格式检查。 它的使用方法如下： __attribute__(( format (archetype, string-index, first-to-check))) void LOG(const char *fmt, ...)  __attribute__((format(p...
void print ()c语言,c语言中的void printlog(char *format,...)这是什么意思？
weixin_30171859的博客
05-18 1492
c语言中的void printlog(char *format,...)这是什么意思？答案:2信息版本：手机版解决时间 2018-12-15 18:03已解决2018-12-15 14:38c语言中的void printlog(char *format,...)这是什么意思？最佳答案2018-12-15 15:07表示printlog这个函数，接受任意多个参数，第一个参数必须为char*类型...
VS调试以及Trace函数的用法
热门推荐
ndjk454164628的专栏
06-15 2万+
. VC调试入门 设置 为了调试一个程序，首先必须使程序中包含调试信息。一般情况下，一个从AppWizard创建的工程中包含的Debug Configuration自动包含调试信息，但是是不是Debug版本并不是程序包含调试信息的决定因素，程序设计者可以在任意的Configuration中增加调试信息，包括Release版本。 为了增加调试信息，可以按照下述步骤进行： 打开Proj
分享一个适合单片机的轻量级日志库
strongerHuang
09-06 631
关注+星标公众号，不错过精彩内容来源| Github编排 | strongerHuang单片机项目在很多时候都需要调试，通过日志诊断bug是常见的一种调试方法。下面就给大家分享一个开源的适合单片机的轻量级日志库，只有log.c 和 log.h 两个文件，使用非常方便。用法这个日志库的使用比较简单，新手完全可以胜任。1、概述在你的项目中添加log.c 和 log.h 文件。提供 6 用于日志记录...
文件操作函数
u010144189的专栏
04-16 604
1.打开文件 FILE *fopen( const char * filename, const char *mode ); 参数：filename : 可以是一个用双引号括起的字面字符串／一个指向字符串的指针；           mode     ：以何种模式打开文件； 2.格式化文件输出／输入 int fprintf( FILE *fp, char *fmt, … ); 参数
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值