通过操作Cortex-A7核，串口输入相应的命令，控制LED灯进行工作

通过操作Cortex-A7核，串口输入相应的命令，控制LED灯进行工作--->上传CSDN 1.例如在串口输入led1on,开饭led1灯点亮 2.例如在串口输入led1off,开饭led1灯熄灭 3.例如在串口输入led2on,开饭led2灯点亮 4.例如在串口输入led2off,开饭led2灯熄灭 5.例如在串口输入led3on,开饭led3灯点亮 6.例如在串口输入led3off,开饭led3灯熄灭

头文件

#include"stm32mp1xx_rcc.h"                                                                           
#include"stm32mp1xx_uart.h"                                                                          
#define RCC_AHB4_ENSETR (*(volatile unsigned int*)0x50000A28)                                        
                                                                                                     
//寄存器MODER模式初始化                                                                              
typedef enum{                                                                                        
    Input,                                                                                           
    Output,                                                                                          
    Alt_fun,                                                                                         
    Analog,                                                                                          
}gpio_moder_t;                                                                                       
                                                                                                     
//寄存器OTYPER输出类型                                                                               
typedef enum{                                                                                        
    PP,                                                                                              
    OD,                                                                                              
}gpio_otyper_t;                                                                                      
                                                                                                     
//寄存器OSPEEDR输出速度                                                                              
typedef enum{                                                                                        
    LOW,                                                                                             
    MED,                                                                                             
    HIGH,                                                                                            
    VERY_HIGH,                                                                                       
}gpio_ospeedr_t;                                                                                     
                                                                                                     
//寄存器PUPDR是否需要上下拉                                                                          
typedef enum{                                                                                        
    NO_PUPDR,                                                                                        
    PU,                                                                                              
    PD,                                                                                              
    RESERVED,                                                                                        
}gpio_pupdr_t;                                                                                       
                                                                                                     
                                                                                                     
//对gpio引脚状态封装                                                                                 
typedef enum{                                                                                        
    gpio_reset_t,                                                                                    
    gpio_set_t,                                                                                      
}gpio_status_t;                                                                                      
                                                                                                     
//对GPIO进行初始化                                                                                   
typedef struct{                                                                                      
    gpio_moder_t moder; //模式                                                                       
    gpio_otyper_t otyper; //类型                                                                     
    gpio_ospeedr_t speedr; //速度                                                                    
    gpio_pupdr_t pupdr; //是否需要上下拉                                                             
}gpio_init_t;                                                                                        
                                                                                                     
typedef struct                                                                                       
{                                                                                                    
    char *cmd_str;  //命令行字符串                                                                   
    gpio_t* gpiox;  //gpio组号                                                                       
    unsigned int pin; //引脚编号                                                                     
    gpio_status_t status; //LED灯状态                                                                
    void (*gpio_write_pin)(gpio_t* gpiox,unsigned int pin,gpio_status_t status);                     
}cmd_t;                                                                                              
                                                                                                     
                                                                                                     
//对GPIO引脚初始化函数                                                                               
void hal_gpio_init(gpio_t* gpiox,gpio_init_t* init,unsigned int pin);                                
                                                                                                     
//对GPIO引脚写操作函数                                                                               
void hal_gpio_write(gpio_t* gpiox,unsigned int pin,gpio_status_t state);                             
                                                                                                     
                                                                                                     
                                                                                                     
//初始化                                                                                             
void uart();                                                                                         
                                                                                                     
//发送一个字符                                                                                       
void write_char(char str);                                                                           
                                                                                                     
//发送一个字符串                                                                                     
void write_str(const char *str);                                                                     
                                                                                                     
//接受一个字符                                                                                       
char read_char();                                                                                    
                                                                                                     
//接受一个字符串                                                                                     
char *read_str1();                                                                                   
                                                                                                     
cmd_t* find_command();                                                                               
                                                                                                     
                                                                                                     
                                                                                                     
                                                                                                     
#endif                                                                                               

功能文件

