STM32MP157 cortex-M4 cortext-A7综合实验

1) cortex-M4 

 

1.通过配置开发板LED1/LED2/LED3三盏灯

2.当KEY1/KEY2/KEY3/光电开关/火焰传感器/人体红外中断触发，需要完成以下内容 1)中断触发，在串口工具打印一句话 2)中断触发，对应LED灯状态取反

3.需求：实验中的内容，需要在一个工程下配置，代码编写

实验现象:

 代码

uart.c

/**
  ******************************************************************************
  * @file    usart.c
  * @brief   This file provides code for the configuration
  *          of the USART instances.
  ******************************************************************************
  * @attention
  *
  * <h2><center>&copy; Copyright (c) 2023 STMicroelectronics.
  * All rights reserved.</center></h2>
  *
  * This software component is licensed by ST under BSD 3-Clause license,
  * the "License"; You may not use this file except in compliance with the
  * License. You may obtain a copy of the License at:
  *                        opensource.org/licenses/BSD-3-Clause
  *
  ******************************************************************************
  */

/* Includes ------------------------------------------------------------------*/
#include "usart.h"

/* USER CODE BEGIN 0 */
int fputc(int ch,FILE* stream)
{
	//判断发送寄存器是否为空
	while(!(huart4.Instance->ISR&(0x1<<7))){}  //TXE=1时往下执行
	huart4.Instance->TDR = ch;
	if('\n' == ch)
	{
		while(!(huart4.Instance->ISR&(0x1<<7))){}
			huart4.Instance->TDR = '\r';
	}
	return ch;	
}

/* USER CODE END 0 */

UART_HandleTypeDef huart4;

/* UART4 init function */
void MX_UART4_Init(void)
{

  /* USER CODE BEGIN UART4_Init 0 */

  /* USER CODE END UART4_Init 0 */

  /* USER CODE BEGIN UART4_Init 1 */

  /* USER CODE END UART4_Init 1 */
  huart4.Instance = UART4;
  huart4.Init.BaudRate = 115200;
  huart4.Init.WordLength = UART_WORDLENGTH_8B;
  huart4.Init.StopBits = UART_STOPBITS_1;
  huart4.Init.Parity = UART_PARITY_NONE;
  huart4.Init.Mode = UART_MODE_TX_RX;
  huart4.Init.HwFlowCtl = UART_HWCONTROL_NONE;
  huart4.Init.OverSampling = UART_OVERSAMPLING_16;
  huart4.Init.OneBitSampling = UART_ONE_BIT_SAMPLE_DISABLE;
  huart4.Init.ClockPrescaler = UART_PRESCALER_DIV1;
  huart4.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT;
  if (HAL_UART_Init(&huart4) != HAL_OK)
  {
    Error_Handler();
  }
  if (HAL_UARTEx_SetTxFifoThreshold(&huart4, UART_TXFIFO_THRESHOLD_1_8) != HAL_OK)
  {
    Error_Handler();
  }
  if (HAL_UARTEx_SetRxFifoThreshold(&huart4, UART_RXFIFO_THRESHOLD_1_8) != HAL_OK)
  {
    Error_Handler();
  }
  if (HAL_UARTEx_DisableFifoMode(&huart4) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN UART4_Init 2 */

  /* USER CODE END UART4_Init 2 */

}

void HAL_UART_MspInit(UART_HandleTypeDef* uartHandle)
{

  GPIO_InitTypeDef GPIO_InitStruct = {0};
  RCC_PeriphCLKInitTypeDef PeriphClkInit = {0};
  if(uartHandle->Instance==UART4)
  {
  /* USER CODE BEGIN UART4_MspInit 0 */

  /* USER CODE END UART4_MspInit 0 */
  if(IS_ENGINEERING_BOOT_MODE())
  {
  /** Initializes the peripherals clock
  */
    PeriphClkInit.PeriphClockSelection = RCC_PERIPHCLK_UART24;
    PeriphClkInit.Uart24ClockSelection = RCC_UART24CLKSOURCE_PCLK1;
    if (HAL_RCCEx_PeriphCLKConfig(&PeriphClkInit) != HAL_OK)
    {
      Error_Handler();
    }

  }

    /* UART4 clock enable */
    __HAL_RCC_UART4_CLK_ENABLE();

    __HAL_RCC_GPIOG_CLK_ENABLE();
    __HAL_RCC_GPIOB_CLK_ENABLE();
    /**UART4 GPIO Configuration
    PG11     ------> UART4_TX
    PB2     ------> UART4_RX
    */
    GPIO_InitStruct.Pin = GPIO_PIN_11;
    GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
    GPIO_InitStruct.Pull = GPIO_NOPULL;
    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
    GPIO_InitStruct.Alternate = GPIO_AF6_UART4;
    HAL_GPIO_Init(GPIOG, &GPIO_InitStruct);

    GPIO_InitStruct.Pin = GPIO_PIN_2;
    GPIO_InitStruct.Mode = GPIO_MODE_AF;
    GPIO_InitStruct.Pull = GPIO_NOPULL;
    GPIO_InitStruct.Alternate = GPIO_AF8_UART4;
    HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);

  /* USER CODE BEGIN UART4_MspInit 1 */

  /* USER CODE END UART4_MspInit 1 */
  }
}

