/** * Configures the EZRadio GPIO port and pins * * @param[in] ezradioIrqCallback EZRadio interrupt callback configuration * @param[in] enablePTI If true enables the radio PTI bridge in the controller. */ void ezradio_hal_GpioInit( GPIOINT_IrqCallbackPtr_t ezradioIrqCallback, bool enablePTI ) { #if defined(_EZR32_HAPPY_FAMILY) (void)enablePTI; #endif #if !defined(EZRADIODRV_SPI_4WIRE_MODE) GPIO_PinModeSet( (GPIO_Port_TypeDef) RF_USARTRF_CS_PORT, RF_USARTRF_CS_PIN, gpioModePushPull, 1 ); #endif /* Setup enable and interrupt pins to radio */ GPIO_PinModeSet( (GPIO_Port_TypeDef) RF_SDN_PORT, RF_SDN_PIN, gpioModePushPull, 0 ); GPIO_PinModeSet( (GPIO_Port_TypeDef) RF_INT_PORT, RF_INT_PIN, gpioModeInputPull, 1 ); /* EZR32HG family uses hard wired PTI interface from the radio to the board controller */ #if ( !defined(_EZR32_HAPPY_FAMILY) && !defined(EZRADIODRV_DISABLE_PTI) ) if (enablePTI) { /* Setup PRS for PTI pins */ CMU_ClockEnable(cmuClock_PRS, true); /* Configure RF_GPIO0 and RF_GPIO1 to inputs. */ GPIO_PinModeSet((GPIO_Port_TypeDef)RF_GPIO0_PORT, RF_GPIO0_PIN, gpioModeInput, 0); GPIO_PinModeSet((GPIO_Port_TypeDef)RF_GPIO1_PORT, RF_GPIO1_PIN, gpioModeInput, 0); /* Pin PA0 and PA1 output the GPIO0 and GPIO1 via PRS to PTI */ GPIO_PinModeSet(gpioPortA, 0, gpioModePushPull, 0); GPIO_PinModeSet(gpioPortA, 1, gpioModePushPull, 0); /* Disable INT for PRS channels */ GPIO_IntConfig((GPIO_Port_TypeDef)RF_GPIO0_PORT, RF_GPIO0_PIN, false, false, false); GPIO_IntConfig((GPIO_Port_TypeDef)RF_GPIO1_PORT, RF_GPIO1_PIN, false, false, false); /* Setup PRS for RF GPIO pins */ PRS_SourceAsyncSignalSet(0, PRS_CH_CTRL_SOURCESEL_GPIOH, PRS_CH_CTRL_SIGSEL_GPIOPIN15); PRS_SourceAsyncSignalSet(1, PRS_CH_CTRL_SOURCESEL_GPIOH, PRS_CH_CTRL_SIGSEL_GPIOPIN14); PRS->ROUTE = (PRS_ROUTE_CH0PEN | PRS_ROUTE_CH1PEN); /* Make sure PRS sensing is enabled (should be by default) */ GPIO_InputSenseSet(GPIO_INSENSE_PRS, GPIO_INSENSE_PRS); } #endif //#if !defined(_EZR32_HAPPY_FAMILY) #if defined(EZRADIODRV_DISABLE_PTI) && defined(EZRADIODRV_COMM_USE_GPIO1_FOR_CTS) //Enable GPIO1 for CTS input GPIO_PinModeSet((GPIO_Port_TypeDef)RF_GPIO1_PORT, RF_GPIO1_PIN, gpioModeInput, 0); #endif if (NULL != ezradioIrqCallback) { /* Register callback and enable interrupt */ GPIOINT_CallbackRegister( RF_INT_PIN, ezradioIrqCallback ); GPIO_IntConfig( (GPIO_Port_TypeDef) RF_INT_PORT, RF_INT_PIN, false, true, true ); } }
/**************************************************************************//** * @brief Initialize Real Time Counter *****************************************************************************/ void initRTC() { /* Starting LFXO and waiting until it is stable */ CMU_OscillatorEnable(cmuOsc_LFXO, true, true); /* Routing the LFXO clock to the RTC */ CMU_ClockSelectSet(cmuClock_LFA, cmuSelect_LFXO); CMU_ClockEnable(cmuClock_RTC, true); /* Enabling clock to the interface of the low energy modules */ CMU_ClockEnable(cmuClock_CORELE, true); const RTC_Init_TypeDef rtcInit = { .enable = true, .debugRun = false, .comp0Top = true, }; RTC_Init(&rtcInit); /* Set comapre value for compare register 0 */ RTC_CompareSet(0, RTC_COUNT_BETWEEN_WAKEUP); /* Enable interrupt for compare register 0 */ RTC_IntEnable(RTC_IFC_COMP0); /* Enabling Interrupt from RTC */ NVIC_EnableIRQ(RTC_IRQn); RTC_Enable(false); } /**************************************************************************//** * @brief Initialize General Purpuse Input/Output *****************************************************************************/ void initGPIO() { /* Enable clock for GPIO module */ CMU_ClockEnable(cmuClock_GPIO, true); /* Configure pin PB9/PD8 (Push Button 1) and PB10/PB11 (Push Button 2) as an input, * so that we can read their values. */ GPIO_PinModeSet(PB0_PORT, PB0_PIN, gpioModeInput, 1); GPIO_PinModeSet(PB1_PORT, PB1_PIN, gpioModeInput, 1); /* Enable GPIO_ODD and GPIO_EVEN interrupts in NVIC */ NVIC_EnableIRQ(GPIO_ODD_IRQn); NVIC_EnableIRQ(GPIO_EVEN_IRQn); /* Configure interrupts on falling edge for pins B9/D8 (Push Button 1), * B10/B11 (Push Button 2) and D3 */ GPIO_IntConfig(PB0_PORT, PB0_PIN, true, true, true); GPIO_IntConfig(PB1_PORT, PB1_PIN, true, true, true); }
/*============================================================================== hal_extIntInit() =============================================================================*/ uint8_t hal_extIntInit(en_targetExtInt_t e_intSource, pfn_intCallb_t pfn_intCallback) { int8_t c_ret = 0; s_hal_gpio_pin_t* p_gpioPin = NULL; if( pfn_intCallback != NULL ) { /* Initialize GPIO interrupt dispatcher */ GPIOINT_Init(); switch( e_intSource ){ case E_TARGET_RADIO_INT: pf_hal_radioCb = pfn_intCallback; p_gpioPin = &s_hal_gpio[e_hal_gpios_rf_irq]; /* configure pin */ GPIO_PinModeSet( p_gpioPin->port, p_gpioPin->pin, p_gpioPin->mode, p_gpioPin->val ); /* Register callbacks before setting up and enabling pin interrupt. */ GPIOINT_CallbackRegister( p_gpioPin->pin, _hal_radioCb ); /* Set falling edge interrupt */ GPIO_IntConfig( p_gpioPin->port, p_gpioPin->pin, true, false, true ); c_ret = 1; break; case E_TARGET_USART_INT: break; default: break; } } return c_ret; } /* hal_extIntInit() */
__LINK_C error_t hw_gpio_configure_interrupt(pin_id_t pin_id, gpio_inthandler_t callback, uint8_t event_mask) { if(interrupts[pin_id.pin].interrupt_port != pin_id.port) return EOFF; else if(callback == 0x0 || event_mask > (GPIO_RISING_EDGE | GPIO_FALLING_EDGE)) return EINVAL; error_t err; start_atomic(); //do this check atomically: interrupts[..] callback is altered by this function //so the check belongs in the critical section as well if(interrupts[pin_id.pin].callback != 0x0 && interrupts[pin_id.pin].callback != callback) err = EBUSY; else { interrupts[pin_id.pin].callback = callback; GPIOINT_CallbackRegister(pin_id.pin, &gpio_int_callback); GPIO_IntConfig(pin_id.port, pin_id.pin, !!(event_mask & GPIO_RISING_EDGE), !!(event_mask & GPIO_FALLING_EDGE), false); err = SUCCESS; } end_atomic(); return err; }
/* * Interrupt GDO2 init */ void CC1101_Radio::initializeRadioInterrupt2( bool rising, bool falling ) { GPIO_PinModeSet( _CC1101_INT_PIN_TWO, gpioModeInputPull, 1 ); GPIO->IFC = ~0; GPIO_IntConfig( _CC1101_INT_PIN_TWO, rising, falling, true ); NVIC_EnableIRQ( GPIO_EVEN_IRQn ); }
void setup_gpio_and_buttons() { CMU_ClockEnable(cmuClock_GPIO, true); // Make sure the soleniod is off at startup GPIO_PinModeSet(SOLENOID_PORT, SOLENOID_PIN, gpioModePushPull, 0); // Set up the user interface buttons GPIO_PinModeSet(BUTTON_PORT, SET_BUTTON_PIN, gpioModeInput, 0); GPIO_PinModeSet(BUTTON_PORT, ADJUST_BUTTON_PIN, gpioModeInput, 0); set_button.short_press = false; set_button.long_press = false; set_button.pin = SET_BUTTON_PIN; adjust_button.short_press = false; adjust_button.long_press = false; adjust_button.pin = ADJUST_BUTTON_PIN; program_button.short_press = false; program_button.long_press = false; button_array[SET_BUTTON_INDEX] = &set_button; button_array[ADJUST_BUTTON_INDEX] = &adjust_button; button_array[PROGRAM_BUTTON_INDEX] = &program_button; // Enable GPIO_ODD interrupt vector in NVIC //NVIC_EnableIRQ(GPIO_ODD_IRQn); NVIC_EnableIRQ(GPIO_EVEN_IRQn); // Configure interrupt on falling edge of SET_BUTTON_PIN GPIO_IntConfig(BUTTON_PORT, SET_BUTTON_PIN, false, true, true); }
int gpio_init_int(gpio_t pin, gpio_mode_t mode, gpio_flank_t flank, gpio_cb_t cb, void *arg) { int result = gpio_init(pin, mode); if (result != 0) { return result; } /* just in case, disable the interrupt for this pin */ GPIO_IntDisable(_pin_num(pin)); /* store interrupt callback */ isr_ctx[_pin_num(pin)].cb = cb; isr_ctx[_pin_num(pin)].arg = arg; /* enable interrupts */ GPIO_IntConfig(_port_num(pin), _pin_num(pin), flank & GPIO_RISING, flank & GPIO_FALLING, true); NVIC_ClearPendingIRQ(GPIO_EVEN_IRQn); NVIC_ClearPendingIRQ(GPIO_ODD_IRQn); NVIC_EnableIRQ(GPIO_EVEN_IRQn); NVIC_EnableIRQ(GPIO_ODD_IRQn); return 0; }
void initGPIO() { CMU_ClockEnable(cmuClock_GPIO, true); // enable GPIO peripheral clock GPIO_PinModeSet(GPS_PORT, FIX, gpioModeInput, 0); // set FIX pin as input (no filter) GPIO_PinModeSet(GPS_PORT, ENABLE, gpioModePushPull, 0); // set ENABLE pin as output, initialize low GPIO_PinModeSet(LED_PORT, LED0_PIN, gpioModePushPull, 0); // configure LED0 pin as push-pull output with standard drive strength GPIO_PinModeSet(LED_PORT, LED1_PIN, gpioModePushPull, 0); // configure LED1 pin as push-pull output with alternate drive strength GPIO_PinModeSet(EXT_LED, RED_LED, gpioModePushPull, 0); // configure LED1 pin as push-pull output with alternate drive strength GPIO_PinModeSet(EXT_LED, YEL_LED, gpioModePushPull, 0); // configure LED1 pin as push-pull output with alternate drive strength GPIO_PinModeSet(EXT_LED, GRE_LED, gpioModePushPull, 0); // configure LED1 pin as push-pull output with alternate drive strength GPIO_DriveModeSet(LED_PORT, gpioDriveModeLowest); // set alternate drive strength to lowest setting (0.5mA) GPIO_PinOutClear(LED_PORT, LED0_PIN); // turn on LED0 GPIO_PinOutSet(LED_PORT, LED1_PIN); // turn on LED1 GPIO_PinOutClear(EXT_LED, RED_LED); GPIO_PinOutClear(EXT_LED, YEL_LED); // turn on LED1 GPIO_PinOutClear(EXT_LED, GRE_LED); GPIO_PinModeSet(BUT_PORT, LEFT_BUT, gpioModeInputPull, 1); //configure left button as input with pull-up enabled GPIO_PinModeSet(BUT_PORT, RIGHT_BUT, gpioModeInputPull, 1); //'' but with right button NVIC_EnableIRQ(GPIO_ODD_IRQn); //enable gpio_even interrupt vector in nvic GPIO_IntConfig(GPS_PORT, FIX, true, false, true); //configure FIX pin interrupt on rising }
/***************************************************************************** * Waits in EM3 until the bootloader pin is pulled low. This saves power * while waiting to install firmware. *****************************************************************************/ void enterLowPowerWait(void) { /* Enable interrupt on GPIO pin. Note that * if the pin is changed to an odd pin number * the interrupt handler must also be changed */ GPIO_IntConfig(BOOTLOADER_PIN, true, false, true); NVIC_EnableIRQ(GPIO_EVEN_IRQn); /* Wait in EM3 until the pin is pulled low */ while ( GPIO_PinInGet(BOOTLOADER_PIN) ) { EMU_EnterEM3(false); } /* Disable interrupts again */ GPIO_IntConfig(BOOTLOADER_PIN, false, false, false); NVIC_DisableIRQ(GPIO_EVEN_IRQn); }
static void Bitless_GpioSetup(void) { for (int i = 0; i < NUM_BUTTONS; i++) { /* Configure the five as input */ GPIO_PinModeSet(BTNS[i].port, BTNS[i].pin, gpioModeInput, 0); /* Set falling edge interrupt for both ports */ GPIO_IntConfig(BTNS[i].port, BTNS[i].pin, false, true, true); } }
/** @brief Initialize External Device GPIOs * @param deviceIntCB The callback routine for device general interrupt * (NULL to disable) * @param deviceRdyCB The callback routine for device ready interrupt * (NULL to disable) * @return bitmask of configured features for this device * @note First initialization after bootup leaves the device powered down * and unselected. Subsequent inits don't touch the device powered * or selected states and can be used to reconfigure callback(s), * which always clears any stale/pending events. For deviceRdyCB, * its interrupt is enabled upon configuration; for deviceIntCB, * halExtDeviceIntEnable() must subsequently be called to enable it. */ HalExtDeviceConfig halExtDeviceInit(HalExtDeviceIrqCB deviceIntCB, HalExtDeviceIrqCB deviceRdyCB) { UNUSED_VAR(halExtDeviceRdyCB); // Work around potential compiler warnings UNUSED_VAR(halExtDeviceIntCB); // Work around potential compiler warnings halExtDeviceRdyCB = deviceRdyCB; halExtDeviceIntCB = deviceIntCB; CMU_ClockEnable(cmuClock_PRS, true); /* Pin is configured to Push-pull: SDN */ GPIO_PinModeSet((GPIO_Port_TypeDef) RF_SDN_PORT, RF_SDN_PIN, gpioModePushPull, 1u); /* Pin is configured to Push-pull: nSEL */ GPIO_PinModeSet((GPIO_Port_TypeDef) RF_USARTRF_CS_PORT, RF_USARTRF_CS_PIN, gpioModePushPull, 1u); /* Pin PE13 is configured input: nIRQ */ //GPIO_PinModeSet(RF_INT_PORT, RF_INT_PIN, gpioModeInput, 0u); /* Pin PA15 and PE14 are connected to GPIO0 and GPIO1 respectively. */ GPIO_PinModeSet((GPIO_Port_TypeDef) RF_GPIO0_PORT, RF_GPIO0_PIN, gpioModeInput, 0); GPIO_PinModeSet((GPIO_Port_TypeDef) RF_GPIO1_PORT, RF_GPIO1_PIN, gpioModeInput, 0); /* Pin PA0 and PA1 are output the GPIO0 and GPIO1 via PRS */ GPIO_PinModeSet(gpioPortA, 0, gpioModePushPull, 0); GPIO_PinModeSet(gpioPortA, 1, gpioModePushPull, 0); /* Configure INT/PRS channels */ GPIO_IntConfig((GPIO_Port_TypeDef) RF_GPIO0_PORT, RF_GPIO0_PIN, false, false, false); GPIO_IntConfig((GPIO_Port_TypeDef) RF_GPIO1_PORT, RF_GPIO1_PIN, false, false, false); /* Setup PRS */ PRS_SourceAsyncSignalSet(0, PRS_CH_CTRL_SOURCESEL_GPIOH, PRS_CH_CTRL_SIGSEL_GPIOPIN15); PRS_SourceAsyncSignalSet(1, PRS_CH_CTRL_SOURCESEL_GPIOH, PRS_CH_CTRL_SIGSEL_GPIOPIN14); PRS->ROUTE = (PRS_ROUTE_CH0PEN | PRS_ROUTE_CH1PEN); /* Make sure PRS sensing is enabled (should be by default) */ GPIO_InputSenseSet(GPIO_INSENSE_PRS, GPIO_INSENSE_PRS); /* TODO: Check whether the removed part is required for the EZR32 implementation */ halExtDeviceRdyCfgIrq(); halExtDeviceIntCfgIrq(); return 0; }
/********************************************************** * Enable GPIO interrupts on both push buttons on the STK **********************************************************/ void gpioInit(void) { /* Enable clock to GPIO */ CMU_ClockEnable(cmuClock_GPIO, true); /* Enable interrupt on push button 0 */ GPIO_PinModeSet(gpioPortB, 9, gpioModeInput, 0); GPIO_IntConfig(gpioPortB, 9, false, true, true); NVIC_ClearPendingIRQ(GPIO_ODD_IRQn); NVIC_EnableIRQ(GPIO_ODD_IRQn); /* Enable interrupt on push button 1 */ GPIO_PinModeSet(gpioPortB, 10, gpioModeInput, 0); GPIO_IntConfig(gpioPortB, 10, false, true, true); NVIC_ClearPendingIRQ(GPIO_EVEN_IRQn); NVIC_EnableIRQ(GPIO_EVEN_IRQn); }
/**************************************************************************//** * @brief Setup GPIO interrupt to set the time *****************************************************************************/ void gpioSetup(void) { /* Configure PB10 as input */ GPIO_PinModeSet(gpioPortB, 10, gpioModeInput, 0); /* Set falling edge interrupt */ GPIO_IntConfig(gpioPortB, 10, false, true, true); NVIC_ClearPendingIRQ(GPIO_EVEN_IRQn); NVIC_EnableIRQ(GPIO_EVEN_IRQn); /* Configure PB9 as input */ GPIO_PinModeSet(gpioPortB, 9, gpioModeInput, 0); /* Set falling edge interrupt */ GPIO_IntConfig(gpioPortB, 9, false, true, true); NVIC_ClearPendingIRQ(GPIO_ODD_IRQn); NVIC_EnableIRQ(GPIO_ODD_IRQn); }
/**************************************************************************//** * @brief Setup GPIO interrupt to change demo mode *****************************************************************************/ void gpioSetup(void) { /* Enable GPIO clock */ CMU->HFPERCLKEN0 |= CMU_HFPERCLKEN0_GPIO; /* Configure PB10 as input and enable interrupt */ GPIO_PinModeSet(gpioPortB, 10, gpioModeInputPull, 1); GPIO_IntConfig(gpioPortB, 10, false, true, true); NVIC_ClearPendingIRQ(GPIO_EVEN_IRQn); NVIC_EnableIRQ(GPIO_EVEN_IRQn); /* Configure PB9 as input and enable interrupt */ GPIO_PinModeSet(gpioPortB, 9, gpioModeInputPull, 1); GPIO_IntConfig(gpioPortB, 9, false, true, true); NVIC_ClearPendingIRQ(GPIO_ODD_IRQn); NVIC_EnableIRQ(GPIO_ODD_IRQn); }
/**************************************************************************//** * @brief Setup GPIO interrupt for pushbuttons. *****************************************************************************/ static void gpioSetup(void) { /* Enable GPIO clock */ CMU_ClockEnable(cmuClock_GPIO, true); /* Configure PC8 as input and enable interrupt */ GPIO_PinModeSet(gpioPortC, 8, gpioModeInputPull, 1); GPIO_IntConfig(gpioPortC, 8, false, true, true); NVIC_ClearPendingIRQ(GPIO_EVEN_IRQn); NVIC_EnableIRQ(GPIO_EVEN_IRQn); /* Configure PC9 as input and enable interrupt */ GPIO_PinModeSet(gpioPortC, 9, gpioModeInputPull, 1); GPIO_IntConfig(gpioPortC, 9, false, true, true); NVIC_ClearPendingIRQ(GPIO_ODD_IRQn); NVIC_EnableIRQ(GPIO_ODD_IRQn); }
/**************************************************************************//** * @brief Setup the GPIO *****************************************************************************/ void setupGPIO(void) { /* Configure measuring pin as push pull */ GPIO_PinModeSet(LCSENSE_SENSOR_PORT, LCSENSE_SENSOR_PIN, gpioModePushPull, 0); /* Enable push button 0 pin as input. */ GPIO_PinModeSet(LCSENSE_BUTTON_PORT, LCSENSE_BUTTON_PIN, gpioModeInput, 0); /* Enable interrupts for that pin. */ GPIO_IntConfig(LCSENSE_BUTTON_PORT, LCSENSE_BUTTON_PIN, false, true, true); /* Enable GPIO_EVEN interrupt vector in NVIC. */ NVIC_EnableIRQ(GPIO_EVEN_IRQn); }
/**************************************************************************//** * @brief Setup GPIO interrupt to set the time *****************************************************************************/ void gpioSetup(void) { /* Enable GPIO in CMU */ CMU_ClockEnable(cmuClock_GPIO, true); /* Configure PB9 and PB10 as input */ GPIO_PinModeSet(gpioPortB, 9, gpioModeInput, 0); GPIO_PinModeSet(gpioPortB, 10, gpioModeInput, 0); /* Set falling edge interrupt for both ports */ GPIO_IntConfig(gpioPortB, 9, false, true, true); GPIO_IntConfig(gpioPortB, 10, false, true, true); /* Enable interrupt in core for even and odd gpio interrupts */ NVIC_ClearPendingIRQ(GPIO_EVEN_IRQn); NVIC_EnableIRQ(GPIO_EVEN_IRQn); NVIC_ClearPendingIRQ(GPIO_ODD_IRQn); NVIC_EnableIRQ(GPIO_ODD_IRQn); }
/**************************************************************************//** * @brief Initialize GPIO interrupt for joystick (ie FPGA signal) *****************************************************************************/ void eepromtestIRQInit(void) { /* Configure interrupt pin as input with pull-up */ GPIO_PinModeSet(GPIO_INT_PORT, GPIO_INT_PIN, gpioModeInputPull, 2); /* Set falling edge interrupt and clear/enable it */ GPIO_IntConfig(GPIO_INT_PORT, GPIO_INT_PIN, false, true, true); NVIC_ClearPendingIRQ(GPIO_EVEN_IRQn); NVIC_EnableIRQ(GPIO_EVEN_IRQn); }
/**************************************************************************//** * @brief Initialize GPIO interrupt for joystick (ie FPGA signal) *****************************************************************************/ void temperatureIRQInit(void) { /* Configure interrupt pin as input with pull-up */ GPIO_PinModeSet(gpioPortC, GPIO_INT_PIN, gpioModeInputPull, 1); /* Set falling edge interrupt and clear/enable it */ GPIO_IntConfig(gpioPortC, GPIO_INT_PIN, false, true, true); NVIC_ClearPendingIRQ(GPIO_EVEN_IRQn); NVIC_EnableIRQ(GPIO_EVEN_IRQn); }
/* functions */ void RADIO_Init() { // usart 0 location 2 // enable pins GPIO_PinModeSet(NRF_CE_PORT, NRF_CE_PIN, gpioModePushPull, 0); GPIO_PinModeSet(NRF_CSN_PORT, NRF_CSN_PIN, gpioModePushPull, 1); GPIO_PinModeSet(NRF_INT_PORT, NRF_INT_PIN, gpioModeInput, 0); GPIO_PinModeSet(NRF_RXEN_PORT, NRF_RXEN_PIN, gpioModePushPull, 0); GPIO_PinModeSet(gpioPortC, 11, gpioModePushPull, 1); GPIO_PinModeSet(gpioPortC, 10, gpioModeInput, 0); GPIO_PinModeSet(gpioPortC, 9, gpioModePushPull, 0); USART_InitSync_TypeDef usartInit = USART_INITSYNC_DEFAULT; usartInit.msbf = true; usartInit.clockMode = usartClockMode0; usartInit.baudrate = 1000000; USART_InitSync(NRF_USART, &usartInit); NRF_USART->ROUTE = (NRF_USART->ROUTE & ~_USART_ROUTE_LOCATION_MASK) | USART_ROUTE_LOCATION_LOC2; NRF_USART->ROUTE |= USART_ROUTE_TXPEN | USART_ROUTE_RXPEN | USART_ROUTE_CLKPEN; // configure gpio interrupt GPIO_IntClear(1 << 0); writeRegister(NRF_STATUS,0x70); GPIO_IntConfig(NRF_INT_PORT,NRF_INT_PIN,false,true,true); // initial config writeRegister(NRF_EN_AA,0x00); writeRegister(NRF_EN_RXADDR,0x3F); writeRegister(NRF_SETUP_AW,0x03); writeRegister(NRF_SETUP_RETR,0x00); writeRegister(NRF_RF_CH,NODE_CH); writeRegister(NRF_RF_SETUP,0x0F); uint8_t addr_array[5]; addr_array[0] = 0xE7; addr_array[1] = 0xE7; addr_array[2] = 0xE7; addr_array[3] = 0xE7; addr_array[4] = 0xE7; writeRegisterMulti(NRF_TX_ADDR, addr_array, 5); writeRegisterMulti(NRF_RX_ADDR_P0, addr_array, 5); writeRegister(NRF_RX_PW_P0,0x20); writeRegister(NRF_DYNPD, 0x00); writeRegister(NRF_FEATURE, 0x00); }
/**************************************************************************//** * @brief Gpio setup. Setup button pins to trigger falling edge interrupts. * Register callbacks for that interrupts. *****************************************************************************/ void gpioSetup(void) { /* Enable GPIO in CMU */ CMU_ClockEnable(cmuClock_GPIO, true); /* Initialize GPIO interrupt dispatcher */ GPIOINT_Init(); /* Configure PB9 and PB10 as input */ GPIO_PinModeSet(gpioPortB, 9, gpioModeInput, 0); GPIO_PinModeSet(gpioPortB, 10, gpioModeInput, 0); /* Register callbacks before setting up and enabling pin interrupt. */ GPIOINT_CallbackRegister(9, gpioCallback); GPIOINT_CallbackRegister(10, gpioCallback); /* Set falling edge interrupt for both ports */ GPIO_IntConfig(gpioPortB, 9, false, true, true); GPIO_IntConfig(gpioPortB, 10, false, true, true); }
/**************************************************************************//** * @brief Initialize GPIO interrupt on PC14 *****************************************************************************/ void GPIO_IRQInit(void) { /* Configure PC14 as input pull, drive high */ GPIO_PinModeSet(gpioPortC, 14, gpioModeInputPull, 1); /* Set and enable falling edge interrupt */ GPIO_IntConfig(gpioPortC, 14, false, true, true); NVIC_ClearPendingIRQ(GPIO_EVEN_IRQn); NVIC_EnableIRQ(GPIO_EVEN_IRQn); }
/**************************************************************************//** * @brief Initialize GPIO interrupt on PC14 *****************************************************************************/ static void GpioIrqInit(void) { /* Configure interrupt pin as input with pull-up */ GPIO_PinModeSet(gpioPortE, 2, gpioModeInputPull, 1); /* Set falling edge interrupt and clear/enable it */ GPIO_IntConfig(gpioPortE, 2, false, true, true); NVIC_ClearPendingIRQ(GPIO_EVEN_IRQn); NVIC_EnableIRQ(GPIO_EVEN_IRQn); }
/**************************************************************************//** * @brief Setup GPIO interrupt to set the time *****************************************************************************/ void gpioSetup(void) { /* Enable GPIO in CMU */ CMU_ClockEnable(cmuClock_GPIO, true); /* Configure PD8 as input */ GPIO_PinModeSet(gpioPortD, 8, gpioModeInput, 0); /* Set falling edge interrupt */ GPIO_IntConfig(gpioPortD, 8, false, true, true); NVIC_ClearPendingIRQ(GPIO_EVEN_IRQn); NVIC_EnableIRQ(GPIO_EVEN_IRQn); /* Configure PB11 as input */ GPIO_PinModeSet(gpioPortB, 11, gpioModeInput, 0); /* Set falling edge interrupt */ GPIO_IntConfig(gpioPortB, 11, false, true, true); NVIC_ClearPendingIRQ(GPIO_ODD_IRQn); NVIC_EnableIRQ(GPIO_ODD_IRQn); }
/**************************************************************************//** * @brief Initialize GPIO interrupt on PE0 and PE1 *****************************************************************************/ void GPIO_IRQInit(void) { // enable clock for GPIO module CMU_ClockEnable(cmuClock_GPIO, true); // Init the Button BUT1 located on PIN PE0 GPIO_PinModeSet(gpioPortE,0,gpioModeInputPullFilter,1); // Init the Button BUT2 located on PIN PE1 GPIO_PinModeSet(gpioPortE,1,gpioModeInputPullFilter,1); /* Enable GPIO_ODD interrupt vector in NVIC */ NVIC_EnableIRQ(GPIO_ODD_IRQn); /* Enable GPIO_EVEN interrupt vector in NVIC */ NVIC_EnableIRQ(GPIO_EVEN_IRQn); /* Configure PE0 interrupt on falling edge */ GPIO_IntConfig(gpioPortE, 0, false, true, true); /* Configure PE1 interrupt on falling edge */ GPIO_IntConfig(gpioPortE, 1, false, true, true); }
void qk_gpio_interrupt_set(qk_gpio_pin pin, uint32_t flags) { bool risingEdge = false, fallingEdge = false; if(flags & QK_GPIO_FLAG_FALL) fallingEdge = true; if(flags & QK_GPIO_FLAG_RISE) risingEdge = true; GPIO_IntConfig((GPIO_Port_TypeDef) _QK_GPIO_PORT(pin), (unsigned int) _QK_GPIO_BIT(pin), risingEdge, fallingEdge, true); }
/** @brief Configure and enable/disable the device interrupt IRQ */ static void halExtDeviceIntCfgIrq(void) { /* Configure nIRQ signal to trigger Port Pin ISR */ GPIO_PinModeSet((GPIO_Port_TypeDef) RF_INT_PORT, RF_INT_PIN, gpioModeInput, 1u); GPIO_InputSenseSet(GPIO_INSENSE_INT, GPIO_INSENSE_INT); GPIOINT_CallbackRegister(RF_INT_PIN, halIrqxIsr); GPIO_IntConfig((GPIO_Port_TypeDef) RF_INT_PORT, RF_INT_PIN, false, true, true); if (halExtDeviceIntCB == NULL) { halExtDeviceIntLevel = EXT_DEVICE_INT_UNCONFIGURED; } else { halExtDeviceIntLevel = EXT_DEVICE_INT_LEVEL_OFF; // Callers need to use halExtDeviceIntEnable() to enable top level } }
/**************************************************************************//** * @brief Main function *****************************************************************************/ int main(void) { /* Initialize chip */ CHIP_Init(); setupSWO(); BSP_LedsInit(); /* Enable clock for GPIO module */ CMU_ClockEnable(cmuClock_GPIO, true); /* Configure interrupt for Push Button 0 */ GPIO_PinModeSet(PB0_PORT, PB0_PIN, gpioModeInput, 1); #if defined(_EFM32_GIANT_FAMILY) NVIC_EnableIRQ(GPIO_ODD_IRQn); #else NVIC_EnableIRQ(GPIO_EVEN_IRQn); #endif GPIO_IntConfig(PB0_PORT, PB0_PIN, false, true, true); /* By turning on retention in EM4, the state of the GPIO pins * can be retained in all energy modes */ GPIO->CTRL = GPIO_CTRL_EM4RET; /* Uncomment to drive LED in all energy modes */ /* BSP_LedSet(0);*/ while (1) { switch (STATE) { case EM0: break; case EM1: EMU_EnterEM1(); break; case EM2: EMU_EnterEM2(true); break; case EM3: EMU_EnterEM3(true); case EM4: EMU_EnterEM4(); break; } } }
/**************************************************************************//** * @brief Setup the GPIO *****************************************************************************/ void setupGPIO(void) { /* Configure the drive strength of the ports for the light sensor. */ GPIO_DriveModeSet(LIGHTSENSE_EXCITE_PORT, gpioDriveModeStandard); GPIO_DriveModeSet(LIGHTSENSE_SENSOR_PORT, gpioDriveModeStandard); /* Initialize the 2 GPIO pins of the light sensor setup. */ GPIO_PinModeSet(LIGHTSENSE_EXCITE_PORT, LIGHTSENSE_EXCITE_PIN, gpioModePushPull, 0); GPIO_PinModeSet(LIGHTSENSE_SENSOR_PORT, LIGHTSENSE_SENSOR_PIN, gpioModeDisabled, 0); /* Enable push button 0 pin as input. */ GPIO_PinModeSet(LIGHTSENSE_BUTTON0_PORT, LIGHTSENSE_BUTTON0_PIN, gpioModeInput, 0); /* Enable interrupts for that pin. */ GPIO_IntConfig(LIGHTSENSE_BUTTON0_PORT, LIGHTSENSE_BUTTON0_PIN, false, true, true); /* Enable GPIO_EVEN interrupt vector in NVIC. */ NVIC_EnableIRQ(GPIO_ODD_IRQn); }
/** * Initializes the SPI pins, frequency, and SPI mode configuration. */ void enc28j60_spi_init(void) { /* * UEXT connections with STM32-P152: * 1 +3.3V * 2 GND * 3 LEDA = TX_US1 * 4 WOL = RX_US1 * 5 INT = PD7 * 6 RST = PD6 * 7 MISO = PE11 * 8 MOSI = PE10 * 9 SCK = PE12 * 10 CS = PE13 */ // Enable clocks. CMU_ClockEnable(cmuClock_GPIO, true); CMU_ClockEnable(cmuClock_USART0, true); // Configure GPIO pins. // Set CS to 1 (inactive) GPIO_PinModeSet(gpioPortE, 13, gpioModePushPull, 1); GPIO_PinModeSet(gpioPortE, 10, gpioModePushPull, 0); GPIO_PinModeSet(gpioPortE, 12, gpioModePushPull, 0); GPIO_PinModeSet(gpioPortE, 11, gpioModeInput, 0); // Configure SPI. USART_Reset(USART0); USART_InitSync(USART0, &spiConfig); USART0->ROUTE = USART_ROUTE_TXPEN | USART_ROUTE_RXPEN | USART_ROUTE_CLKPEN | USART_ROUTE_LOCATION_LOC0; #ifdef ENC28J60_USE_INTERRUPTS // Configure UEXT enc28j60 interrupt line. CMU_ClockEnable(cmuClock_GPIO, true); GPIO_PinModeSet(gpioPortD, 7, gpioModeInputPullFilter, 1); GPIO_IntConfig(gpioPortD, 7, false, true, true); NVIC_EnableIRQ(GPIO_ODD_IRQn); NVIC_SetPriority(GPIO_ODD_IRQn, PORT_PENDSV_PRI - 1); #endif }