Stm32高级驱动编程-第3章 UART驱动

最新推荐文章于 2023-02-16 17:25:57 发布
最新推荐文章于 2023-02-16 17:25:57 发布
阅读量619 收藏 9
点赞数
分类专栏： Stm32高级驱动编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/abc240697738/article/details/103387580
版权

第3章 UART驱动

如果需要其它实现方法及商业合作，邮件联系240697738@qq.com

https://github.com/wuyuanfu240697738/Science_Embeded

3.1 UART封装需求

对于初使化一个UART，我们在定义UART编号后，初使化函数可以自动根据UART编号进行配置对应的gpio引脚，uart参数，dma参数。在定义UART回调函数后，Uart中断函数可以自动触发并响应。如果定义485控制引脚，不论发送函数或是接收函数可以根据发送或是接收情况自动设置485控制引脚的电平。我们只需要注重发送数据及接收数据的功能。

3.2 UART引脚编号

为使所有的UART编号唯一，我们需要对所有的UART（可以扩展）进行统一编号。

typedef  enum {

    wPIN_U1_A9A10                           =     (wuint)0xf011u,
    wPIN_U1_B6B7                            =     (wuint)0xf012u,
    wPIN_U2_A2A3                            =     (wuint)0xf021u,
    wPIN_U2_D5D6                            =     (wuint)0xf022u,
    wPIN_U3_B10B11                          =     (wuint)0xf031u,
    wPIN_U3_C10C11                          =     (wuint)0xf032u,
    wPIN_U3_D8D9                            =     (wuint)0xf033u,
    wPIN_U4_C10C11                          =     (wuint)0xf041u,
    wPIN_U5_C12D2                           =     (wuint)0xf042u,  
…… …… ……
}

3.3 UART结构体引用

typedef  void (*UartRxCpltFnct_Idle)(UART_HandleTypeDef *huart,uint32_t length);//接收空闲回调函数
typedef  void (*UartTxCpltFnct     )(UART_HandleTypeDef *huart);//发送完成回调函数

typedef  struct    wUart_def       wUart_Def;
struct  wUart_def{
    UART_HandleTypeDef    huart;   
    DMA_HandleTypeDef     hdma_tx;
    DMA_HandleTypeDef     hdma_rx;   	 
    wGpio_Def             CSS;
	wUart_Def*			  NextPtr;
    UartRxCpltFnct_Idle   RxCplt_IdlePtr;   
    UartTxCpltFnct        TxCpltPtr;        
};

3.4 UART变量定义

wUart_Def* wUart_ListPtr;//起始链表指针
UART_HandleTypeDef*     Int_huart[wUart_Num];

3.5 UART链表函数

static void wUart_List(wUart_Def *p_Uart)
{
    //需要查询原有的链表中是否已经注册，如已经注册过，则无需再次注册
    wUart_Def* p_list = wUart_ListPtr; 
        while(p_list != (wUart_Def *)NULL)
    {
        if(p_list == p_Uart){break;}
        else{p_list = p_list->NextPtr;}
    }
    if(p_list != p_Uart)
    {
        //如还未注册过，则需注册
        if( wUart_ListPtr == (wUart_Def *)NULL )
        {
            p_Uart->NextPtr = (wUart_Def *)NULL;
            wUart_ListPtr = p_Uart;
        }
        else
        {
            p_Uart->NextPtr = wUart_ListPtr;
            wUart_ListPtr = p_Uart;
        }
    } 
}

3.6 UART（直接）初使化函数