void HAL_UART_MspDeInit(UART_HandleTypeDef* uartHandle)
{

  if(uartHandle->Instance==UART4)
  {
  /* USER CODE BEGIN UART4_MspDeInit 0 */

  /* USER CODE END UART4_MspDeInit 0 */
    /* Peripheral clock disable */
    __HAL_RCC_UART4_CLK_DISABLE();

    /**UART4 GPIO Configuration
    PG11     ------> UART4_TX
    PB2     ------> UART4_RX
    */
    HAL_GPIO_DeInit(GPIOG, GPIO_PIN_11);

    HAL_GPIO_DeInit(GPIOB, GPIO_PIN_2);

  /* USER CODE BEGIN UART4_MspDeInit 1 */

  /* USER CODE END UART4_MspDeInit 1 */
  }
}

/* USER CODE BEGIN 1 */

/* USER CODE END 1 */

/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/

gpio.c

/**
  ******************************************************************************
  * @file    gpio.c
  * @brief   This file provides code for the configuration
  *          of all used GPIO pins.
  ******************************************************************************
  * @attention
  *
  * <h2><center>&copy; Copyright (c) 2023 STMicroelectronics.
  * All rights reserved.</center></h2>
  *
  * This software component is licensed by ST under BSD 3-Clause license,
  * the "License"; You may not use this file except in compliance with the
  * License. You may obtain a copy of the License at:
  *                        opensource.org/licenses/BSD-3-Clause
  *
  ******************************************************************************
  */

/* Includes ------------------------------------------------------------------*/
#include "gpio.h"

/* USER CODE BEGIN 0 */

/* USER CODE END 0 */

/*----------------------------------------------------------------------------*/
/* Configure GPIO                                                             */
/*----------------------------------------------------------------------------*/
/* USER CODE BEGIN 1 */

/* USER CODE END 1 */

