自学教程：C++ HAL_GPIO_ReadPin函数代码示例

int main(void){  /* USER CODE BEGIN 1 */  /* USER CODE END 1 */  /* MCU Configuration----------------------------------------------------------*/  /* Reset of all peripherals, Initializes the Flash interface and the Systick. */  HAL_Init();  /* Configure the system clock */  SystemClock_Config();  /* Initialize all configured peripherals */  MX_GPIO_Init();  //MX_TIM3_Init();  //MX_TIM4_Init();  //HAL_TIM_Base_Start(&htim3);  //HAL_TIM_Base_Start(&htim4);  //HAL_TIM_PWM_Start(&htim3, TIM_CHANNEL_3);  //HAL_TIM_PWM_Start(&htim3, TIM_CHANNEL_4);  //HAL_TIM_PWM_Start(&htim4, TIM_CHANNEL_2);  HAL_GPIO_WritePin(Led_gpio,Led_pin,GPIO_PIN_SET);  HAL_Delay(1000);  HAL_GPIO_WritePin(Led_gpio,Led_pin,GPIO_PIN_RESET);  HAL_GPIO_WritePin(DcCal_gpio,DcCal_pin,GPIO_PIN_RESET);    char state;  int cnt;  cnt = HAL_GetTick();  while (1)  {    state = HAL_GPIO_ReadPin(sens_gpio,sens_ph1_pin);    state = state << 1;    state |= HAL_GPIO_ReadPin(sens_gpio,sens_ph2_pin);    state = state << 1;    state |= HAL_GPIO_ReadPin(sens_gpio,sens_ph3_pin);    ApplyPhaseSolid(state);    if(HAL_GetTick()>1000+cnt) {      HAL_GPIO_TogglePin(EnGate_gpio,EnGate_pin);      cnt = HAL_GetTick();    }//      if(TIM3->CCR3<200)//        TIM3->CCR3++;//      else//        TIM3->CCR3=0;////      HAL_Delay(20);  }  /* USER CODE END 3 */}

/*** @brief This function handles TIM3 global interrupt.*/void TIM3_IRQHandler(void){  /* USER CODE BEGIN TIM3_IRQn 0 */	int i;	if(btnDebounceIRQTimer[0]>debounceDelay){		btnDebounceIRQTimer[0] = 0;		if(HAL_GPIO_ReadPin(GPIOE,GPIO_PIN_10)) irqflag_btns[0] = 1;	}	else if(btnDebounceIRQTimer[0] > 0) btnDebounceIRQTimer[0] ++;	if(btnDebounceIRQTimer[1]>debounceDelay){			btnDebounceIRQTimer[1] = 0;			if(HAL_GPIO_ReadPin(GPIOE,GPIO_PIN_11)) irqflag_btns[1] = 1;		}		else if(btnDebounceIRQTimer[1] > 0) btnDebounceIRQTimer[1] ++;	if(btnDebounceIRQTimer[2]>debounceDelay){			btnDebounceIRQTimer[2] = 0;			if(HAL_GPIO_ReadPin(GPIOE,GPIO_PIN_12)) irqflag_btns[2] = 1;		}		else if(btnDebounceIRQTimer[2] > 0) btnDebounceIRQTimer[2] ++;  /* USER CODE END TIM3_IRQn 0 */  HAL_TIM_IRQHandler(&htim3);  /* USER CODE BEGIN TIM3_IRQn 1 */  /* USER CODE END TIM3_IRQn 1 */}

void AD7190_PowerDown(){	uint8_t mode[4] = {0x68,0x04,0x00,0x01};	int i = 0;	while(!HAL_GPIO_ReadPin(GPIOC,GPIO_PIN_11) && i<50000);	while(HAL_GPIO_ReadPin(GPIOC,GPIO_PIN_11) && i<50000);	AD7190_SPI_Write(mode,4);}

void EXTI0_IRQHandler(){    if(HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_0)) {        ExpLedToggle(RED_LED);        while(HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_0));        HAL_NVIC_ClearPendingIRQ(EXTI0_IRQn);    }}

