2023/2/24 作业

作业：

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

        头文件：

#ifndef __UART4_H__
#define __UART4_H__

#include "stm32mp1xx_gpio.h"
#include "stm32mp1xx_rcc.h"
#include "stm32mp1xx_uart.h"
#define gpio_Set 1
#define gpio_Reset 0

typedef char 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(const char* str,cmd_t *parr);

//改变引脚状态
void  hal_gpio_write1(gpio_t* gpiox,unsigned int pin,status_t status);



//串口初始化
void uart_init();

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

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

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

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

//LED1---->PE10
void led11_init();
void led11_on();
void led11_off();


//LED2---->PF10
void led22_init();
void led22_on();
void led22_off();


//LED3---->PE8
void led33_init();
void led33_on();
void led33_off();


#endif

源文件：

#include "uart4.h"

extern void delay_ms(int ms);

//串口初始化
void uart_init()
{
 	/*********RCC章节初始化************/
	//通过MP_AHB4ENSETR设置GPIOB/GPIOG控制器使能 GPIOB[1] = 1 GPIOG[6] = 1
	RCC->MP_AHB4ENSETR |= (0x1 << 1);
	RCC->MP_AHB4ENSETR |= (0x1 << 6);
	//通过MP_APB1ENSETR设置UART4控制器使能 UART4[16] = 1
	RCC->MP_APB1ENSETR |= (0x1 << 16);

 	/*********GPIO章节初始化************/
	//PB2---->UART4_RX
	//1.通过MODER寄存器设置PB2引脚为复用功能 MODER[5:4] = 10
	GPIOB->MODER &= (~(0x3 << 4));
	GPIOB->MODER |= (0x1 << 5);
	//2.通过AFRL寄存器设置PB2引脚复用功能为UART4_RX AFRL[11:8] = 1000
	GPIOB->AFRL &= (~(0xf << 8));
	GPIOB->AFRL |= (0x1 << 11);
	//PG11---->UART4_TX
	//1.通过MODER寄存器设置PG11引脚为复用功能 MODER[23:22] = 10
	GPIOG->MODER &= (~(0x3 << 22));
	GPIOG->MODER |= (0x1 << 23);
	//2.通过AFRH寄存器设置PG11引脚复用功能为UART4_TX AFRH[15:12] = 0110
	GPIOG->AFRH &= (~(0xf << 12));
	GPIOG->AFRH |= (0x3 << 13);

 	/*********UART4章节初始化************/
	//0.判断UE为是否为0
	if(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.1位停止位 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
	USART4->CR1 |= (0x1 << 0);
}

//发送一个字符
//putchar
void uart_put_char(const char str)
{
	//1.判断发送数据寄存器是否为空,为空，才可以发送下一个字节
	//ISR[7]  
	//读0:发送数据寄存器满，需要等待
	//读1:发送数据寄存器空，才可以发送下一位数据
	while(!(USART4->ISR & (0x1 << 7)));
	//2.将要发送的字符，写到发送数据寄存器中
	USART4->TDR = str;
	//3.判断发送数据是否完成 ISR[6]
	//读0:发送数据没有完成，需要等待
	//读1:发送一帧数据完成，可以发送下一帧数据
	while(!(USART4->ISR & (0x1 << 6)));
}

//发送一个字符串
void uart_put_string(const char* str)
{
	//判断是否为'\0',一个字符一个字符发送
	while(*str)
	{
		uart_put_char(*str++);
	}
	uart_put_char('\n');
	uart_put_char('\r');
}

//接收一个字符
//getchar
char uart_get_char()
{
	char ch;
	//1.判断接收数据寄存器是否有数据可读 ISR[5]
	//读0：表示接收数据寄存器有数据可读
	//读1：表示接收数据寄存器中没有数据
	while(!(USART4->ISR & (0x1 << 5)));	
	//2.将接收到的数据读出来
	ch = USART4->RDR;
	return ch;
}

char buffer[50] = {0};
//接收一个字符串
char* uart_get_string()
{
	int i;
	//for循环
	//当键盘的回车键'\r'按下之后，字符串输入完成
	for(i=0;i<49;i++)
	{
		buffer[i] = uart_get_char();//接收一个字符
		uart_put_char(buffer[i]);//发送一个字符
		if(buffer[i] == '\r') //判断字符串是否输入完成
		{
			break;
		}
	}
	//字符串补'\0'
	buffer[i] = '\0';
	uart_put_char('\n');
	return buffer;
}


void led11_init()
{
    RCC->MP_AHB4ENSETR |= (0x1 << 4); 
    //1.设置PE10引脚为输出模式 MODER[21:20] = 01
    GPIOE->MODER = GPIOE->MODER & (~(0x3<<20));
    GPIOE->MODER = GPIOE->MODER | (0x1<<20);
    //2.设置PE10引脚为推挽输出模式 OTYPER[10] = 0
    GPIOE->OTYPER = GPIOE->OTYPER & (~(0x1<<10));
    //GPIOE->OTYPER &= (~(0x1 << 10));
    //3.设置PE10引脚为低速输出 OSPEEDR[21:20] = 00
    GPIOE->OSPEEDR = GPIOE->OSPEEDR & (~(0x3<<20));
    //4.设置PE10引脚禁止上下拉电阻 PUPDR[21:20] = 00
    GPIOE->PUPDR = GPIOE->PUPDR &(~(0x3<<20));
}


void led11_on()
{
                                                                                
  //设置PE10引脚输出高电平 ODR[10] = 1
  GPIOE->ODR = GPIOE->ODR | (0x1<<10);
}


void led11_off()
{

  //设置PE10引脚输出低电平 ODR[10] = 0
    GPIOE->ODR = GPIOE->ODR & (~(0x1<<10));
}


void led22_init() //PF10
{
    RCC->MP_AHB4ENSETR |= (0x1 << 5); 
   	//1.设置PF10引脚为输出模式 MODER[21:20] = 01
    GPIOF->MODER = GPIOF->MODER & (~(0x3<<20));
    GPIOF->MODER = GPIOF->MODER | (0x1<<20);
    //2.设置PF10引脚为推挽输出模式 OTYPER[10] = 0
    GPIOF->OTYPER = GPIOF->OTYPER & (~(0x1<<10));
    //GPIOF->OTYPER &= (~(0x1 << 10));
    //3.设置PF10引脚为低速输出 OSPEEDR[21:20] = 00
    GPIOF->OSPEEDR = GPIOF->OSPEEDR & (~(0x3<<20));
    //4.设置PF10引脚禁止上下拉电阻 PUPDR[21:20] = 00
    GPIOF->PUPDR = GPIOF->PUPDR &(~(0x3<<20));
}


void led22_on()
{
                                                                                
  //设置PF10引脚输出高电平 ODR[10] = 1
  GPIOF->ODR = GPIOF->ODR | (0x1<<10);
}


void led22_off()
{

  //设置PF10引脚输出低电平 ODR[10] = 0
    GPIOF->ODR = GPIOF->ODR & (~(0x1<<10));
}


void led33_init() 	//PE8
{
    RCC->MP_AHB4ENSETR |= (0x1 << 4); 
    //1.设置PE8引脚为输出模式 MODER[17:16] = 01
    GPIOE->MODER = GPIOE->MODER & (~(0x3<<16));
    GPIOE->MODER = GPIOE->MODER | (0x1<<16);
    //2.设置PE8引脚为推挽输出模式 OTYPER[8] = 0
    GPIOE->OTYPER = GPIOE->OTYPER & (~(0x1<<8));
    //GPIOE->OTYPER &= (~(0x1 << 8));
    //3.设置PE8引脚为低速输出 OSPEEDR[17:16] = 00
    GPIOE->OSPEEDR = GPIOE->OSPEEDR & (~(0x3<<16));
    //4.设置PE8引脚禁止上下拉电阻 PUPDR[17:16] = 00
    GPIOE->PUPDR = GPIOE->PUPDR &(~(0x3<<16));
}


void led33_on()
{
                                                                                
  //设置PE10引脚输出高电平 ODR[10] = 1
  GPIOE->ODR = GPIOE->ODR | (0x1<<8);
}


void led33_off()
{

  //设置PE10引脚输出低电平 ODR[10] = 0
    GPIOE->ODR = GPIOE->ODR & (~(0x1<<8));
}


//字符串比较函数
cmd_t* find_command(const char* str,cmd_t *parr)
{
	int i = 0;
	int j = 0;
	for(i = 0; i < 6;i++)
	{
		j = 0;
		while(str[j] != '\0' && parr[i].cmd_arr[j] != '\0')
		{
			if(str[j] != parr[i].cmd_arr[j])
			{
				break;
			}
			j++;
		}
		if(str[j] == parr[i].cmd_arr[j])
		{
			return &parr[i];
		}
	}
	return 0;
}

//改变引脚状态
void  hal_gpio_write1(gpio_t* gpiox,unsigned int pin,status_t status)
{
	if(1 == status)
	{
  		gpiox->ODR = gpiox->ODR | (0x1<<pin);
	}
	else
	{	
    	gpiox->ODR = gpiox->ODR & (~(0x1<<pin));
	}
}

主函数调用：

#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++);
}