UART_HandleTypeDef* wUart_Init(wUart_Def *p_Uart,wPin Pin,uint32_t BaudRate,uint32_t StopBits,uint32_t Parity,uint32_t Trans)
{	
	UART_HandleTypeDef* huart = &p_Uart->huart;
	
    uint32_t   Preempt = NoUse_Pri;
    IRQn_Type  IRQn;
    
    if((Pin==wPIN_U1_A9A10) || (Pin==wPIN_U1_B6B7))
    {
        huart->Instance=USART1;
        __HAL_RCC_USART1_CLK_ENABLE();
        if(Pin==wPIN_U1_A9A10)
        {            
            wGpio_Init(wPIN_A9,GPIO_MODE_AF_PP,GPIO_NOPULL,GPIO_SPEED_FREQ_HIGH,GPIO_AF7_USART1);
            wGpio_Init(wPIN_A10,GPIO_MODE_AF_PP,GPIO_NOPULL,GPIO_SPEED_FREQ_HIGH,GPIO_AF7_USART1);  
        }else
        {	
            wGpio_Init(wPIN_B6,GPIO_MODE_AF_PP,GPIO_NOPULL,GPIO_SPEED_FREQ_HIGH,GPIO_AF7_USART1);
            wGpio_Init(wPIN_B7,GPIO_MODE_AF_PP,GPIO_NOPULL,GPIO_SPEED_FREQ_HIGH,GPIO_AF7_USART1); 
        }
        
        Preempt = USART1_Pri;
        IRQn = USART1_IRQn;   
        Int_huart[0] = huart;
    }
    else if((Pin==wPIN_U2_A2A3) || (Pin==wPIN_U2_D5D6))
    {
        huart->Instance=USART2;
        __HAL_RCC_USART2_CLK_ENABLE();
        if(Pin==wPIN_U2_A2A3)
        {	
            wGpio_Init(wPIN_A2,GPIO_MODE_AF_PP,GPIO_NOPULL,GPIO_SPEED_FREQ_HIGH,GPIO_AF7_USART2);
            wGpio_Init(wPIN_A3,GPIO_MODE_AF_PP,GPIO_NOPULL,GPIO_SPEED_FREQ_HIGH,GPIO_AF7_USART2); 
          
        }else
        { 
            wGpio_Init(wPIN_D5,GPIO_MODE_AF_PP,GPIO_NOPULL,GPIO_SPEED_FREQ_HIGH,GPIO_AF7_USART2);
            wGpio_Init(wPIN_D6,GPIO_MODE_AF_PP,GPIO_NOPULL,GPIO_SPEED_FREQ_HIGH,GPIO_AF7_USART2);  
        }
        Preempt = USART2_Pri;
        IRQn = USART2_IRQn; 
        Int_huart[1] = huart;        
    }
    else if((Pin==wPIN_U3_B10B11) || (Pin==wPIN_U3_C10C11) || (Pin==wPIN_U3_D8D9))
    {
        huart->Instance=USART3;
        __HAL_RCC_USART3_CLK_ENABLE();
        if(Pin==wPIN_U3_B10B11)
        {          		
            wGpio_Init(wPIN_B10,GPIO_MODE_AF_PP,GPIO_NOPULL,GPIO_SPEED_FREQ_HIGH,GPIO_AF7_USART3);
            wGpio_Init(wPIN_B11,GPIO_MODE_AF_PP,GPIO_NOPULL,GPIO_SPEED_FREQ_HIGH,GPIO_AF7_USART3);  
        }else if(Pin==wPIN_U3_C10C11)
        {          	
            wGpio_Init(wPIN_C10,GPIO_MODE_AF_PP,GPIO_NOPULL,GPIO_SPEED_FREQ_HIGH,GPIO_AF7_USART3);
            wGpio_Init(wPIN_C11,GPIO_MODE_AF_PP,GPIO_NOPULL,GPIO_SPEED_FREQ_HIGH,GPIO_AF7_USART3);             
        }else
        {
            wGpio_Init(wPIN_D8,GPIO_MODE_AF_PP,GPIO_NOPULL,GPIO_SPEED_FREQ_HIGH,GPIO_AF7_USART3);
            wGpio_Init(wPIN_D9,GPIO_MODE_AF_PP,GPIO_NOPULL,GPIO_SPEED_FREQ_HIGH,GPIO_AF7_USART3);
        } 
        Preempt = USART3_Pri;
        IRQn = USART3_IRQn; 
        Int_huart[2] = huart;         
    }
    else if(Pin==wPIN_U4_C10C11)
    {
        huart->Instance=UART4;
        __HAL_RCC_UART4_CLK_ENABLE();
        wGpio_Init(wPIN_C10,GPIO_MODE_AF_PP,GPIO_NOPULL,GPIO_SPEED_FREQ_HIGH,GPIO_AF8_UART4);
        wGpio_Init(wPIN_C11,GPIO_MODE_AF_PP,GPIO_NOPULL,GPIO_SPEED_FREQ_HIGH,GPIO_AF8_UART4);  
        Preempt = UART4_Pri;
        IRQn = UART4_IRQn;  
        Int_huart[3] = huart; 		
	}
    else if(Pin==wPIN_U5_C12D2)
    {
        huart->Instance=UART5;
        __HAL_RCC_UART5_CLK_ENABLE();
        wGpio_Init(wPIN_C12,GPIO_MODE_AF_PP,GPIO_NOPULL,GPIO_SPEED_FREQ_HIGH,GPIO_AF8_UART5);
        wGpio_Init(wPIN_D2,GPIO_MODE_AF_PP,GPIO_NOPULL,GPIO_SPEED_FREQ_HIGH,GPIO_AF8_UART5);  
        Preempt = UART5_Pri;
        IRQn = UART5_IRQn; 
        Int_huart[4] = huart;         
    }
    else
        {return NULL;}  
    if(Preempt != NoUse_Pri)
    {
        HAL_NVIC_SetPriority(IRQn, Preempt, 0);
        HAL_NVIC_EnableIRQ(IRQn); 
    }
    wUart_List(p_Uart);   
    huart->Init.BaudRate = BaudRate;
    if(StopBits==2)
    {
        huart->Init.StopBits = UART_STOPBITS_2;
    }
    else
    {
       huart->Init.StopBits = UART_STOPBITS_1;
    }
    if(IS_UART_PARITY(Parity))
    {
        huart->Init.Parity = Parity;
    }
    else
    {
        huart->Init.Parity = UART_PARITY_NONE;
    }
    if(huart->Init.Parity == UART_PARITY_NONE)
    {
        huart->Init.WordLength = UART_WORDLENGTH_8B;
    }
    else
    {
        huart->Init.WordLength = UART_WORDLENGTH_9B;
    }
    huart->Init.HwFlowCtl = UART_HWCONTROL_NONE; 
    huart->Init.OverSampling = UART_OVERSAMPLING_16; //在波特率较大切换UART_OVERSAMPLING_8
    huart->Init.Mode = Trans & 0x00ff;
    if (HAL_UART_Init(huart) != HAL_OK)
    {
        return NULL;
    }
    return huart;
}