/** Configure pins
*/
void MX_GPIO_Init(void)
{

  GPIO_InitTypeDef GPIO_InitStruct = {0};

  /* GPIO Ports Clock Enable */
  __HAL_RCC_GPIOE_CLK_ENABLE();
  __HAL_RCC_GPIOF_CLK_ENABLE();
  __HAL_RCC_GPIOG_CLK_ENABLE();
  __HAL_RCC_GPIOB_CLK_ENABLE();

  /*Configure GPIO pin Output Level */
  HAL_GPIO_WritePin(GPIOF, GPIO_PIN_10, GPIO_PIN_RESET);

  /*Configure GPIO pin Output Level */
  HAL_GPIO_WritePin(GPIOE, GPIO_PIN_10|GPIO_PIN_8, GPIO_PIN_RESET);

  /*Configure GPIO pin : PE15 */
  GPIO_InitStruct.Pin = GPIO_PIN_15;
  GPIO_InitStruct.Mode = GPIO_MODE_IT_RISING;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  HAL_GPIO_Init(GPIOE, &GPIO_InitStruct);

  /*Configure GPIO pins : PF5 PF12 */
  GPIO_InitStruct.Pin = GPIO_PIN_5|GPIO_PIN_12;
  GPIO_InitStruct.Mode = GPIO_MODE_IT_RISING;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  HAL_GPIO_Init(GPIOF, &GPIO_InitStruct);

  /*Configure GPIO pin : PF10 */
  GPIO_InitStruct.Pin = GPIO_PIN_10;
  GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
  HAL_GPIO_Init(GPIOF, &GPIO_InitStruct);

  /*Configure GPIO pins : PE10 PE8 */
  GPIO_InitStruct.Pin = GPIO_PIN_10|GPIO_PIN_8;
  GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
  HAL_GPIO_Init(GPIOE, &GPIO_InitStruct);

  /*Configure GPIO pins : PF7 PF8 PF9 */
  GPIO_InitStruct.Pin = GPIO_PIN_7|GPIO_PIN_8|GPIO_PIN_9;
  GPIO_InitStruct.Mode = GPIO_MODE_IT_FALLING;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  HAL_GPIO_Init(GPIOF, &GPIO_InitStruct);

  /* EXTI interrupt init*/
  HAL_NVIC_SetPriority(EXTI5_IRQn, 5, 0);
  HAL_NVIC_EnableIRQ(EXTI5_IRQn);

  HAL_NVIC_SetPriority(EXTI7_IRQn, 7, 0);
  HAL_NVIC_EnableIRQ(EXTI7_IRQn);

  HAL_NVIC_SetPriority(EXTI8_IRQn, 8, 0);
  HAL_NVIC_EnableIRQ(EXTI8_IRQn);

  HAL_NVIC_SetPriority(EXTI9_IRQn, 9, 0);
  HAL_NVIC_EnableIRQ(EXTI9_IRQn);

  HAL_NVIC_SetPriority(EXTI12_IRQn, 12, 0);
  HAL_NVIC_EnableIRQ(EXTI12_IRQn);

  HAL_NVIC_SetPriority(EXTI15_IRQn, 15, 0);
  HAL_NVIC_EnableIRQ(EXTI15_IRQn);

}

/* USER CODE BEGIN 2 */
void HAL_GPIO_EXTI_Falling_Callback(uint16_t GPIO_Pin)
{
	switch(GPIO_Pin)
	{
		//PF7-->Key2-->LED2-->PF10
		case GPIO_PIN_7:
			//LED状态取反
		  HAL_GPIO_TogglePin(GPIOF,GPIO_PIN_10);
			//串口打印一句话
			printf("key2 pressed*****\n");
		break;
		
		//PF9-->Key1-->LED3-->PE8
		case GPIO_PIN_9:
			//LED状态取反
			HAL_GPIO_TogglePin(GPIOE,GPIO_PIN_8);
			//串口打印一句话
			printf("key1 pressed*****\n");
		break;
		
		
		//PF8-->Key3-->LED1-->PE10
		case GPIO_PIN_8:
			//LED状态取反   LED1-->PE10  
			HAL_GPIO_TogglePin(GPIOE,GPIO_PIN_10);
			//串口打印一句话
			printf("key3 pressed*****\n");
		break;
	}
}

void HAL_GPIO_EXTI_Rising_Callback(uint16_t GPIO_Pin)
{
		switch(GPIO_Pin)
		{
			//PE15 光电开关  
			case GPIO_PIN_15:
				//LED状态取反
		  HAL_GPIO_TogglePin(GPIOF,GPIO_PIN_10);
			//串口打印一句话
			printf("light-electic switch trigger*****\n");
			break;
			
			//PF12 人体红外  LED1-->PE10
			case GPIO_PIN_12:
				//LED状态取反   LED1-->PE10  
			HAL_GPIO_TogglePin(GPIOE,GPIO_PIN_10);
			//串口打印一句话
			printf("human body ultra red trigger *****\n");	
				
			break;
			
			//PF5 火焰传感器
			case GPIO_PIN_5:
				  //LED状态取反   LED1-->PE10  
			HAL_GPIO_TogglePin(GPIOE,GPIO_PIN_10);
			   //串口打印一句话
			printf("fire sensor trigger *****\n");	
				
			break;
				
			
			
		}
	
}