int main(void) {  char msg[20];  HAL_Init();  Nucleo_BSP_Init();  /* Before we can access to every register of the PWR peripheral we must enable it */  __HAL_RCC_PWR_CLK_ENABLE();  while (1) {    if(__HAL_PWR_GET_FLAG(PWR_FLAG_SB)) {      /* If standby flag set in PWR->CSR, then the reset is generated from       * the exit of the standby mode */      sprintf(msg, "RESET after STANDBY mode/r/n");      HAL_UART_Transmit(&huart2, (uint8_t*)msg, strlen(msg), HAL_MAX_DELAY);      /* We have to explicitly clear the flag */      __HAL_PWR_CLEAR_FLAG(PWR_FLAG_WU|PWR_FLAG_SB);    }    sprintf(msg, "MCU in run mode/r/n");    HAL_UART_Transmit(&huart2, (uint8_t*)msg, strlen(msg), HAL_MAX_DELAY);    while(HAL_GPIO_ReadPin(GPIOC, GPIO_PIN_13) == GPIO_PIN_SET) {      HAL_GPIO_TogglePin(LD2_GPIO_Port, LD2_Pin);      HAL_Delay(100);    }    HAL_Delay(200);    sprintf(msg, "Entering in SLEEP mode/r/n");    HAL_UART_Transmit(&huart2, (uint8_t*)msg, strlen(msg), HAL_MAX_DELAY);    SleepMode();    sprintf(msg, "Exiting from SLEEP mode/r/n");    HAL_UART_Transmit(&huart2, (uint8_t*)msg, strlen(msg), HAL_MAX_DELAY);    while(HAL_GPIO_ReadPin(GPIOC, GPIO_PIN_13) == GPIO_PIN_SET);    HAL_Delay(200);    sprintf(msg, "Entering in STOP mode/r/n");    HAL_UART_Transmit(&huart2, (uint8_t*)msg, strlen(msg), HAL_MAX_DELAY);    StopMode();    sprintf(msg, "Exiting from STOP mode/r/n");    HAL_UART_Transmit(&huart2, (uint8_t*)msg, strlen(msg), HAL_MAX_DELAY);    while(HAL_GPIO_ReadPin(GPIOC, GPIO_PIN_13) == GPIO_PIN_SET);    HAL_Delay(200);    sprintf(msg, "Entering in STANDBY mode/r/n");    HAL_UART_Transmit(&huart2, (uint8_t*)msg, strlen(msg), HAL_MAX_DELAY);    StandbyMode();    while(1); //Never arrives here, since MCU is reset when exiting from STANDBY  }}

/**   * @brief Reports column of key that was pressed   * @retval Int of column activated   */uint8_t get_column(void) {		// Initialize pins to allow for columns as input	init_columns();		// Row selection determined by active low 	if(!HAL_GPIO_ReadPin(GPIOD, col_pinmap[0])) return 0;	else if(!HAL_GPIO_ReadPin(GPIOD, col_pinmap[1])) return 1;	else if(!HAL_GPIO_ReadPin(GPIOD, col_pinmap[2])) return 2;	else return 9;	}

/**	* @brief Find in which row a button was pressed	* @param None	* @retval None	*/int findRow(void){	int row = 0;	/* change the column at output */	Column_GPIO_InitDef.Mode = GPIO_MODE_OUTPUT_PP;	Column_GPIO_InitDef.Pull = GPIO_NOPULL;	HAL_GPIO_Init(GPIOC, &Column_GPIO_InitDef);	/* change row as input */	Row_GPIO_InitDef.Mode = GPIO_MODE_INPUT;	Row_GPIO_InitDef.Pull = GPIO_PULLUP;	HAL_GPIO_Init(GPIOC, &Row_GPIO_InitDef);	HAL_GPIO_WritePin(GPIOC, col1, GPIO_PIN_RESET);	HAL_GPIO_WritePin(GPIOC, col2, GPIO_PIN_RESET);	HAL_GPIO_WritePin(GPIOC, col3, GPIO_PIN_RESET);	/* check which row have a button pressed */	if (HAL_GPIO_ReadPin(GPIOC, row1) == GPIO_PIN_RESET){		row = 1;	}	else if (HAL_GPIO_ReadPin(GPIOC, row2) == GPIO_PIN_RESET){		row = 2;	}	else if (HAL_GPIO_ReadPin(GPIOC, row3) == GPIO_PIN_RESET){		row = 3;	}	else if (HAL_GPIO_ReadPin(GPIOC, row4) == GPIO_PIN_RESET){		row = 4;	}	/* set back the row and column as output and input */	Row_GPIO_InitDef.Mode = GPIO_MODE_OUTPUT_PP;	Row_GPIO_InitDef.Pull = GPIO_NOPULL;	HAL_GPIO_Init(GPIOC, &Row_GPIO_InitDef);	HAL_GPIO_WritePin(GPIOC, row1, GPIO_PIN_RESET);	HAL_GPIO_WritePin(GPIOC, row2, GPIO_PIN_RESET);	HAL_GPIO_WritePin(GPIOC, row3, GPIO_PIN_RESET);	HAL_GPIO_WritePin(GPIOC, row4, GPIO_PIN_RESET);	Column_GPIO_InitDef.Mode = GPIO_MODE_INPUT;	Column_GPIO_InitDef.Pull = GPIO_PULLUP;	HAL_GPIO_Init(GPIOC, &Column_GPIO_InitDef);	return row;}

/***************读按键程序**************/uint8_t read_key(){uint8_t rekey =0;uint8_t   i ;I2CStart();I2CWritebyte(0x42);							 //写读指令0x42DIO_H;CLK_H;for(i=0;i<8;i++){	CLK_L;  #ifdef tm1651_delay_EN	__nop() ;   tm1651_delay();  #endif	rekey>>=1;	   						//先读低位  #ifdef tm1651_delay_EN	__nop() ;   tm1651_delay();  #endif	CLK_H;   HAL_GPIO_WritePin(TM1651_DIO_GPIO_Port ,TM1651_DIO_Pin,GPIO_PIN_SET) ;	if( HAL_GPIO_ReadPin(TM1651_DIO_GPIO_Port ,TM1651_DIO_Pin))	  rekey=rekey|0x80;	else 	  rekey=rekey|0x00;  #ifdef tm1651_delay_EN	__nop() ;   tm1651_delay();  #endif}	CLK_L;							  //判断芯片发过来的ACK应答信号  #ifdef tm1651_delay_EN	__nop() ;   tm1651_delay();  #endif//使用开漏输出模式，在读取管脚电平的时候 先将管脚写高电平，然后读数 HAL_GPIO_WritePin(TM1651_DIO_GPIO_Port ,TM1651_DIO_Pin,GPIO_PIN_SET) ;	while( HAL_GPIO_ReadPin(TM1651_DIO_GPIO_Port ,TM1651_DIO_Pin));  #ifdef tm1651_delay_EN	__nop() ;   tm1651_delay();  #endif	CLK_H;  #ifdef tm1651_delay_EN	__nop() ;   tm1651_delay();  #endif	I2CStop();		return rekey;}

/**  * @brief  EXTI line detection callbacks.  * @param  GPIO_Pin: Specifies the pins connected EXTI line  * @retval None  */void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin){  if(HAL_GPIO_ReadPin(SEL_JOY_GPIO_PORT, SEL_JOY_PIN) != GPIO_PIN_SET)   {    /* SEL is used to pause and resume the audio playback */    if (PressCount == 1)    {      /* Resume playing Wave status */      PauseResumeStatus = RESUME_STATUS;      PressCount = 0;    }    else    {      /* Pause playing Wave status */      PauseResumeStatus = PAUSE_STATUS;      PressCount = 1;    }  }  else if(HAL_GPIO_ReadPin(UP_JOY_GPIO_PORT, UP_JOY_PIN) != GPIO_PIN_SET)  {    /* UP is used to increment the volume of the audio playback */    volume ++;    if (volume > 100)    {      volume = 100;    }    VolumeChange = 1;  }  else if(HAL_GPIO_ReadPin(DOWN_JOY_GPIO_PORT, DOWN_JOY_PIN) != GPIO_PIN_SET)  {    /* DOWN is used to decrement the volume of the audio playback */    volume --;    if ((int8_t)volume < 50)    {      volume = 50;    }    VolumeChange = 1;  }  else if(HAL_GPIO_ReadPin(RIGHT_JOY_GPIO_PORT, RIGHT_JOY_PIN) != GPIO_PIN_SET)  {    /* Audio change output: speaker only */    UserOutputMode = OUTPUT_DEVICE_SPEAKER;  }  else if(HAL_GPIO_ReadPin(LEFT_JOY_GPIO_PORT, LEFT_JOY_PIN) != GPIO_PIN_SET)  {    /* Audio change output: headset only */    UserOutputMode = OUTPUT_DEVICE_HEADPHONE;  }}

int main(void) {  HAL_Init();  Nucleo_BSP_Init();  hdma_memtomem_dma1_channel5.Instance = DMA1_Channel5;  hdma_memtomem_dma1_channel5.Init.Direction = DMA_MEMORY_TO_MEMORY;  hdma_memtomem_dma1_channel5.Init.PeriphInc = DMA_PINC_ENABLE;  hdma_memtomem_dma1_channel5.Init.MemInc = DMA_MINC_ENABLE;  hdma_memtomem_dma1_channel5.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;  hdma_memtomem_dma1_channel5.Init.MemDataAlignment = DMA_PDATAALIGN_BYTE;  hdma_memtomem_dma1_channel5.Init.Mode = DMA_NORMAL;  hdma_memtomem_dma1_channel5.Init.Priority = DMA_PRIORITY_VERY_HIGH;  HAL_DMA_Init(&hdma_memtomem_dma1_channel5);  GPIOC->ODR = 0x100;  HAL_DMA_Start(&hdma_memtomem_dma1_channel5,  (uint32_t)&flashData,  (uint32_t)&sramData, 1000);  HAL_DMA_PollForTransfer(&hdma_memtomem_dma1_channel5, HAL_DMA_FULL_TRANSFER, HAL_MAX_DELAY);  GPIOC->ODR = 0x0;  while(HAL_GPIO_ReadPin(B1_GPIO_Port, B1_Pin));  hdma_memtomem_dma1_channel5.Init.PeriphDataAlignment = DMA_PDATAALIGN_WORD;  hdma_memtomem_dma1_channel5.Init.MemDataAlignment = DMA_PDATAALIGN_WORD;  HAL_DMA_Init(&hdma_memtomem_dma1_channel5);  GPIOC->ODR = 0x100;  HAL_DMA_Start(&hdma_memtomem_dma1_channel5,  (uint32_t)&flashData,  (uint32_t)&sramData, 250);  HAL_DMA_PollForTransfer(&hdma_memtomem_dma1_channel5, HAL_DMA_FULL_TRANSFER, HAL_MAX_DELAY);  GPIOC->ODR = 0x0;  HAL_Delay(1000);  while(HAL_GPIO_ReadPin(B1_GPIO_Port, B1_Pin));  GPIOC->ODR = 0x100;  memcpy(sramData, flashData, 1000);  GPIOC->ODR = 0x0;  HAL_Delay(1000);  while(HAL_GPIO_ReadPin(B1_GPIO_Port, B1_Pin));  GPIOC->ODR = 0x100;  for(int i = 0; i < 1000; i++)	  sramData[i] = flashData[i];  GPIOC->ODR = 0x0;  /* Infinite loop */  while (1);}

void read_keypad_col() {	initGPIOT(GPIOB, COLUMN_PIN_SET, input);//Used for the keypad	initGPIOT(GPIOB, ROW_PIN_SET, output);		// set all rows to 0	HAL_GPIO_WritePin(GPIOB,ROW_PIN_SET,GPIO_PIN_RESET);		// loop through all columns, see which is right!!!	//while (!colDet) {		if(GPIO_PIN_RESET == HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_6)) colDet = 1;		if(GPIO_PIN_RESET == HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_7)) colDet = 2;		if(GPIO_PIN_RESET == HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_8)) colDet = 3;	//}}

int main(void){  /* USER CODE BEGIN 1 */  /* USER CODE END 1 */  /* MCU Configuration----------------------------------------------------------*/  /* Reset of all peripherals, Initializes the Flash interface and the Systick. */  HAL_Init();  /* Configure the system clock */  SystemClock_Config();  /* Initialize all configured peripherals */  MX_GPIO_Init();//  MX_TIM3_Init();//  MX_TIM4_Init();////  HAL_TIM_Base_Start(&htim3);//  HAL_TIM_Base_Start(&htim4);//  HAL_TIM_PWM_Start(&htim3, TIM_CHANNEL_3);//  HAL_TIM_PWM_Start(&htim3, TIM_CHANNEL_4);//  HAL_TIM_PWM_Start(&htim4, TIM_CHANNEL_2);  HAL_GPIO_WritePin(Led_gpio,Led_pin,SET);  HAL_Delay(1000);  HAL_GPIO_WritePin(Led_gpio,Led_pin,RESET);  HAL_GPIO_WritePin(DcCal_gpio,DcCal_pin,RESET);  HAL_GPIO_WritePin(EnGate_gpio,EnGate_pin,SET);  char state;  /* Infinite loop */  /* USER CODE BEGIN WHILE */  while (1)  {    state = HAL_GPIO_ReadPin(sens_gpio,sens_ph1_pin);    state = state << 1;    state |= HAL_GPIO_ReadPin(sens_gpio,sens_ph2_pin);    state = state << 1;    state |= HAL_GPIO_ReadPin(sens_gpio,sens_ph3_pin);    ApplyPhase(state);  }  /* USER CODE END 3 */}

static void main_loop(void){	static uint32_t loopCounter = 0;	static uint32_t divider100ms = 100;	uint32_t i = 0;	if(!(loopCounter%divider100ms)){		HAL_GPIO_TogglePin(GPIOD,GPIO_PIN_15);		kommuHandler();	}		if(!(loopCounter)){	}	power[3] = 100+pidY_X;	if(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_0) == GPIO_PIN_SET){		if(!bursting_start && !bursting_end){			//bursting_start = 1;		}	}else{		if(bursting_end){			i = 0;			while(i <= currentburst ){				stdout_putchar(burst[i++]);			}			currentburst = 0;			bursting_end = 0;		}	}	loopCounter++;}

/*****************************************************************Name			:	uint8_t BLE_CON(void)Fuction		:	the BLE connect stateInput			:	voidOutput		:	the value of connect state						(PA4	BLE_CON Low:connected ; High:disconnected)Author		:	@hiyangdongVersion		:	V0.1Time			:	30 Nov. 2015*****************************************************************/uint8_t BLE_CON(void){	if(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_4)==GPIO_PIN_RESET)		return 0;	else		return 1;}

void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin){		if (GPIO_Pin==GPIO_PIN_0){	while (BSP_PB_GetState(BUTTON_KEY) != RESET)	{};		 	click++;			startsyncpulse();	frameid = 0;					printf("/nButton Press Detected");	return;	}			if (GPIO_Pin==GPIO_PIN_2){	 	 if(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_2)){		//Rising Edge Detected	  modulation_on();		startcounter(); //Starts ticking the clock for exposure		 		 }	 else{			//Falling Edge Detected 	 	     	 }	}		}

int is_update_image_enable(gpio_t *gpio_uart_update_eable){	HAL_GPIO_PIN  GPIO_Pin;    u32 active_state;//	gpio_t gpio_uart_update_eable;	int ret = 0;#if 0    GPIO_Pin.pin_name = 0xC4;	//low active	GPIO_Pin.pin_mode = DIN_PULL_HIGH;	active_state = GPIO_PIN_LOW;	    HAL_GPIO_Init(&GPIO_Pin);	    if (HAL_GPIO_ReadPin(&GPIO_Pin) == active_state)    	ret = 0;	else		ret = 1;	   	HAL_GPIO_DeInit(&GPIO_Pin);#else	gpio_init(gpio_uart_update_eable, PIN_NAME);	gpio_dir(gpio_uart_update_eable, PIN_INPUT);     // Direction: Input	gpio_mode(gpio_uart_update_eable, PullUp);       // Pull-High//	ret = gpio_read(&gpio_uart_update_eable);#endif	return ret;}

static void LED_Thread1(void const *argument){	GPIO_InitTypeDef GPIO_InitStruct_LED, GPIO_InitStruct_BUTTON;	/* GPIO Ports Clock Enable */	__GPIOI_CLK_ENABLE();	/*Configure GPIO pin : PI1 */	GPIO_InitStruct_LED.Pin = GPIO_PIN_1;	GPIO_InitStruct_LED.Mode = GPIO_MODE_OUTPUT_PP;	GPIO_InitStruct_LED.Pull = GPIO_NOPULL;	GPIO_InitStruct_LED.Speed = GPIO_SPEED_LOW;	HAL_GPIO_Init(GPIOI, &GPIO_InitStruct_LED);	GPIO_InitStruct_BUTTON.Pin = GPIO_PIN_11;	GPIO_InitStruct_BUTTON.Mode = GPIO_MODE_INPUT;	GPIO_InitStruct_BUTTON.Pull = GPIO_PULLUP;	HAL_GPIO_Init(GPIOI, &GPIO_InitStruct_BUTTON);	while(1)	{		if(HAL_GPIO_ReadPin(GPIOI, GPIO_PIN_11)){			HAL_GPIO_TogglePin(GPIOI, GPIO_PIN_1);			HAL_Delay(500);			printf("Pintando /n");		}		HAL_GPIO_WritePin(GPIOI, GPIO_PIN_1, 0);	}}

void TM1637::writeByte(int8_t wr_data){  uint8_t i,count1;     for(i=0;i<8;i++)        //sent 8bit data  {		HAL_GPIO_WritePin(CLK_GPIO_Port, CLK_Pin, GPIO_PIN_RESET);	    if(wr_data & 0x01) HAL_GPIO_WritePin(DI_GPIO_Port, DI_Pin, GPIO_PIN_SET);	//LSB first    else HAL_GPIO_WritePin(DI_GPIO_Port, DI_Pin, GPIO_PIN_RESET);    wr_data >>= 1;          HAL_GPIO_WritePin(CLK_GPIO_Port, CLK_Pin, GPIO_PIN_SET);        }    HAL_GPIO_WritePin(CLK_GPIO_Port, CLK_Pin, GPIO_PIN_RESET);	 //wait for the ACK  HAL_GPIO_WritePin(DI_GPIO_Port, DI_Pin, GPIO_PIN_SET);  HAL_GPIO_WritePin(CLK_GPIO_Port, CLK_Pin, GPIO_PIN_SET);       pinDI_Input();  while(HAL_GPIO_ReadPin(DI_GPIO_Port, DI_Pin))      {     count1 +=1;    if(count1 == 200)//    {     pinDI_Output();     HAL_GPIO_WritePin(DI_GPIO_Port, DI_Pin, GPIO_PIN_RESET);     count1 =0;    }    pinDI_Input();  }  pinDI_Output();  }

/** * @brief  EXTI line detection callback. * @param  uint16_t GPIO_Pin Specifies the pins connected EXTI line * @retval None */void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin){  tHciDataPacket * hciReadPacket = NULL;  uint8_t data_len;  /*    * No need to call Clear_SPI_EXTI_Flag() here as   * HAL_GPIO_EXTI_IRQHandler() already does it   */    if(GPIO_Pin == BNRG_SPI_EXTI_PIN) {        while (HAL_GPIO_ReadPin(BNRG_SPI_EXTI_PORT, BNRG_SPI_EXTI_PIN) == GPIO_PIN_SET) {            uint8_t rx_buffer[255];      uint8_t rx_bytes;            /* Data are available from BlueNRG: read them through SPI */      rx_bytes = BlueNRG_SPI_Read_All(&SpiHandle, rx_buffer, sizeof(rx_buffer));       /* Check if there is data is so, send it to VCOM */      if (rx_bytes > 0) {        int i;        for (i = 0; i < rx_bytes; i++) {          PRINTF("0x%x, ", rx_buffer[i]);          if(HAL_UART_Transmit(&UartHandle, (uint8_t*)&rx_buffer[i], 1, 300)!= HAL_OK) {            Error_Handler();          }        }        PRINTF("/n");      }            Clear_SPI_EXTI_Flag();    }  }}

/* Model step function */void Test_Stateflow_step(void){  /* S-Function Block: <Root>/STM32_Config */  /* S-Function Block: <Root>/GPIO_Read */  Test_Stateflow_B.GPIO_Read = (boolean_T)HAL_GPIO_ReadPin(GPIOE, GPIO_PIN_8);  if (Test_Stateflow_DW.temporalCounter_i1 < 7U) {    Test_Stateflow_DW.temporalCounter_i1++;  }  if (Test_Stateflow_DW.is_active_c3_Test_Stateflow == 0U) {    Test_Stateflow_DW.is_active_c3_Test_Stateflow = 1U;    Test_Stateflow_DW.is_c3_Test_Stateflow = Test_Stateflow_IN_S1;    Test_Stateflow_B.LED1 = 1.0;    Test_Stateflow_B.LED2 = 0.0;    Test_Stateflow_B.LED3 = 0.0;  } else {    switch (Test_Stateflow_DW.is_c3_Test_Stateflow) {     case Test_Stateflow_IN_S1:      if (Test_Stateflow_B.GPIO_Read == 1.0) {        Test_Stateflow_DW.is_c3_Test_Stateflow = Test_Stateflow_IN_S2;        Test_Stateflow_B.LED1 = 0.0;        Test_Stateflow_B.LED2 = 1.0;        Test_Stateflow_B.LED3 = 0.0;      }      break;     case Test_Stateflow_IN_S2:      if (Test_Stateflow_B.GPIO_Read == 0.0) {        Test_Stateflow_DW.is_c3_Test_Stateflow = Test_Stateflow_IN_S3;        Test_Stateflow_DW.temporalCounter_i1 = 0U;        Test_Stateflow_B.LED1 = 0.0;        Test_Stateflow_B.LED2 = 0.0;        Test_Stateflow_B.LED3 = 1.0;      }      break;     default:      if (Test_Stateflow_DW.temporalCounter_i1 >= 4U) {        Test_Stateflow_DW.is_c3_Test_Stateflow = Test_Stateflow_IN_S1;        Test_Stateflow_B.LED1 = 1.0;        Test_Stateflow_B.LED2 = 0.0;        Test_Stateflow_B.LED3 = 0.0;      }      break;    }  }  /* S-Function Block: <Root>/GPIO_Write */  HAL_GPIO_WritePin(GPIOD, GPIO_PIN_11, Test_Stateflow_B.LED1);  HAL_GPIO_WritePin(GPIOD, GPIO_PIN_12, Test_Stateflow_B.LED2);  HAL_GPIO_WritePin(GPIOD, GPIO_PIN_13, Test_Stateflow_B.LED3);  /* S-Function Block: <Root>/GPIO_Write2 */  HAL_GPIO_WritePin(GPIOD, GPIO_PIN_7, Test_Stateflow_P.Constant1_Value);  /* S-Function Block: <Root>/GPIO_Write1 */  HAL_GPIO_WritePin(GPIOC, GPIO_PIN_13, Test_Stateflow_P.Constant2_Value);  HAL_GPIO_WritePin(GPIOC, GPIO_PIN_14, Test_Stateflow_P.Constant2_Value);}

void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin){	if (GPIO_Pin != GPIO_PIN_1) return;	if (HAL_GPIO_ReadPin(GPIOC, GPIO_PIN_1) == GPIO_PIN_SET) {		/* This block is run on the rising edge of the READ signal */		/* If not acquiring then exit callback */		if (!acquiring)			return;		flag_captureGoing = 1;		imageCursor = 0;		flag_captureEnd = 0;	} else {		/* This block is run on the falling edge of the READ signal */		flag_captureGoing = 0;		/* If not acquiring then exit callback */		if (!acquiring)			return;		flag_captureEnd = 1;	}}

	bool F7GPIO::read()	{		volatile int v;		v=HAL_GPIO_ReadPin(this->GPIOx,this->GPIO_Pin);		return v;	}

/*** @brief  This function handles External lines 15 to 4 interrupt request.* @param  None* @retval None*/void EXTI9_5_IRQHandler(void){  /* EXTI line 7 interrupt detected */  if(__HAL_GPIO_EXTI_GET_IT(RADIO_GPIO_3_EXTI_LINE))  {    __HAL_GPIO_EXTI_CLEAR_IT(RADIO_GPIO_3_EXTI_LINE);    HAL_GPIO_EXTI_Callback(RADIO_GPIO_3_EXTI_LINE);    spirit1_interrupt_callback();  }  __HAL_GPIO_EXTI_CLEAR_IT(GPIO_PIN_9);  __HAL_GPIO_EXTI_CLEAR_IT(GPIO_PIN_8);  __HAL_GPIO_EXTI_CLEAR_IT(GPIO_PIN_7);  __HAL_GPIO_EXTI_CLEAR_IT(GPIO_PIN_6);  __HAL_GPIO_EXTI_CLEAR_IT(GPIO_PIN_5);#ifndef  LPM_ENABLE  //  if(__HAL_GPIO_EXTI_GET_IT(KEY_BUTTON_EXTI_LINE) != RESET)  //  {  //    __HAL_GPIO_EXTI_CLEAR_IT(KEY_BUTTON_EXTI_LINE);  //  // Set_KeyStatus(SET);  //  }  //#else /*Low Power mode enabled*/#if defined(RF_STANDBY)/*if spirit1 is in standby*/  if(EXTI->PR & KEY_BUTTON_EXTI_LINE)  {    HAL_GPIO_EXTI_Callback(KEY_BUTTON_EXTI_LINE);    /* EXTI line 13 interrupt detected */    if(HAL_GPIO_ReadPin(KEY_BUTTON_GPIO_PORT, KEY_BUTTON_PIN) == 0x01) //0x00    {      HAL_GPIO_EXTI_Callback(KEY_BUTTON_EXTI_LINE);      PushButtonStatusWakeup = SET;      PushButtonStatusData = RESET;      wakeupCounter = LPM_WAKEUP_TIME;      dataSendCounter = DATA_SEND_TIME;      dataSendCounter++;    }    __HAL_GPIO_EXTI_CLEAR_IT(KEY_BUTTON_EXTI_LINE);  }#else /*if spirit1 is not in standby or sleep mode but MCU is in LPM*/  if(__HAL_GPIO_EXTI_GET_IT(KEY_BUTTON_EXTI_LINE) != RESET)  {    __HAL_GPIO_EXTI_CLEAR_IT(KEY_BUTTON_EXTI_LINE);    HAL_GPIO_EXTI_Callback(KEY_BUTTON_EXTI_LINE);    Set_KeyStatus(SET);  }#endif#endif}

void prvExtCtrlHandler(GPIO_TypeDef* GPIOx, uint16_t GPIO_Pin){    GPIO_PinState xPinState = HAL_GPIO_ReadPin(GPIOx, GPIO_Pin);    switch(xPinState)    {        case GPIO_PIN_SET:            /* Rising edge */            if(GPIO_Pin == GPIO_PIN_0)                xPitchTickTmp = __HAL_TIM_GetCounter(&xTimeBaseHandle);            else if(GPIO_Pin == GPIO_PIN_1)                xRollTickTmp = __HAL_TIM_GetCounter(&xTimeBaseHandle);            else if(GPIO_Pin == GPIO_PIN_3)                xYawTickTmp = __HAL_TIM_GetCounter(&xTimeBaseHandle);            break;        case GPIO_PIN_RESET:            /* Falling edge */            if(GPIO_Pin == GPIO_PIN_0)                xPitchTick = __HAL_TIM_GetCounter(&xTimeBaseHandle) - xPitchTickTmp;            else if(GPIO_Pin == GPIO_PIN_1)                xRollTick = __HAL_TIM_GetCounter(&xTimeBaseHandle) - xRollTickTmp;            else if(GPIO_Pin == GPIO_PIN_3)                xYawTick = __HAL_TIM_GetCounter(&xTimeBaseHandle) - xYawTickTmp;            break;        default:            break;    }    __HAL_GPIO_EXTI_CLEAR_IT(GPIO_Pin);}

uint8_t frsky_d8_rx_getpkt(void){  uint8_t ret = 0;  if (HAL_GPIO_ReadPin(CC2500_GD0_GPIO, CC2500_GD0_PIN) == GPIO_PIN_SET)  {    // note: can't read this while the packet is still being received.    // HAL_Delay(1); // but this is just silly.    CC2500_Strobe(CC2500_STROBE_SIDLE);        volatile uint8_t rx_packet_length = CC2500_ReadReg(CC2500_REG_RXBYTES | CC2500_READ_BURST);        if ((rx_packet_length > 7) && (rx_packet_length < D8_MAX_PACKET_SIZE)) // TODO: fix this to detect pktlen from bindmode    {      CC2500_ReadRXData(rxmsg.packet, rx_packet_length);            if ((rxmsg.d8_rx_packet_data.header_bindcode == m_config.frsky_d8_bind_info.bind_id) && (rxmsg.d8_rx_packet_data.len == 0x11))        /* So, there's two bytes in the packet header that indicate something.         * 0x0100 - North American launch day taranis A         *        - DJT jr module         * 0x0300 - XJT jr module         * There are others out there which are unknown, so this check is removed for now.         * Also, there's a CRC or something at the end. But it isn't. 0xA0 bits will always match it. */        ret = rx_packet_length;    }    CC2500_Strobe(CC2500_STROBE_SFRX);  }    return ret;}

int HAL_UART_Slave_Enabled(){#ifdef DISABLE_EXTERNAL_UART_INTERFACE	return 0;#endif	return (HAL_GPIO_ReadPin(GPIOB,GPIO_PIN_15) != GPIO_PIN_SET);}

uint8_t processUserInput(int8_t opt) {  char msg[30];  if(!(opt >=1 && opt <= 3))    return 0;  sprintf(msg, "%d", opt);  UART_Transmit(&huart2, (uint8_t*)msg, strlen(msg));  switch(opt) {  case 1:    HAL_GPIO_TogglePin(LD2_GPIO_Port, LD2_Pin);    break;  case 2:    sprintf(msg, "/r/nUSER BUTTON status: %s",        HAL_GPIO_ReadPin(GPIOC, GPIO_PIN_13) == GPIO_PIN_RESET ? "PRESSED" : "RELEASED");    UART_Transmit(&huart2, (uint8_t*)msg, strlen(msg));    break;  case 3:    return 2;  };  UART_Transmit(&huart2, (uint8_t*)PROMPT, strlen(PROMPT));  return 1;}

void keypad_mode(void){	osSemaphoreWait(keypad_semaphore, osWaitForever);	switch (key_number){		case 1:			DISPLAY_TEMP=1;			DISPLAY_ACC =0;			ACC_PITCH = 1;			ACC_ROLL = 0;			break;		case 2:			DISPLAY_TEMP=0;			DISPLAY_ACC =1;			ACC_PITCH = 1;			ACC_ROLL = 0;			break;		case 3:			DISPLAY_TEMP=0;			DISPLAY_ACC =1;			ACC_PITCH = 0;			ACC_ROLL = 1;			break;		default:			break;	}		rows_init();	if(HAL_GPIO_ReadPin(GPIOC, GPIO_PIN_5) == 0)	{			init_columns();			if(HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_13) == 0)					{				key_number = 1;			}			else if(HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_12) == 0)			{				key_number = 2;			}			else if(HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_11) == 0)			{				key_number = 3;			}			printf("%d/n", key_number);		}  		}

int HAL_RN4020_Get_RTS(){#ifdef ENABLE_RN4020    return (HAL_GPIO_ReadPin(GPIOC,GPIO_PIN_1) == GPIO_PIN_SET);#else    return 0;#endif}

int HAL_RN4020_Get_MLDP_EV(){#ifdef ENABLE_RN4020    return (HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_15) == GPIO_PIN_SET);#else    return 0;#endif}