3.7 UART（带DMA）初使化函数

UART_HandleTypeDef* wUart_DMAInit(wUart_Def *p_Uart,wPin Pin,uint32_t BaudRate,uint32_t StopBits,uint32_t Parity,uint32_t Trans)
{
	UART_HandleTypeDef* huart = wUart_Init(p_Uart,Pin,BaudRate,StopBits,Parity,Trans); 
	if(huart== NULL) {return NULL;}
    if((Trans & UART_MODE_TX) == UART_MODE_TX)
	{//发送
        __HAL_LINKDMA(huart,hdmatx,p_Uart->hdma_tx);         
        if(huart->Instance==USART1)
        {
            huart->hdmatx->Instance = DMA_USART1_TX_Instance;
            wDma_Init(huart->hdmatx,DMA_USART1_TX_Instance,DMA_CHANNEL_4,DMA_MEMORY_TO_PERIPH,DMA_PDATAALIGN_BYTE,DMA_NORMAL,DMA_PRIORITY_HIGH);
        }else if(huart->Instance==USART2)
        {          
            huart->hdmatx->Instance = DMA_USART2_TX_Instance;  
            wDma_Init(huart->hdmatx,DMA_USART2_TX_Instance,DMA_CHANNEL_4,DMA_MEMORY_TO_PERIPH,DMA_PDATAALIGN_BYTE,DMA_NORMAL,DMA_PRIORITY_HIGH);
        }else if(huart->Instance==USART3)
        {
           huart->hdmatx->Instance = DMA_USART3_TX_Instance;    
           wDma_Init(huart->hdmatx,DMA_USART3_TX_Instance,DMA_CHANNEL_7,DMA_MEMORY_TO_PERIPH,DMA_PDATAALIGN_BYTE,DMA_NORMAL,DMA_PRIORITY_HIGH);
        }else if(huart->Instance==UART4)
        {            
            huart->hdmatx->Instance = DMA_USART4_TX_Instance;
            wDma_Init(huart->hdmatx,DMA_USART2_TX_Instance,DMA_CHANNEL_4,DMA_MEMORY_TO_PERIPH,DMA_PDATAALIGN_BYTE,DMA_NORMAL,DMA_PRIORITY_HIGH);
        }
    }
    
    if((Trans & UART_MODE_RX) == UART_MODE_RX)
    {
        __HAL_LINKDMA(huart,hdmarx,p_Uart->hdma_rx);  
    #if  defined(STM32F4)
            huart->hdmarx->Init.Channel       = DMA_CHANNEL_4;   
    #endif
        if(huart->Instance==USART1)
        {
            huart->hdmarx->Instance = DMA_USART1_RX_Instance;  
            wDma_Init(huart->hdmarx,DMA_USART1_RX_Instance,DMA_CHANNEL_4,DMA_PERIPH_TO_MEMORY,DMA_PDATAALIGN_BYTE,DMA_CIRCULAR,DMA_PRIORITY_LOW);
        }else if(huart->Instance==USART2)
        {       
            huart->hdmarx->Instance = DMA_USART2_RX_Instance;    
            wDma_Init(huart->hdmarx,DMA_USART2_RX_Instance,DMA_CHANNEL_4,DMA_PERIPH_TO_MEMORY,DMA_PDATAALIGN_BYTE,DMA_CIRCULAR,DMA_PRIORITY_LOW);   
        }else if(huart->Instance==USART3)
        {
            huart->hdmarx->Instance = DMA_USART3_RX_Instance;    
            wDma_Init(huart->hdmarx,DMA_USART3_RX_Instance,DMA_CHANNEL_4,DMA_PERIPH_TO_MEMORY,DMA_PDATAALIGN_BYTE,DMA_CIRCULAR,DMA_PRIORITY_LOW);       
        }else if(huart->Instance==UART4)
        {       
            huart->hdmarx->Instance = DMA_USART4_RX_Instance;
            wDma_Init(huart->hdmarx,DMA_USART4_RX_Instance,DMA_CHANNEL_4,DMA_PERIPH_TO_MEMORY,DMA_PDATAALIGN_BYTE,DMA_CIRCULAR,DMA_PRIORITY_LOW);       
        }
    }
    /* Enable the UART Error Interrupt: (Frame error, noise error, overrun error) */
    //__HAL_UART_ENABLE_IT(huart, UART_IT_ERR); 
    return huart ;
}

