十一假期作业 UART串口实验

原理图

框图分析

代码

main.c

#include "uart4.h"                          
                                            
extern void printf(const char *fmt, ...);   
void delay_ms(int ms)                       
{                                           
    int i,j;                                
    for(i = 0; i < ms;i++)                  
        for (j = 0; j < 1800; j++);         
}                                           
                                            
int main()                                  
{                                           
    //1.调用初始化函数                      
    init_uart4();                           
                                            
    //2.发送字符串                          
    my_puts("uart4 test!!!!");              
                                            
    while(1)                                
    {                                       
        my_puts(my_gets());                 
    }                                       
    return 0;                               
}                                           
                                            

uart4.c

#include"uart4.h"                                                          
extern void delay_ms(int ms);                                              
//初始化                                                                   
void init_uart4()                                                          
{                                                                          
    /*******RCC章节初始化******/                                           
                                                                           
    //1.使能GPIOB控制器 MP_AHB4ENSETR[1] = 1                               
    RCC->MP_AHB4ENSETR |=(0x1<<1);                                         
    //2.使能GPIOG控制器 MP_AHB4ENSETR[6] = 1                               
    RCC->MP_AHB4ENSETR |=(0x1<<6);                                         
    //3.使能USART4控制器 MP_APB1ENSETR[16] = 1                             
    RCC->MP_APB1ENSETR |=(0x1<<16);                                        
                                                                           
                                                                           
                                                                           
    /*******GPIO章节初始化******/                                          
                                                                           
    //PB2---->USART4_Rx                                                    
    //PG11----->USART4_Tx                                                  
    //1.设置PB2引脚为复用功能 MODER[5:4] = 10                              
    GPIOB->MODER &=(~(0x3<<4));                                            
    GPIOB->MODER |=(0x1<<5);                                               
    //2.设置PB2引脚复用功能为USART4_Rx AFRL[11:8] = 1000                   
    GPIOB->AFRL &=(~(0xf<<8));                                             
    GPIOB->AFRL |=(0x1<<11);                                               
                                                                           
    //3.设置PG11引脚为复用功能 MODER[23:22] = 10                           
    GPIOG->MODER &=(~(0x3<<22));                                           
    GPIOG->MODER |=(0x1<<23);                                              
    //4.设置PG11引脚复用功能为USART4_Tx  AFRH[15:12] = 0110                
    GPIOG->AFRH &=(~(0xf<<12));                                            
    GPIOG->AFRH |=(0x3<<13);                                               
                                                                           
                                                                           
                                                                           
    /*******UART章节初始化******/                                          
                                                                           
    //将UE为禁止 CR1[0] = 0                                                
    while(USART4->CR1 & (0x1<<0))                                          
    {                                                                      
        delay_ms(500);                                                     
        USART4->CR1 &=(~(0x1<<0));                                         
    }                                                                      
                                                                           
    //1.串口初始化 8位数据位 无奇偶校验位 CR1[28][12]=00 CR1[10]=0         
    USART4->CR1 &=(~(0x1<<28));                                            
    USART4->CR1 &=(~(0x1<<12));                                            
    USART4->CR1 &=(~(0x1<<10));                                            
                                                                           
    //2.设置串口一位停止位 CR2[13:12] = 00                                 
    USART4->CR2 &=(~(0x3<<12));                                            
                                                                           
    //3.设置串口16倍采样率 CR1[15] = 0                                     
    USART4->CR1 &=(~(0x1<<15));                                            
                                                                           
    //4.设置串口不分频 PRESC[3:0] = 0000                                   
    USART4->PRESC &=(~(0xf<<0));                                           
                                                                           
    //5.设置串口波特率115200   BRR = 0x22b                                 
    USART4->BRR=0x22b;                                                     
                                                                           
    //6.设置串口发送器使能 CR1[3] = 1                                      
    USART4->CR1 |=(0x1<<3);                                                
                                                                           
    //7.设置串口接收器使能 CR1[2] = 1                                      
    USART4->CR1 |=(0x1<<2);                                                
                                                                           
    //8.设置串口使能 CR1[0] = 1  -->UE                                     
    USART4->CR1 |=(0x1<<0);                                                
}                                                                          
                                                                           
                                                                           
//发送一个字符                                                             
void my_putc(const char strc)                                              
{                                                                          
    //1.判断发送数据寄存器是否有数据 ISR[7]                                
    //读0:发送数据寄存器满，需要等待                                       
    //读1:发送数据寄存器为空，才可以发送下一个字节数据                     
    while(!(USART4->ISR & (0x1<<7)));                                      
                                                                           
    //2.将要发送的字符，写入到发送数据寄存器中                             
    USART4->TDR =strc;                                                     
                                                                           
    //3.判断发送数据是否发送完成                                           
    //读0:发送数据没有完成，需要等待                                       
    //读1:发送数据完成，可以发送下一帧数据                                 
    while(!(USART4->ISR & (0x1<<6)));                                      
                                                                           
}                                                                          

                                                
//接收一个字符                                  
char my_getc()                                  
{                                               
    char ch;                                    
    //1.判断接收寄存器是否有数据可读 ISR[5]     
    //读0:没有数据可读，需要等待                
    //读1:有数据可读                            
    while(!(USART4->ISR & (0x1 << 5)));         
                                                
    //2.将接收数据寄存器中的内容读出来          
    ch = USART4->RDR;                           
    return ch;                                  
}                                               

                                                                       
//发送一串字符                                                         
void my_puts(const char * str)                                         
{                                                                      
    //判断是否为'\0'                                                   
    //一个一个字符的进行发送                                           
    unsigned int i=0;                                                  
    while(str[i])                                                      
    {                                                                  
        my_putc(str[i]);                                               
        i++;                                                           
    }                                                                  
    my_putc('\n');                                                     
    my_putc('\r');                                                     
}                                                                      
                                                                       
char buff[50]={0};                                                     
//接收一串字符                                                         
char * my_gets()                                                       
{                                                                      
    unsigned int i=0;                                                  
    for(i=0;i<49;i++)             //49，给\0留位置                     
    {                                                                  
        buff[i]=my_getc();                                             
        my_putc(buff[i]);                                              
        if(buff[i]=='\r')                                              
            break;                                                     
    }                                                                  
    buff[i]='\0';                                                      
    my_putc('\n');                                                     
    return buff;                                                       
}                                                                      
                                                                                                              

uart.h

#ifndef __UART4_H__                          
#define __UART4_H__                          
#include "stm32mp1xx_rcc.h"                  
#include "stm32mp1xx_gpio.h"                 
#include "stm32mp1xx_uart.h"                 
                                             
//初始化                                     
void init_uart4();                           
//发送一个字符                               
void my_putc(const char strc);               
//接收一个字符                               
char my_getc();                              
//发送一串字符                               
void my_puts(const char *str);               
//接收一串字符                               
char * my_gets();                            
#endif