/* USER CODE END 2 */

/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/

2) cortex-A7   

实验需求：在串口输入相应的命令，控制对应的硬件进行操作

在串口输入led1on------>板子LED1灯点亮

在串口输入led1off------>板子LED1灯熄灭

在串口输入led2on------>板子LED2灯点亮

在串口输入led2off------>板子LED2灯熄灭

在串口输入led3on------>板子LED3灯点亮

在串口输入led3off------>板子LED3灯熄灭

gpio.h

#ifndef __GPIO_H__
#define __GPIO_H__
#include "stm32mp1xx_gpio.h"

//struct encapsulation
/*
typedef struct
{
	volatile unsigned int MODER;
	volatile unsigned int OTYPER;
	volatile unsigned int OSPEEDR;
	volatile unsigned int PUPDR;
	volatile unsigned int IDR;
	volatile unsigned int ODR;
} gpio_t;
#define GPIOE ((gpio_t *)0x50006000)
#define GPIOF ((gpio_t *)0x50007000)
#define RCC_AHB4_ENSETR ((volatile unsigned int *)0x50000A28)
*/

//pin encapsulation
#define GPIO_PIN_0 0
#define GPIO_PIN_1 1
#define GPIO_PIN_2 2
#define GPIO_PIN_3 3
#define GPIO_PIN_4 4
#define GPIO_PIN_5 5
#define GPIO_PIN_6 6
#define GPIO_PIN_7 7
#define GPIO_PIN_8 8
#define GPIO_PIN_9 9
#define GPIO_PIN_10 10
#define GPIO_PIN_11 11
#define GPIO_PIN_12 12
#define GPIO_PIN_13 13
#define GPIO_PIN_14 14
#define GPIO_PIN_15 15
#define GPIO_PIN_16 16 
#define GPIO_PIN_17 17
#define GPIO_PIN_18 18
#define GPIO_PIN_19 19
#define GPIO_PIN_20 20 
#define GPIO_PIN_21 21
#define GPIO_PIN_22 22
#define GPIO_PIN_23 23
#define GPIO_PIN_24 24 
#define GPIO_PIN_25 25
#define GPIO_PIN_26 26
#define GPIO_PIN_27 27
#define GPIO_PIN_28 28
#define GPIO_PIN_29 29
#define GPIO_PIN_30 30
#define GPIO_PIN_31 31

//MODER encapsulation
typedef enum
{
	INPUT,
	OUTPUT,
	ALF,
	ANALOG
} gpio_moder_t;


//OTYPER encapsulation
typedef enum
{
	PP,
	OD
} gpio_otyper_t;

//OSPEEDR
typedef enum
{
	LOW,
	MEDIUM,
	HIGH,
	VERY_HIGH

} gpio_ospeedr_t;

//PUPDR
typedef enum
{
	NO_PUPD,
	PU,
	PD

} gpio_pupdr_t;

//ODR
typedef enum 
{
	GPIO_RESET_T,
	GPIO_SET_T

} gpio_odr_t;


typedef struct 
{
	gpio_moder_t moder; //mode 
	gpio_otyper_t otyper; //type 
	gpio_ospeedr_t ospeedr; //speed
	gpio_pupdr_t pupdr;  //pupd
} gpio_init_t;




//gpio init
void hal_gpio_init(gpio_t * gpiox,unsigned int pin,gpio_init_t* init);


//gpio write 
void hal_gpio_write(gpio_t * gpiox,unsigned int pin,gpio_odr_t status);



