bool USER_GPIO_EXTI_IRQHandler(uint16_t GPIO_Pin)
{
/* EXTI line interrupt detected */
if(__HAL_GPIO_EXTI_GET_IT(GPIO_Pin) != RESET)
{
__HAL_GPIO_EXTI_CLEAR_IT(GPIO_Pin);
return true;
}
return false;
}
/*lsm6ds3*/
void EXTI0_IRQHandler(void)
{
if(__HAL_GPIO_EXTI_GET_IT(MEMS_INT1_PIN) != RESET)
{
__HAL_GPIO_EXTI_CLEAR_IT(MEMS_INT1_PIN);
if(EXTI0_IRQFUNC)
(*EXTI0_IRQFUNC)();
// imu_sensor_read_data_from_fifo();
// printf("fifo interrupt \n");
}
}
/**
* @brief Enable SPI IRQ.
* @param None
* @retval None
*/
static void Enable_SPI_Receiving_Path(void)
{
__HAL_GPIO_EXTI_CLEAR_IT(BNRG_SPI_EXTI_PIN);
HAL_NVIC_ClearPendingIRQ(BNRG_SPI_EXTI_IRQn);
HAL_NVIC_EnableIRQ(BNRG_SPI_EXTI_IRQn);
if (HAL_GPIO_ReadPin(BNRG_SPI_IRQ_PORT, BNRG_SPI_IRQ_PIN) == GPIO_PIN_SET)
{
__HAL_GPIO_EXTI_GENERATE_SWIT(BNRG_SPI_IRQ_PIN);
}
}
/**
* ext irq handler
*
* Handles the gpio interrupt attached to a gpio pin.
*
* @param index
*/
static void
ext_irq_handler(int index)
{
uint32_t mask;
mask = 1 << index;
if (__HAL_GPIO_EXTI_GET_IT(mask) != RESET) {
__HAL_GPIO_EXTI_CLEAR_IT(mask);
gpio_irq_handlers[index].isr(gpio_irq_handlers[index].arg);
}
}
void EXTI1_IRQHandler(void)
{
if(__HAL_GPIO_EXTI_GET_IT(LSM303D_MAG_DRDY_PIN) != RESET)
{
LSM303D_MAG_READY(&LSM303D_MAG_report1);
LSM303D_RD_CNT++;
__HAL_GPIO_EXTI_CLEAR_IT(LSM303D_MAG_DRDY_PIN);
}
}
void EXTI4_IRQHandler(void)
{
if(__HAL_GPIO_EXTI_GET_IT(LSM303D_ACC_DRDY_PIN) != RESET)
{
// LSM303D_ACC_READY(&LSM303D_ACC_report1);
__HAL_GPIO_EXTI_CLEAR_IT(LSM303D_ACC_DRDY_PIN);
}
}
/**
* @brief This function handles EXTI0 Handler.
* @param None
* @retval None
*/
void EXTI2_IRQHandler(void)
{
/* EXTI line interrupt detected */
if(__HAL_GPIO_EXTI_GET_IT(PIN8_PIN) != RESET)
{
__HAL_GPIO_EXTI_CLEAR_IT(PIN8_PIN);
if(EXTI_CallBack[8]){ EXTI_CallBack[8](); }
}
/* EXTI line interrupt detected */
if(__HAL_GPIO_EXTI_GET_IT(PIN14_PIN) != RESET)
{
__HAL_GPIO_EXTI_CLEAR_IT(PIN14_PIN);
if(EXTI_CallBack[14]){ EXTI_CallBack[14](); }
}
/* EXTI line interrupt detected */
if(__HAL_GPIO_EXTI_GET_IT(PINA3_PIN) != RESET)
{
__HAL_GPIO_EXTI_CLEAR_IT(PINA3_PIN);
if(EXTI_CallBack[A3]){ EXTI_CallBack[A3](); }
}
}
void EXTI15_10_IRQHandler(void)
{
for(uint8_t i=0; i< (sizeof(EXTI_TAB)/sizeof(EXTI_TAB[0])); i++)
{
if(__HAL_GPIO_EXTI_GET_IT(EXTI_TAB[i]) != RESET)
{
__HAL_GPIO_EXTI_CLEAR_IT(EXTI_TAB[i]);
xQueueSendFromISR( joyPressQueue, &JOY_MAP[i], NULL );
break;
}
}
}
void hal_gpio_ext_irq_handler(uint16_t index)
{
uint32_t mask;
mask = HAL_GPIO_PIN(index);
if (__HAL_GPIO_EXTI_GET_IT(mask) != RESET) {
__HAL_GPIO_EXTI_CLEAR_IT(mask);
if (hal_gpio_irq[index].isr) {
++hal_gpio_irq[index].invoked;
hal_gpio_irq[index].isr(hal_gpio_irq[index].arg);
} else {
++hal_gpio_irq[index].dropped;
}
}
}
/**
* @brief Configures button GPIO and EXTI Line.
* @param Button: Button to be configured
* This parameter can be one of the following values:
* @arg BUTTON_WAKEUP: Wakeup Push Button
* @arg BUTTON_TAMPER: Tamper Push Button
* @arg BUTTON_KEY: Key Push Button
* @arg BUTTON_RIGHT: Joystick Right Push Button
* @arg BUTTON_LEFT: Joystick Left Push Button
* @arg BUTTON_UP: Joystick Up Push Button
* @arg BUTTON_DOWN: Joystick Down Push Button
* @arg BUTTON_SEL: Joystick Sel Push Button
* @param Button_Mode: Button mode
* This parameter can be one of the following values:
* @arg BUTTON_MODE_GPIO: Button will be used as simple IO
* @arg BUTTON_MODE_EXTI: Button will be connected to EXTI line
* with interrupt generation capability
* @retval None
*/
void BSP_PB_Init(Button_TypeDef Button, ButtonMode_TypeDef Button_Mode)
{
GPIO_InitTypeDef GPIO_InitStruct;
/* Enable the BUTTON clock */
BUTTONx_GPIO_CLK_ENABLE(Button);
if(Button_Mode == BUTTON_MODE_GPIO)
{
/* Configure Button pin as input */
GPIO_InitStruct.Pin = BUTTON_PIN[Button];
GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
GPIO_InitStruct.Pull = GPIO_NOPULL;
GPIO_InitStruct.Speed = GPIO_SPEED_FAST;
HAL_GPIO_Init(BUTTON_PORT[Button], &GPIO_InitStruct);
HAL_NVIC_DisableIRQ((IRQn_Type)(BUTTON_IRQn[Button]));
}
if(Button_Mode == BUTTON_MODE_EXTI)
{
/* Configure Button pin as input with External interrupt */
GPIO_InitStruct.Pin = BUTTON_PIN[Button];
GPIO_InitStruct.Pull = GPIO_NOPULL;
GPIO_InitStruct.Speed = GPIO_SPEED_FAST;
if(Button != BUTTON_WAKEUP)
{
GPIO_InitStruct.Mode = GPIO_MODE_IT_FALLING;
}
else
{
GPIO_InitStruct.Mode = GPIO_MODE_IT_RISING;
}
HAL_GPIO_Init(BUTTON_PORT[Button], &GPIO_InitStruct);
/* Enable and set Button EXTI Interrupt to the lowest priority */
HAL_NVIC_SetPriority((IRQn_Type)(BUTTON_IRQn[Button]), 0x0F, 0x0);
__HAL_GPIO_EXTI_CLEAR_IT(BUTTON_PIN[Button]);
NVIC_ClearPendingIRQ((IRQn_Type)(BUTTON_IRQn[Button]));
HAL_NVIC_EnableIRQ((IRQn_Type)(BUTTON_IRQn[Button]));
}
}
static void Ads1222_SenseD_EXTIGpioConfig()
{
GPIO_InitTypeDef GPIO_InitStructure;
/* Enable /DRDY clock */
ADS1222_D_DOUT_GPIO_CLK_ENABLE();
/* Configure PB15 pin as input floating */
GPIO_InitStructure.Mode = GPIO_MODE_IT_FALLING;
GPIO_InitStructure.Pull = GPIO_NOPULL;
GPIO_InitStructure.Pin = ADS1222_D_DOUT_PIN;
HAL_GPIO_Init(ADS1222_D_DOUT_PORT, &GPIO_InitStructure);
/* Enable and set EXTI Line15:10 Interrupt to the HIGH2 priority */
// !!! this is very important
// !!! we must clear EXTI bit first or it will trigger next interrupt when IRQ enabled
__HAL_GPIO_EXTI_CLEAR_IT(ADS1222_D_DOUT_PIN);
HAL_NVIC_SetPriority(ADS1222_D_DOUT_EXTI_IRQn, SYSTEM_IRQ_PRIORITY_HIGH_2, 0);
HAL_NVIC_EnableIRQ(ADS1222_D_DOUT_EXTI_IRQn);
}
/**
* @brief Clear EXTI (External Interrupt) line for SPI IRQ.
* @param None
* @retval None
*/
void Clear_SPI_EXTI_Flag(void)
{
__HAL_GPIO_EXTI_CLEAR_IT(BNRG_SPI_EXTI_PIN);
}
/**
* @brief Suspend callback.
* When Low power mode is enabled the debug cannot be used (IAR, Keil doesn't support it)
* @param hpcd: PCD handle
* @retval None
*/
void HAL_PCD_SuspendCallback(PCD_HandleTypeDef *hpcd)
{
U8 i,y;
// USBD_HID_HandleTypeDef *ptr;
// ptr = (USBD_HID_HandleTypeDef *)(hUsbDeviceFS.pClassData);
// GPIO_InitTypeDef GPIO_InitStruct;
/* Inform USB library that core enters in suspend Mode */
USBD_LL_Suspend(hpcd->pData);
/*Enter in STOP mode */
/* USER CODE BEGIN 2 */
if (hpcd->Init.low_power_enable)
{
//[ slash
// for (y = COLS; y < COLS+ROWS; y++) { // Scan, save, and update the current keyboard state
// gpio_setDirvalue(matrix[y].port, matrix[y].pin, GPIO_MODE_OUTPUT_PP, GPIO_PIN_SET);
// for (i = 0; i < 10; i++);
// }
if (HAL_TIM_Base_Stop_IT(&htim2) != HAL_OK)
{
/* Starting Error */
while(1);
}
HAL_I2CEx_AnalogFilter_Config(&hi2c2, I2C_ANALOGFILTER_DISABLE);
if (HAL_I2C_DeInit(&hi2c2)!= HAL_OK) {
while(1);
}
for (i=0;i<3;i++) {
((USBD_HID_HandleTypeDef *)&hUsbDeviceFS.pClassData)->state[i] = HID_BUSY;
}
HAL_GPIO_WritePin(LED_RESET_GPIO_Port, LED_RESET_Pin, GPIO_PIN_RESET); // Low to shut down led controller
// for (i = 0; i < 10; i++);
// GPIO_InitStruct.Pin = GPIO_PIN_0|GPIO_PIN_1|GPIO_PIN_2|GPIO_PIN_3
// |GPIO_PIN_4|GPIO_PIN_5|GPIO_PIN_6|GPIO_PIN_7
// |GPIO_PIN_15;
// GPIO_InitStruct.Pin = GPIO_PIN_15;
// GPIO_InitStruct.Mode = GPIO_MODE_IT_FALLING;
// GPIO_InitStruct.Pull = GPIO_NOPULL;
// HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
////// __HAL_GPIO_EXTI_CLEAR_IT(GPIO_PIN_0);
////// __HAL_GPIO_EXTI_CLEAR_IT(GPIO_PIN_1);
////// __HAL_GPIO_EXTI_CLEAR_IT(GPIO_PIN_2);
////// __HAL_GPIO_EXTI_CLEAR_IT(GPIO_PIN_3);
////// __HAL_GPIO_EXTI_CLEAR_IT(GPIO_PIN_4);
////// __HAL_GPIO_EXTI_CLEAR_IT(GPIO_PIN_5);
////// __HAL_GPIO_EXTI_CLEAR_IT(GPIO_PIN_6);
////// __HAL_GPIO_EXTI_CLEAR_IT(GPIO_PIN_7);
// __HAL_GPIO_EXTI_CLEAR_IT(GPIO_PIN_15);
__HAL_GPIO_EXTI_CLEAR_IT(GPIO_PIN_All);
//// HAL_NVIC_SetPriority(EXTI0_1_IRQn, 3, 0);
HAL_NVIC_EnableIRQ(EXTI0_1_IRQn);
//// HAL_NVIC_SetPriority(EXTI2_3_IRQn, 3, 0);
HAL_NVIC_EnableIRQ(EXTI2_3_IRQn);
// HAL_NVIC_SetPriority(EXTI4_15_IRQn, 3, 0);
HAL_NVIC_EnableIRQ(EXTI4_15_IRQn);
//// __HAL_GPIO_EXTI_CLEAR_IT(GPIO_PIN_0);
//// __HAL_GPIO_EXTI_CLEAR_IT(GPIO_PIN_1);
//// __HAL_GPIO_EXTI_CLEAR_IT(GPIO_PIN_2);
//// __HAL_GPIO_EXTI_CLEAR_IT(GPIO_PIN_3);
//// __HAL_GPIO_EXTI_CLEAR_IT(GPIO_PIN_4);
//// __HAL_GPIO_EXTI_CLEAR_IT(GPIO_PIN_5);
//// __HAL_GPIO_EXTI_CLEAR_IT(GPIO_PIN_6);
//// __HAL_GPIO_EXTI_CLEAR_IT(GPIO_PIN_7);
//// __HAL_GPIO_EXTI_CLEAR_IT(GPIO_PIN_15);
// __HAL_GPIO_EXTI_CLEAR_IT(GPIO_PIN_All);
//// HAL_NVIC_DisableIRQ(I2C2_IRQn);
//]
for (y = 0; y < COLS; y++) { // Scan, save, and update the current keyboard state
gpio_setDirvalue(matrix[y].port, matrix[y].pin, GPIO_MODE_OUTPUT_PP, GPIO_PIN_RESET);
for (i = 0; i < 10; i++);
}
for (y = 0; y < COLS; y++) { // Scan, save, and update the current keyboard state
gpio_setDirvalue(matrix[y].port, matrix[y].pin, GPIO_MODE_OUTPUT_PP, GPIO_PIN_RESET);
for (i = 0; i < 10; i++);
}
/* Set SLEEPDEEP bit and SleepOnExit of Cortex System Control Register */
// SCB->SCR |= (uint32_t)((uint32_t)(SCB_SCR_SLEEPDEEP_Msk | SCB_SCR_SLEEPONEXIT_Msk));
}
/* USER CODE END 2 */
}
void EXTI15_10_IRQHandler(void) {
__HAL_GPIO_EXTI_CLEAR_IT(GPIO_PIN_13);
HAL_GPIO_TogglePin(LD2_GPIO_Port, GPIO_PIN_5);
}
void EXTI9_5_IRQHandler(void)
{
button2.change_event();
__HAL_GPIO_EXTI_CLEAR_IT(GPIO_PIN_5);
}
/** @brief This function enables the button interrupt
*
* The interrupt is re-enabled after waiting for a possible bouncing phase.
* */
void de_bounce_callback(xTimerHandle)
{
// once more: reset EXTI I/O interrupt latch
__HAL_GPIO_EXTI_CLEAR_IT( KEY_BUTTON_PIN);
BSP_PB_Init (BUTTON_KEY, BUTTON_MODE_EXTI);
}
/**
* @brief Set in Output mode the IRQ.
* @param None
* @retval None
*/
static void set_irq_as_output(void)
{
HAL_GPIO_WritePin(BNRG_SPI_IRQ_PORT, BNRG_SPI_IRQ_PIN, GPIO_PIN_SET);
HAL_LPPUART_GPIO_Set_Mode(BNRG_SPI_IRQ_PORT, BNRG_SPI_IRQ_PIN_POSITION, GPIO_MODE_OUTPUT_PP);
__HAL_GPIO_EXTI_CLEAR_IT(BNRG_SPI_IRQ_PIN);
}
void EXTI15_10_IRQHandler(void){
__HAL_GPIO_EXTI_CLEAR_IT(GPIO_PIN_11);
if (cts_irq_handler){
(*cts_irq_handler)();
}
}