cmd_t cmd_arrn[6] = {
                    [0] ={
                            .cmd_arr = "led1on",
                            .gpiox = GPIOE,
                            .pin = 10,
                            .status = gpio_Set,
                            .gpio_write_pin = hal_gpio_write1,
                    },
                    [1] = {
                            .cmd_arr = "led1off",
                            .gpiox = GPIOE,
                            .pin = 10,
                            .status = gpio_Reset,
                            .gpio_write_pin = hal_gpio_write1,

					},
                    [2] = {
                            .cmd_arr = "led2on",
                            .gpiox = GPIOF,
                            .pin = 10,
                            .status = gpio_Set,
                            .gpio_write_pin = hal_gpio_write1,
					
					},
                    [3] = {
                            .cmd_arr = "led2off",
                            .gpiox = GPIOF,
                            .pin = 10,
                            .status = gpio_Reset,
                            .gpio_write_pin = hal_gpio_write1,
					},
                    [4] = {
                            .cmd_arr = "led3on",
                            .gpiox = GPIOE,
                            .pin = 8,
                            .status = gpio_Set,
                            .gpio_write_pin = hal_gpio_write1,
					},
                    [5] = {
                            .cmd_arr = "led3off",
                            .gpiox = GPIOE,
                            .pin = 8,
                            .status = gpio_Reset,
                            .gpio_write_pin = hal_gpio_write1,
					
					},
        };


int main()
{
	
	//GPIO初始化
	led11_init();
	led22_init();
	led33_init();
	//串口初始化
	uart_init();
	uart_put_string("uart4 test!!!!\n");
	cmd_t *cmd_arr;
	char *str;
	//实现串口数据收发
	while(1)
	{
	    str = uart_get_string();
		cmd_arr = find_command(str,cmd_arrn);
		if(cmd_arr == 0)
		{
			//查找失败
			printf("查找失败\n");
		}
		else
		{
			cmd_arr->gpio_write_pin(cmd_arr->gpiox,cmd_arr->pin,cmd_arr->status);
		}
	}
	return 0;
}

实验现象：