typedef struct
{
	char* cmd_arr; //命令字符串
	gpio_t* gpiox; //gpio组号
	unsigned int pin; //对应引脚编号
	gpio_odr_t status; //对应引脚状态
	void (*gpio_write)(gpio_t * gpiox,unsigned int pin,gpio_odr_t status);

} cmd_t;


int mystrcmp(const char *dest,const char* src);






#endif




	

gpio.c

#include "gpio.h"

void hal_gpio_init(gpio_t * gpiox,unsigned int pin,gpio_init_t* init)
{
	//1.mode 
    gpiox->MODER &=(~(0x3 << 2*pin));
	gpiox->MODER |= (init->moder << 2*pin);

	//2.type
	gpiox->OTYPER &= (0x1<<pin);
	gpiox->OTYPER |= (init->otyper << pin);

	//3.speed 
	gpiox->OSPEEDR &= (~(0x3 << 2*pin));
	gpiox->OSPEEDR |= (init->ospeedr <<2*pin);

	//4.push pull 
	gpiox->PUPDR &= (~(0x3<<2*pin));
	gpiox->PUPDR |= (init->pupdr << 2*pin);

}




void hal_gpio_write(gpio_t * gpiox,unsigned int pin,gpio_odr_t status)
{

	if(status == GPIO_SET_T)
	{
		gpiox->ODR |= (0x1<<pin);
	} else if(status == GPIO_RESET_T)
	{
		gpiox->ODR &= (~(0x1<<pin));
	}
}


int mystrcmp(const char *dest,const char* src)
{
	if (sizeof(dest)!=sizeof(sizeof(src)))
	{
		return 0;
	}
	int i=0;
	while (src[i]!='\0' && dest[i]!='\0')
	{
		if(src[i]!=dest[i])
		{
			return 0;
		}
		i++;
	}
	
		
	
	return 1;
}

uart4.h

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

//init uart 
void hal_uart4_init();

//send a char
void put_char(const char str);

//send a string 
void put_string(const char* string);


//recv a char 
char get_char();


//recv a string 
char* get_string();


#endif 

uart4.c

#include "uart4.h"
#include "gpio.h"
//init uart 
extern char buff[50];


void delay_ms(int ms);
void hal_uart4_init()
{
	/******RCC init**************/
	//GPIOB GPIOG
	RCC->MP_AHB4ENSETR |= (0x1<<1 | 0x1<<6);
	//UART
	RCC->MP_APB1ENSETR |= (0x1<<16);
	/********GPIO init***********/
	//PB2----> UART4_RX
	GPIOB->MODER &= (~(0b11<<4));
	GPIOB->MODER |= (0b10<<4);
	GPIOB->AFRL &= (~(0b1111<<8));
	GPIOB->AFRL |= (0b1000<<8);
	//PG11---->UART4_TX
	GPIOG->MODER &= (~(0b11<<22));
	GPIOG->MODER |= (0b10<<22);
	GPIOG->AFRH &= (~(0b1111<<12));
	GPIOG->AFRH |= (0b0110<<12);
	/********UART init***********/
	//加上条件判断
	if(USART4->CR1 & (0x1 << 0))
	{
	 	delay_ms(500);
		USART4->CR1 &= (~(0x1 << 0));
	}

	//M bit init(M1 M0) , sampling 16(OVER8), no even odd parity(PCE)
	USART4->CR1 &= (~(0x1<<28 | 0x1<<12 | 0x1<<15 | 0x1<<10));
	//TE RE UE
	USART4->CR1 |= (0x1<<3 | 0x1<<2 | 0x1<<0);
	//1 stop bit
	USART4->CR2 &= (~(0b11<<12));
	//BRR= 64MHz/115200 = 0x22B
	USART4->BRR |=  0x22B;
	//no prescaling
	USART4->PRESC &= 0b0000;
}