3.8 UART控制引脚配置（用于485传输）

void wUart_CSSCreate(wUart_Def *p_Uart,wPin pin,wGpio_Level level)
{
    wGpio_putInit(&p_Uart->CSS,pin,GPIO_MODE_OUTPUT_PP,GPIO_NOPULL,GPIO_SPEED_FREQ_HIGH,level); 
    wGpio_putWrite(&p_Uart->CSS,Set_INACTIVE);
}

void wUart_CSSEnable( wUart_Def *p_Uart,uint8_t xEnable )
{
    if (p_Uart->CSS.EN==ENABLE)
    {    
        if(xEnable == wTxEnable)
        {
            wGpio_putWrite(&p_Uart->CSS,Set_INACTIVE);
        }
        else
        {
            wGpio_putWrite(&p_Uart->CSS,Set_ACTIVE);
        }       
	}
}

static void wUart_CSSEnable_Handle( UART_HandleTypeDef *huart,uint8_t xEnable )
{
	wUart_Def  *p_Uart = wUart_ListPtr;
	while (p_Uart != (wUart_Def *)NULL)
    {
        if(huart == &p_Uart->huart)
        {
            wUart_CSSEnable( p_Uart, xEnable );          
            break;
        }
        p_Uart = p_Uart->NextPtr;
    } 
}

3.9 UART中调回调函数配置

void wUart_SetCallback(wUart_Def *p_Uart,UartTxCpltFnct TxCpltPtr,UartRxCpltFnct_Idle RxCplt_IdlePtr)
{
    if(p_Uart != (wUart_Def *)NULL)
    {
        p_Uart->TxCpltPtr = TxCpltPtr;
        p_Uart->RxCplt_IdlePtr = RxCplt_IdlePtr;
    }
}

3.10 UART（带DMA）发送函数

HAL_StatusTypeDef wUart_DMATransmit(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size)
{
    wUart_CSSEnable_Handle( huart,wTxEnable ); 
    return HAL_UART_Transmit_DMA(huart,pData,Size);//开始接收数据    
}

