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

1.例如在串口输入led1on,开饭led1灯点亮

2.例如在串口输入led1off,开饭led1灯熄灭

3.例如在串口输入led2on,开饭led2灯点亮

4.例如在串口输入led2off,开饭led2灯熄灭

5.例如在串口输入led3on,开饭led3灯点亮

6.例如在串口输入led3off,开饭led3灯熄灭

头文件

#ifndef __LED_SRT_H_
#define __LED_SRT_H_

#include "stm32mp1xx_rcc.h"
#include "stm32mp1xx_gpio.h"
#include "stm32mp1xx_uart.h"

#define RCC_AHB4_ENSETR (*(volatile unsigned int *)0x50000A28)
#define GPIO_PIN_8 8
#define GPIO_PIN_9 9
#define GPIO_PIN_10 10


//RCC章节初始化
void hal_rcc_init();
//UART初始化
void hal_uart_init();
//GPIO章节初始化
void hal_gpio_init();
//发送一个字符
void hal_put_char(const char str);
//发送一个字符串
void hal_put_str(const char *buffer);
//接收一个字符
char hal_get_char();
//接收一个字符串
char *hal_get_str();
//比较函数
int strcmp(const char *s1,const char *s2);
//对gpio引脚状态封装
typedef enum{
	gpio_reset_t,
	gpio_set_t,
}gpio_status_t;
//1.封装结构体
typedef struct {
	char *cmd_arr;   //命令行字符串
	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;

cmd_t* find_command(const char* str);

//对GPIO引脚写操作函数
void hal_gpio_write(gpio_t* gpiox,unsigned int pin,gpio_status_t state);
#endif

功能函数

#include "led_str.h"
extern void delay_ms(int ms);
extern void printf(const char *fmt, ...);

//RCC章节初始化
void hal_rcc_init()
{
	//RCC对GPIOE\F\G\B组控制器使能,第1.4.5.6位置1
	RCC->MP_AHB4ENSETR|=(0x01<<4);
	RCC->MP_AHB4ENSETR|=(0x01<<5);	
	RCC->MP_AHB4ENSETR|=(0x01<<1);	
	RCC->MP_AHB4ENSETR|=(0x01<<6);	
	//RCC对uart4组控制器使能,第16位置1
	RCC->MP_APB1ENSETR|=(0x1<<16);
}
//UART初始化
void hal_uart_init()
{
	if(USART4->CR1 & (0x1))
	{
		delay_ms(500);
		USART4->CR1 &= (~(0x1));
	}
	//USART_CR1：初始化串口相关操作
	//USART_CR1[28][12]：写00设置数据位宽度为8位
	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_CR2[13:12]:00 	
	USART4->CR2&=(~(0x3<<12));

	//USART_BRR寄存器作用：设置串口的波特率
	USART4->BRR=0x22b;

	//设置串口分频器
	USART4->PRESC&=(~(0xf<<0));

	//USART_CR1[0]：设置串口使能
	USART4->CR1|=(0x1<<0);
}
//GPIO章节初始化
void hal_gpio_init()
{
	/**********初始化PB2\PG11引脚************/
	//GPIOG_MODER寄存器第4.5位,第22.23为复用功能10
	GPIOB->MODER&=(~(0x3<<4));
	GPIOG->MODER&=(~(0x3<<22));
	GPIOB->MODER|=(0x1<<5);
	GPIOG->MODER|=(0x1<<23);
	//设置PB2为复用模式AFRL[11:8]:1000
	GPIOB->AFRL&=(~(0xf<<8));
	GPIOB->AFRL|=(0x1<<11);

	//设置PG11为复用模式AFRL[15:12]:0110
	GPIOG->AFRH&=(~(0xf<<12));
	GPIOG->AFRH|=(0x6<<12);
	/**********初始化PE10\PE8\PF10引脚************/
	//设置为PE10引脚输出模式21:20位01
	GPIOE->MODER&=(~(0x3<<20));
	GPIOE->MODER|=(0x1<<20);
	//设置为PF10引脚输出模式21:20位01
	GPIOF->MODER&=(~(0x3<<20));
	GPIOF->MODER|=(0x1<<20);
	//设置为PE8引脚输出模式17:16位01
	GPIOE->MODER&=(~(0x3<<16));
	GPIOE->MODER|=(0x1<<16);
/*
	//设置为PE10引脚为推挽输出模式10位0
	GPIOE->OTYPER&=(~(0x1<<10));
	//设置为PF10引脚推挽输出模式10位0
	GPIOF->OTYPER&=(~(0x1<<10));
	//设置为PE8引脚推挽输出模式8位0
	GPIOE->OTYPER&=(~(0x1<<8));

	//设置为PE10引脚为低速输出模式21:20位00
	GPIOE->OSPEEDR&=(~(0x3<<20));
	//设置为PF10引脚低速输出模式21:20位00
	GPIOF->OSPEEDR&=(~(0x3<<20));
	//设置为PE8引脚低速输出模式17:16位00
	GPIOE->OSPEEDR&=(~(0x3<<16));
*/
}

//发送一个字符
void hal_put_char(const char str)
{
	//判断发送寄存器是否为空(1),如果为空则可以写入下一个字符
	while(!(USART4->ISR&(0x1<<7)));
	//如果不为空(0),则必须要等待
	USART4->TDR=str;
	//3.判断发送数据是否完成 ISR[6]
	while(!(USART4->ISR&(0x1<<6)));
}
//发送一个字符串
void hal_put_str(const char *buffer)
{
	while(*buffer)
	{
		if(USART4->ISR&(0x1<<6))
		{
			hal_put_char(*buffer);
			buffer++;
		}
	}
	hal_put_char('\n');
	hal_put_char('\r');
}
//接收一个字符
char hal_get_char()
{
	char ch;
	//判断接收寄存器是否为空,是否有数据可以读ISR[5]
	while(!(USART4->ISR&(0x1<<5)));
	//定义一个字符接收把数据读出来
	ch=USART4->RDR;
	return ch;
}
//接收一个字符串
char *hal_get_str()
{
	static char data[64] = "";
	int i=0;
	for (i = 0; i < 63;i++)
	{
		data[i] = hal_get_char();
		hal_put_char(data[i]);
		if(data[i]=='\r')
			break;
	}
	data[i] = '\0';
	hal_put_char('\n');
	return data;
}
//比较函数
int strcmp(const char *s1,const char *s2)
{ 
	while( *s1==*s2 && *s1 && *s2)
	{
		s1++;
		s2++;
	}
	return *s1-*s2 ;
}
//对GPIO引脚写操作函数
void hal_gpio_write(gpio_t* gpiox,unsigned int pin,gpio_status_t state)
{
	if(state == gpio_set_t)
	{
		gpiox->ODR |=(0x1<<pin);
	}
	else if(state == gpio_reset_t)
	{
		gpiox->ODR &= (~(0x1<<pin)); 
	}
}

头文件

#include "led_str.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++);
}
//2.结构体数组初始化
cmd_t cmd_arr[6] ={
	[0]={"led1on" ,GPIOE,GPIO_PIN_10,gpio_set_t  ,hal_gpio_write},
	[1]={"led1off",GPIOE,GPIO_PIN_10,gpio_reset_t,hal_gpio_write},
	[2]={"led2on" ,GPIOF,GPIO_PIN_10,gpio_set_t  ,hal_gpio_write},
	[3]={"led2off",GPIOF,GPIO_PIN_10,gpio_reset_t,hal_gpio_write},
	[4]={"led3on" ,GPIOE,GPIO_PIN_8 ,gpio_set_t  ,hal_gpio_write},
	[5]={"led3off",GPIOE,GPIO_PIN_8 ,gpio_reset_t,hal_gpio_write}
};
cmd_t* find_command(const char* str)
{
	//在串口中输入的字符串,与结构体中每个元素的cmd_arr变量进行比较
	//遍历比较,自己编写的strcmp函数
	for(int i=0; i<6; i++)
	{
		if(strcmp(str,cmd_arr[i].cmd_arr)==0)
		{
			return &cmd_arr[i];
		}
	}
	return 0; 		//失败返回0
}

int main()
{
	hal_rcc_init();
	hal_gpio_init();
	hal_uart_init();
	while(1)
	{
		cmd_t* cmd_arr;
		char *string = hal_get_str();
		cmd_arr = find_command(string);
		if(cmd_arr == 0)
		{
			hal_put_str("error");
		}
		else{
			cmd_arr->gpio_write_pin(cmd_arr->gpiox,cmd_arr->pin,cmd_arr->status);
		}
	}
	return 0;
}

实现结果