通过操作Cortex-A7核，串口输入相应的命令，控制LED灯进行工作（结构体封装）

程序：

uart_led.h:

#ifndef __TEST_H__
#define __TEST_H__
 
#include "stm32mp1xx_rcc.h"
#include "stm32mp1xx_gpio.h"
#include "stm32mp1xx_uart.h"

#define GPIO_PIN_8 8
#define GPIO_PIN_9 9
#define GPIO_PIN_10 10

//GPIO章节初始化
void GPIO_INIT();

//UART章节初始化
void UART_INIT();

//RCC章节初始化
void RCC_INIT();

//发送一个字符
void put_char(const char str);

//发送一个字符串
void put_string(const char* str);

//接收一个字符
char get_char();

//接收一个字符串
char* get_string();

//字符串比较函数
int my_strcmp(char *a,char *b);

//封装灯泡亮灭枚举
typedef enum 
{
	reset_t,
	set_t,
}status_t;


//结构体封装
typedef struct{
	char* cmd_arr; //命令行字符串
	gpio_t* gpiox;//GPIO组号
	unsigned int pin; //引脚编号
	status_t status; //LED灯状态  
	void(*gpio_write_pin)(gpio_t* gpiox,unsigned int pin,status_t status);  
}cmd_t;
cmd_t* find_command(char* str);


//重写函数
void hall_gpio_write(gpio_t* gpiox,unsigned int pin,status_t state);
#endif

uart_led.c:

#include "test.h"
 
//GPIO章节初始化                                                                
void GPIO_INIT()
{
	//设置3个灯的模式
	GPIOE->MODER&=(~(0x3<<20));
	GPIOE->MODER|=(0x1<<20);
	GPIOF->MODER&=(~(0x3<<20));
	GPIOF->MODER|=(0x1<<20);
	GPIOE->MODER&=(~(0x3<<16));
	GPIOE->MODER|=(0x1<<16);
	
	//设置推挽输出
	GPIOE->OTYPER&=(~(0x1<<10));
	GPIOF->OTYPER&=(~(0x1<<10));
	GPIOE->OTYPER&=(~(0x1<<8));
	
	//设置低速
	GPIOE->OSPEEDR&=(~(0x3<<20));
	GPIOF->OSPEEDR&=(~(0x3<<20));
	GPIOE->OSPEEDR&=(~(0x3<<16));
	
	//不需要上拉
	GPIOE->PUPDR&=(~(0x3<<20));
	GPIOF->PUPDR&=(~(0x3<<20));
	GPIOE->PUPDR&=(~(0x3<<16));
		
/**********************************/
	//设置GPIOB引脚输出为复用模式
	GPIOB->MODER&=(~(0x3<<4));
	GPIOB->MODER|=(0x2<<4);

	//设置GPIOG引脚输出模式
	GPIOG->MODER&=(~(0x3<<22));
	GPIOG->MODER|=(0x2<<22);

	//设置GPIOB功能复用模式
	GPIOB->AFRL&=(~(0x15<<8));
	GPIOB->AFRL|=(0x8<<8);
	//设置GPIOG功能复用模式
	GPIOG->AFRH&=(~(0x6<<12));
	GPIOG->AFRH|=(0x6<<12);


}
                                                                                
//UART章节初始化                                                                
void UART_INIT()
{
	//1.USART_CR1：设置数据位宽度，串口/发送位/接收位使能
	//设置宽度
	USART4->CR1&=(~(0x1<<12));
	USART4->CR1&=(~(0x1<<28));
	//USART_CR1[15]：写0 ----->设置串口采样率为16倍
	
	USART4->CR1&=(~(0x1<<15));
	//USART_CR1[10]：写0 ----->设置串口无奇偶校验位
	USART4->CR1&=(~(0x1<<10));

	//USART_CR1[3]：设置串口接收器使能
	USART4->CR1|=(0x1<<3);

	//USART_CR1[2]：设置串口发送器使能
	USART4->CR1|=(0x1<<2);
	//USART_CR1[0]：设置串口使能
	USART4->CR1|=(0x1);

	//2.USART_CR2：设置串口停止位

	//USART_CR2[13:12] = 00 ------>设置串口1位停止位
	USART4->CR2&=(~(0x3<<12));	
		
	//3.设置一级分配
	USART4->PRESC&=(~(0x15));
	//4.USART_BRR：设置串口波特率
	USART4->BRR=0x22B;

}
                                                                                