void wUart_AbortTransmit(UART_HandleTypeDef *huart)
{
    wUart_CSSEnable_Handle( huart,wRxEnable );
    __HAL_UART_CLEAR_FLAG(huart, UART_IT_TC | UART_IT_TXE);//清中断
}

3.11 UART（带DMA）接收函数

HAL_StatusTypeDef wUart_DMAReceive(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size)
{
    /* Clean the input path */
    //__HAL_UART_FLUSH_DRREGISTER(huart);
    
    __HAL_UART_CLEAR_FLAG(huart, UART_IT_RXNE);
    __HAL_UART_CLEAR_IDLEFLAG(huart);
    __HAL_UART_ENABLE_IT(huart,UART_IT_RXNE); //使能接收中断    
    __HAL_UART_ENABLE_IT(huart,UART_IT_IDLE); //使能空闲中断

    wUart_CSSEnable_Handle( huart,wRxEnable ); 
    return HAL_UART_Receive_DMA(huart,pData,Size);//开始接收数据    
}

void wUart_AbortReceive(UART_HandleTypeDef *huart)
{
    //__HAL_UART_DISABLE_IT(huart,UART_IT_RXNE); //关闭空闲中断     
    __HAL_UART_DISABLE_IT(huart,UART_IT_IDLE); //关闭空闲中断      
    __HAL_UART_CLEAR_FLAG(huart, UART_IT_RXNE);
    __HAL_UART_CLEAR_IDLEFLAG(huart); //清空闲中断    
    
    HAL_UART_AbortReceive_IT(huart); //停止uart接收功能
}

3.12 UART中断处理函数

void USART1_IRQHandler(void)
{
    OSIntEnter();
    if(Int_huart[0] != NULL)  
    {
		HAL_UART_RxCpltCallback_Idle(Int_huart[0]);		
        HAL_UART_IRQHandler(Int_huart[0]);
    }
    else
    {
        HAL_NVIC_ClearPendingIRQ(USART1_IRQn);       
    }	   
    OSIntExit(); 
}

void USART2_IRQHandler(void)
{
    OSIntEnter();
    if(Int_huart[1] != NULL)  
    {
		HAL_UART_RxCpltCallback_Idle(Int_huart[1]);		
        HAL_UART_IRQHandler(Int_huart[1]);
    }
    else
    {
        HAL_NVIC_ClearPendingIRQ(USART2_IRQn);       
    }     
    OSIntExit(); 
}

void USART3_IRQHandler(void)
{
    OSIntEnter();    
    if(Int_huart[2] != NULL)  
    {
		HAL_UART_RxCpltCallback_Idle(Int_huart[2]);		
        HAL_UART_IRQHandler(Int_huart[2]);
    }
    else
    {
        HAL_NVIC_ClearPendingIRQ(USART3_IRQn);       
    }  
    OSIntExit(); 
}

void UART4_IRQHandler(void)
{
    OSIntEnter();
    if(Int_huart[3] != NULL)  
    {
		HAL_UART_RxCpltCallback_Idle(Int_huart[3]);		
        HAL_UART_IRQHandler(Int_huart[3]);
    }
    else
    {
        HAL_NVIC_ClearPendingIRQ(UART4_IRQn);       
    }    
    OSIntExit(); 
}

void UART5_IRQHandler(void)
{
    OSIntEnter();
    if(Int_huart[4] != NULL)  
    {
		HAL_UART_RxCpltCallback_Idle(Int_huart[4]);		
        HAL_UART_IRQHandler(Int_huart[4]);
    }
    else
    {
        HAL_NVIC_ClearPendingIRQ(UART5_IRQn);       
    }     
    OSIntExit(); 
}

3.13 UART中断回调函数—发送完成

void HAL_UART_TxCpltCallback(UART_HandleTypeDef *huart)
{
    wUart_Def  *p_Uart = wUart_ListPtr;
    wUart_AbortTransmit(huart);
    while (p_Uart != (wUart_Def *)NULL)
    {
        if(huart == &p_Uart->huart)
        {
            if( p_Uart->TxCpltPtr != (UartTxCpltFnct )NULL)
            {
                p_Uart->TxCpltPtr(huart);
            }               
            break;           
        }
        p_Uart = p_Uart->NextPtr;
    }
}

3.14 UART中断回调函数—空闲接收