//send a char
void put_char(const char str)
{
	//judge if the TXE==>UART_ISR[7]   is 1,if it's 1,then the next byte could be sent
	//1:empty  0:not empty
	while(!(USART4->ISR & (0x1<<7)));
	USART4->TDR = str;
	//judge if sending is finished     0 not finshed 1 finshed
	while (!(USART4->ISR & (0x1<<6)));
}


//send a string 
void put_string(const char* string)
{
	//the sign of the end of a string '\0'
	/* 
	const char *p = string;
	while (*p!='\0')
	{
		put_char(*p);
		p++;
	}
	*/
	while (*string)
	{
		put_char(*string++);
	}
	
	
}


//recv a char 
char get_char()
{
	char ret;
	//1. judge if RXNE is 1,data received,0 data not received
	while (!(USART4->ISR & (0x1<<5)));
	//call put_char
	ret = USART4->RDR;
	return ret;
}


//recv a string 
char* get_string()
{
	int i;
	for(i = 0; i < 49;i++)
	{
		// receive a char
		buff[i] = get_char();
		// display the char 
		put_char(buff[i]);
		if ('\r'==buff[i])
		{
			break;
		}
	}
	put_char('\0');
	put_char('\n');
	return buff;
}

main.c

#include "./include/gpio.h"
#include "./include/uart4.h"
extern void printf(const char *fmt, ...);
char buff[50]={0};

void delay_ms(int ms)
{
	int i,j;
	for(i = 0; i < ms;i++)
		for (j = 0; j < 1800; j++);
}



void led_init()
{
	RCC->MP_AHB4ENSETR |= (0x3<<4);
	gpio_init_t init = {OUTPUT,PP,LOW,NO_PUPD};
	hal_gpio_init(GPIOE,GPIO_PIN_10,&init);
	hal_gpio_init(GPIOE,GPIO_PIN_8,&init);
	hal_gpio_init(GPIOF,GPIO_PIN_10,&init);
	

}
cmd_t arr[6] = 
	{
		[0]={
			    .cmd_arr = "led1on", 
                .gpiox = GPIOE,
                .pin =   GPIO_PIN_10,
                .status = GPIO_SET_T,
                .gpio_write  =  hal_gpio_write, 
			},
		[1]={
				.cmd_arr = "led1off", 
				.gpiox = GPIOE,
				.pin =   GPIO_PIN_10,
				.status = GPIO_RESET_T,
				.gpio_write  =  hal_gpio_write, 
			},
		[2]={

				.cmd_arr = "led2on", 
				.gpiox = GPIOF,
				.pin =   GPIO_PIN_10,
				.status = GPIO_SET_T,
				.gpio_write  =  hal_gpio_write, 
		},
		[3]={
				.cmd_arr = "led2off", 
				.gpiox = GPIOF,
				.pin =   GPIO_PIN_10,
				.status = GPIO_RESET_T,
				.gpio_write  =  hal_gpio_write, 
		},
		[4]={
				.cmd_arr = "led3on", 
				.gpiox = GPIOE,
				.pin =   GPIO_PIN_8,
				.status = GPIO_SET_T,
				.gpio_write  =  hal_gpio_write, 
		},
		[5]={
				.cmd_arr = "led3off", 
				.gpiox = GPIOE,
				.pin =   GPIO_PIN_8,
				.status = GPIO_RESET_T,
				.gpio_write  =  hal_gpio_write, 
		}
};
char *cmpbuf;
int main()
{
	led_init();
	hal_uart4_init();

	while(1)
	{
		/*
		//test purpose
		for (int i = 0; i <= 5; i++)
		{
				delay_ms(200);
				arr[i].gpio_write(arr[i].gpiox,arr[i].pin,arr[i].status);
			
		}
		*/
		char *cmpbuf = get_string();
		printf(cmpbuf);
		for (int i = 0; i <= 5; i++)
		{
			if (mystrcmp(cmpbuf,arr[i].cmd_arr))
			{
				arr[i].gpio_write(arr[i].gpiox,arr[i].pin,arr[i].status);
			} else
			{
				printf("not matched*******\n\r");
			}
		}
	}

	return 0;
}