//RCC章节初始化                                                                 
void RCC_INIT()
{
	//对GPIOE和GPIOG使能
	RCC->MP_AHB4ENSETR|=(0x3<<4);       

	//对GPIOB使能
	RCC->MP_AHB4ENSETR|=(0x1<<1);
	//对GPIOG使能
	RCC->MP_AHB4ENSETR|=(0x1<<6);
	//对UART4使能
	RCC->MP_APB1ENSETR|=(0x1<<16);

}
                                                                                
//发送一个字符                                                                  
void put_char(const char str)
{
	//1.判断发送数据寄存器是否为空,为空，才可以发送下一个字节  	
	//ISR[7]                                                   
	//读0:发送数据寄存器满，需要等待                           
	//读1:发送数据寄存器空，才可以发送下一个字节数据           
	while(!(USART4->ISR & (0x1 << 7)));                        

	//2.将要发送的字符，写到发送数据寄存器中                   
	USART4->TDR = str;                                         
	//3.判断发送数据是否完成 ISR[6]                            

	while(!(USART4->ISR & (0x1<<6)));

}
                                                                                
//发送一个字符串                                                                
void put_string(const char* str)
{
	//判断是否为'\0',一个字符一个字符发送  
	for(int i=0;str[i]!='\0';i++)
	{
		put_char(str[i]);	

	}
	put_char('\n');
	put_char('\r');

}
                                                                                
//接收一个字符                                                                  
char get_char()
{
	char ch;                                         
	//1.判断接收数据寄存器是否有数据可读 ISR[5]      
	while(!(USART4->ISR & (0x1<<5)));  

	//2.将接收到的数据读出来                         
	ch = USART4->RDR;                                
	return ch;    

}
         
char buf[50]={0};

//接收一个字符串                                                                
char* get_string()
{

	//for循环
	int i=0;
	//while(!(USART4->ISR & (0x1<<5)));  

	//当键盘的回车键'\r'按下之后，字符串输入完成  
	for(i=0;(buf[i]=get_char())!='\r';i++)
	{
		put_char(buf[i]);

	}

	//字符串补'\0'                                 
	buf[i] = '\0';  
	put_char('\n');
	put_char('\r');
	return buf;

}
                                                                                
//字符串比较函数                                                                
int my_strcmp(char *a,char *b)
{
	while(*a || *b)
	{
		if(*a!=*b)
		{
			return *a-*b;
		}
		a++;
		b++;
	}
	return 0;

}
                                                                                
//结构体封装                                                                    
cmd_t cmd_arr[6] ={
	[0]={"led1on" ,GPIOE,GPIO_PIN_10,set_t,hall_gpio_write},
	[1]={"led1off",GPIOE,GPIO_PIN_10,reset_t,hall_gpio_write},
	[2]={"led2on" ,GPIOF,GPIO_PIN_10,set_t,hall_gpio_write},
	[3]={"led2off",GPIOF,GPIO_PIN_10,reset_t,hall_gpio_write},
	[4]={"led3on" ,GPIOE,GPIO_PIN_8 ,set_t,hall_gpio_write},
	[5]={"led3off",GPIOE,GPIO_PIN_8 ,reset_t,hall_gpio_write}
};

cmd_t* find_command(char* str)
{
	//在串口中输入的字符串,与结构体中每个元素的cmd_arr变量进行比较
	//遍历比较,自己编写的strcmp函数
	for(int i=0; i<6; i++)
	{
		if(my_strcmp(str,cmd_arr[i].cmd_arr)==0)
		{
			return &cmd_arr[i];
		}
	}
	return 0; 		//失败返回0

}
                                                                                
//对GPIO引脚写控制灯光亮灭函数
void hall_gpio_write(gpio_t* gpiox,unsigned int pin,status_t state)
{
	if(state == set_t)
	{
		gpiox->ODR |=(0x1<<pin);
	}
	else if(state == reset_t)
	{
		gpiox->ODR &= (~(0x1<<pin)); 
	}
}

main.c:

#include "test.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()
{
	RCC_INIT();
	GPIO_INIT();
	UART_INIT();

	while(1)
	{
		cmd_t* cmd_arr;
		char *string = get_string();
		cmd_arr = find_command(string);
		if(cmd_arr == 0)
		{
			put_string("error");
		}
		else
		{
		    cmd_arr->gpio_write_pin(cmd_arr->gpiox,cmd_arr->pin,cmd_arr->status);
		}

	}
	return 0;


}

运行效果：