void HAL_UART_RxCpltCallback_Idle(UART_HandleTypeDef *huart)
{ 
    wUart_Def  *p_Uart = wUart_ListPtr;
    if(__HAL_UART_GET_FLAG(huart,UART_FLAG_IDLE) != RESET)  
    { 
        
#if  defined(STM32F1)    
    uint32_t length = huart->RxXferSize - huart->hdmarx->Instance->CNDTR;   
#elif  defined(STM32F4)
    uint32_t length = huart->RxXferSize - huart->hdmarx->Instance->NDTR;      
#endif 
        wUart_AbortReceive(huart); 
        
        while (p_Uart != (wUart_Def *)NULL)
        {
            if(huart == &p_Uart->huart)
            {
                if( p_Uart->RxCplt_IdlePtr != (UartRxCpltFnct_Idle )NULL)
                {
                    p_Uart->RxCplt_IdlePtr(huart,length);
                }                
                break;           
            }
            p_Uart = p_Uart->NextPtr;
        }        
    }
}
嵌远科技
关注
  • 0
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
STM32 UART串口驱动程序
Sheep Tech Blog
11-26 6310
文章原始地址: http://www.sheeptech.cc/?id=14 示例1.通过UART1进行数据发送 UART 1 的初始化 /** * @brief UART1 Initialise. * @param None. * @retval None. */ void UART1_Init(void) { GPIO_InitTypeDef GPIO_InitStru...
UART驱动（适用于STM32F030/031）
11-23
基于Wolf32F031 自由评估板的UART驱动（适用于STM32F030/031
STM32使用寄存器开发底层驱动学习（USART+DMA）
在知识与无知里反复横跳。
10-22 4609
代码简洁明了，当然需要我们注释好，不然比标准库更难看懂。方便快捷，只需要一本《手册》就可以查看所有的寄存器，不需要像标准库那样记、找每个函数、每个参数的作用。
stm32_uart：stm32 uart驱动程序
02-21
Stm32_uart驱动程序 该驱动程序还使用中断和可调缓冲区进行发送和接收。 接收时，可以对接收到的每个字符使用回调函数。 因此，例如可以检测行尾字符。 初始化将在首次使用期间发生，因此没有uart_init函数。 可用于微控制器系列 stm32f0xx stm32f1xx stm32f2xx stm32f3xx stm32f4xx stm32f7xx stm32h7xx 示例应用 app_uart_test：此程序显示如何通过逐行处理来接收和转发在串行线上接收到的文本数据。 Uart功能 uartx_sendchar（char c）：向usart发送一个字符注意：如果TX缓冲区已满，它将等待直到其中有可用空间 uartx_getchar（char * c）; 在uart rx上接收字符注意：如果return = 0->未接收到字符（不阻止程序运行），如果return = 1
Stm32高级驱动编程-第1章 GPIO驱动
abc240697738的博客
10-23 1110
第1章 GPIO驱动1.1 GPIO封装需求1.2 GPIO 引脚编号1.3 GPIO 引脚直接初使化函数1.4 GPIO结构体引用1.5 GPIO 引脚带句柄式初使化函数1.6 GPIO 引脚带句柄式读函数1.7 GPIO 引脚带句柄式写函数 1.1 GPIO封装需求 对于初使化一个GPIO引脚，比如说一个LED灯的控制引脚GPIOA上的第GPIO_PIN_1，通常做法是这样子： GPIO_I...
能不能基于stm32写个UART驱动
weixin_42613017的博客
02-16 98
可以的，您可以在STM32上编写UART驱动程序。以下是一些概述步骤： 首先，您需要了解STM32的串行通信模块，并熟悉其寄存器的操作方式。 然后，您可以使用STM32提供的库函数，如HAL库或LL库，来编写UART驱动程序。这些库函数可以帮助您简化代码，并提高开发效率。 接下来，您需要选择要使用的UART模块，并将其配置为所需的参数，如波特率、数据位数、停止位数、奇偶校验等。这通常涉及到设...
STM32LL库编程系列第三讲-USART+DMA通信工程
04-27
STM32LL库编程系列第三讲主要探讨了如何利用USART（通用同步异步收发传输器）结合DMA（直接存储器访问）进行高效的串行通信。在这个工程中，我们将会深入理解STM32微控制器的低功耗库（LL库）如何与硬件资源协同工作...
STM32F767驱动HLK-RM04模组，实现串口以太网、WIFI STA、AP通信等功能【支持STM32F7系列，寄存器库】
06-02
STM32F767虽然不内置TCP/IP协议栈，但可以使用第三方库，如lwIP或uIP，或者直接操作原始的网络协议数据包。在驱动HLK-RM04时，我们需将这些协议栈的API封装成适配HLK-RM04的函数。 对于Wi-Fi功能，HLK-RM04支持两种...
STM32F103驱动TFTLCD显示屏【支持STM32F10X系列单片机】
11-20
2. **库函数驱动**：为简化开发，通常会提供一系列的库函数，如STM32的标准库或第三方库。这些库函数封装了寄存器操作，提供了更高级别的接口，如初始化、画点、画线、填充颜色等。使用库函数可以减少代码量，提高...
STM32F103-IAR-boot-to-sys
05-21
STM32 HAL库（Hardware Abstraction Layer，硬件抽象层）是ST公司为STM32系列微控制器提供的一个高级软件框架。它提供了与硬件无关的API，使得开发者可以更轻松地进行跨平台编程。HAL库的主要优点包括简化代码、增强...
STM32串口驱动程序V1.5
01-05
STM32虚拟串行接口驱动程序，v1.5，适用于windows 各版本
STM32H743驱动ESP8266实现TCP网络通信【支持STM32H7系列单片机】.zip
05-31
在实际开发中，为了简化编程，可以采用第三方库如lwIP或FreeRTOS+ lwIP，它们提供了完善的TCP/IP协议栈实现。此外，为了调试方便，可以使用串口终端工具监控AT命令的交互过程，或者通过STM32的其他接口如USART或USB...
STM32串口驱动
weixin_51121577的博客
10-15 3639
STM32串口驱动
驱动开发分为一种如STM32的裸机驱动和linux驱动
诗筱涵的博客
09-13 499
驱动开发分为一种如STM32的裸机驱动和linux驱动 。
STM32CubeIDE开发(八)， UART的CubeMX及HAL库实现原理及底层分析
技术需要分享
12-25 1933
cubeIDE开发， UART的CubeMX及HAL库实现原理及底层分析，分析串口参数设置与串口寄存器数据位映射、HLA实现串口参数配置、收发数据的底层原理。
（实测可用）STM32L431RCT6开发板-实验6 串口DMA收发实验
zhej2014的博客
12-06 2743
1、开发板资源简介 （1）开发板主芯片型号：STM32L431RCT6 （2）开发板主芯片封装：LQFP-64_10x10x05P （3）开发板主芯片内核：ARM® Cortex®-M4 （4）开发板主芯片主频：80MHz （5）开发板主芯片Flash大小：256KB （6）开发板主芯片RAM大小：64KB
STM32之UART、RS232、RS485通讯
weixin_41830837的博客
04-09 7852
shu一、USART解释 USART是一个全双工通用同步/异步串行收发模块，该接口是一个高度灵活的串行通信设备，相互独立的接收数据和发送数据；任何USART双向通信至少需要两个脚：接收数据输入(RX)和发送数据输出(TX)。为什么三种通讯方式一起学习呢？因为单片机最后都是要用到UASRT这个功能与外界通讯的。由于UART规定只是规定了数据（信号的时序）的格式，并没有规定接口的电气特性，这样导致了他们在物理层无法实现互联。 UART通讯时一般直接用处理器自己的TTL电平，（高电平表示1，低电平代...
基于STM32之UART串口通信协议（一）详解
weixin_30809173的博客
05-04 2769
一、前言 1、简介 　　写的这篇博客，是为了简单讲解一下UART通信协议，以及UART能够实现的一些功能，还有有关使用STM32CubeMX来配置芯片的一些操作，在后面我会以我使用的STM32F429开发板来举例讲解（其他STM32系列芯片大多数都可以按照这些步骤来操作的），如有不足请多多指教。 2、UART简介 　　嵌入式开发中，UART串口通信协议是我们常用的通信协议（UART、I2C...
java毕业作品-JAVA技术在《堡垒》手机游戏开发中的应用与探索(源代码+论文)
最新发布
08-03
java毕业作品_JAVA技术在《堡垒》手机游戏开发中的应用与探索(源代码+论文)
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值