ubuntu@ubuntu:01-点灯实验$ cat src/
do_irq.c  do_irq.o  gpio.c    gpio.o    led.c     led.o     
ubuntu@ubuntu:01-点灯实验$ cat src/
do_irq.c  do_irq.o  gpio.c    gpio.o    led.c     led.o     
ubuntu@ubuntu:01-点灯实验$ cat src/gpio.c
#include "gpio.h"

extern void delay_ms(int ms);
 
 void hal_gpio_init(gpio_t* gpiox,gpio_init_t* init,unsigned int pin)
 {
     //1.设置GPIO引脚模式
     gpiox->MODER &= (~(0x3 << (pin * 2)));
     gpiox->MODER |= init->moder << (pin * 2);
     //2.设置GPIO引脚输出类型
     gpiox->OTYPER &= (~(0x1 << pin));
     gpiox->OTYPER |= init->otyper << pin;
     //3.设置GPIO引脚的输出速度
     gpiox->OSPEEDR &= (~(0x3 << (pin * 2)));
     gpiox->OSPEEDR |= init->speedr << (pin * 2);
     //4.设置GPIO引脚是否需要上下拉
     gpiox->PUPDR &= (~(0x3 << (pin * 2)));
     gpiox->PUPDR |= init->pupdr << (pin * 2);
 }
 void hal_gpio_write(gpio_t* gpiox,unsigned int pin,gpio_status_t state)
 {
     if(state == gpio_reset_t)
     {
         gpiox->ODR &= (~(0x1 << pin));
     }else
     {
         gpiox->ODR |= (0x1 << pin);
     }
 }
                                                                                

//初始化
void uart()
{
    //rcc章节
    RCC->MP_AHB4ENSETR|=((0x1<<1));
    RCC->MP_AHB4ENSETR|=((0x1<<6));
    RCC->MP_APB1ENSETR|=((0x1<<16));

    //gpio章节
    //MODER寄存器
    GPIOG->MODER&=(~(0x3<<22));
    GPIOG->MODER|=(0x1<<23);
    GPIOB->MODER&=(~(0x3<<4));
    GPIOB->MODER|=(0x1<<5);
    //AFRL和AFRH寄存器
    GPIOG->AFRH&=(~(0xf<<12));
    GPIOG->AFRH|=(0x3<<13);
    GPIOB->AFRL&=(~(0xf<<8));
    GPIOB->AFRL|=(0x1<<11);

    //uart章节
    if(USART4->CR1&(0x1<<0))
    {
        delay_ms(500);
        USART4->CR1&=(~(0x1));
    }
    //CR1寄存器
    USART4->CR1&=(~(0x1<<12));
    USART4->CR1&=(~(0x1<<28));
    USART4->CR1&=(~(0x1<<15));
    USART4->CR1&=(~(0x1<<10));
    USART4->CR1|=(0x1<<3);
    USART4->CR1|=(0x1<<2);
    USART4->CR1|=(0x1);
    //CR2寄存器
    USART4->CR2&=(~(0x1<<12));
    //BRR寄存器
    USART4->BRR=0x22B;
    //PRESC寄存器
    USART4->PRESC&=(~(0x1));

    USART4->CR1|=(0x1<<3);
    USART4->CR1|=(0x1<<2);
    USART4->CR1|=(0x1);



}

//发送一个字符
void write_char(char str)
{
    while(!(USART4->ISR&0x1<<7));
    USART4->TDR=str;
    while(!(USART4->ISR&0x1<<6));

}

//发送一个字符串
void write_str(const char *str)
{
    while(*str!='\0')
    {
        write_char(*str);             
        str++;
    }
    write_char('\n');
    write_char('\r');
}

//接受一个字符
char read_char()
{
    while(!(USART4->ISR&0x1<<5));
    char cha=0;
    cha=USART4->RDR;
    return cha;
}

//接受一个字符串
char buf[512]={0};
char *read_str1()
{

    int i=0;
    while(1)
    {

        buf[i]=read_char();
        if(buf[i] == '\r') break;
        i++;
    }

    buf[i]='\0';
    write_str(buf);

    return buf;

}