//!
//! \return none
//!
//! \brief Initializes Push Button Ports and Pins
//
//*****************************************************************************
void Button_IF_Init(P_INT_HANDLER S2InterruptHdl,P_INT_HANDLER S3InterruptHdl )
{
//
// Set Interrupt Type for GPIO
//
MAP_GPIOIntTypeSet(GPIOA1_BASE,GPIO_PIN_5,GPIO_FALLING_EDGE);
MAP_GPIOIntTypeSet(GPIOA2_BASE,GPIO_PIN_6,GPIO_FALLING_EDGE);
g_S3InterruptHdl = S3InterruptHdl;
g_S2InterruptHdl = S2InterruptHdl;
//
// Register Interrupt handler
//
osi_InterruptRegister(INT_GPIOA1,(P_OSI_INTR_ENTRY)GPIOs3IntHandler, INT_PRIORITY_LVL_1);
osi_InterruptRegister(INT_GPIOA2,(P_OSI_INTR_ENTRY)GPIOs2IntHandler, INT_PRIORITY_LVL_1);
//
// Enable Interrupt
//
MAP_GPIOIntClear(GPIOA1_BASE,GPIO_PIN_5);
MAP_GPIOIntEnable(GPIOA1_BASE,GPIO_INT_PIN_5);
MAP_GPIOIntClear(GPIOA2_BASE,GPIO_PIN_6);
MAP_GPIOIntEnable(GPIOA2_BASE,GPIO_INT_PIN_6);
}
//****************************************************************************
//
//! Main function
//!
//! \param none
//!
//! This function
//! 1. Configures the GPIOA1 and A2 interrupt.
//!
//! \return None.
//
//****************************************************************************
int main() {
//
// Initialize Board configurations
//
BoardInit();
//
// Power on the corresponding GPIO port B for 9,10,11.
// Set up the GPIO lines to mode 0 (GPIO)
//
PinMuxConfig();
//
// Configure the GPIO13 - SW2 interrupt
//
MAP_GPIOIntRegister(GPIOA1_BASE, GPIOA1IntHandler);
MAP_GPIOIntTypeSet(GPIOA1_BASE, GPIO_PIN_5, GPIO_RISING_EDGE);
//
// Configure the GPIO22 interrupt
//
MAP_GPIOIntRegister(GPIOA2_BASE, GPIOA2IntHandler);
MAP_GPIOIntTypeSet(GPIOA2_BASE, GPIO_PIN_6, GPIO_RISING_EDGE);
//
// Enable GPIO13 Interrupt
//
MAP_GPIOIntClear(GPIOA1_BASE, GPIO_PIN_5);
MAP_IntPendClear(INT_GPIOA1);
MAP_IntEnable(INT_GPIOA1);
MAP_GPIOIntEnable(GPIOA1_BASE, GPIO_PIN_5);
//
// Enable GPIO22 Interrupt
//
MAP_GPIOIntClear(GPIOA2_BASE, GPIO_PIN_6);
MAP_IntPendClear(INT_GPIOA2);
MAP_IntEnable(INT_GPIOA2);
MAP_GPIOIntEnable(GPIOA2_BASE, GPIO_PIN_6);
//
// Infinite loop. All processing happens now in the interrupt handler.
while (1) {
}
return 0;
}
//****************************************************************************
//
//! Configures the GPIO selected as input to generate interrupt on activity
//!
//! \param uiGPIOPort is the GPIO port address
//! \param ucGPIOPin is the GPIO pin of the specified port
//! \param uiIntType is the type of the interrupt (refer gpio.h)
//! \param pfnIntHandler is the interrupt handler to register
//!
//! This function
//! 1. Sets GPIO interrupt type
//! 2. Registers Interrupt handler
//! 3. Enables Interrupt
//!
//! \return None
//
//****************************************************************************
void
GPIO_IF_ConfigureNIntEnable(unsigned int uiGPIOPort,
unsigned char ucGPIOPin,
unsigned int uiIntType,
void (*pfnIntHandler)(void))
{
//
// Set GPIO interrupt type
//
MAP_GPIOIntTypeSet(uiGPIOPort,ucGPIOPin,uiIntType);
//
// Register Interrupt handler
//
#ifdef USE_TIRTOS
osi_InterruptRegister(GetPeripheralIntNum(uiGPIOPort),
pfnIntHandler, INT_PRIORITY_LVL_1);
#else
MAP_GPIOIntRegister(uiGPIOPort,pfnIntHandler);
#endif
//
// Enable Interrupt
//
MAP_GPIOIntClear(uiGPIOPort,ucGPIOPin);
MAP_GPIOIntEnable(uiGPIOPort,ucGPIOPin);
}
//****************************************************************************
//
//! Configures the GPIO selected as input to generate interrupt on activity
//!
//! \param uiGPIOPort is the GPIO port address
//! \param ucGPIOPin is the GPIO pin of the specified port
//! \param uiIntType is the type of the interrupt (refer gpio.h)
//! \param pfnIntHandler is the interrupt handler to register
//!
//! This function
//! 1. Sets GPIO interrupt type
//! 2. Registers Interrupt handler
//! 3. Enables Interrupt
//!
//! \return None
//
//****************************************************************************
void
GPIO_IF_ConfigureNIntEnable(unsigned int uiGPIOPort,
unsigned char ucGPIOPin,
unsigned int uiIntType,
void (*pfnIntHandler)(void))
{
//
// Set GPIO interrupt type
//
MAP_GPIOIntTypeSet(uiGPIOPort,ucGPIOPin,uiIntType);
//
// Register Interrupt handler
//
#if defined(USE_TIRTOS) || defined(USE_FREERTOS) || defined(SL_PLATFORM_MULTI_THREADED)
// USE_TIRTOS: if app uses TI-RTOS (either networking/non-networking)
// USE_FREERTOS: if app uses Free-RTOS (either networking/non-networking)
// SL_PLATFORM_MULTI_THREADED: if app uses any OS + networking(simplelink)
osi_InterruptRegister(GetPeripheralIntNum(uiGPIOPort),
pfnIntHandler, INT_PRIORITY_LVL_1);
#else
MAP_IntPrioritySet(GetPeripheralIntNum(uiGPIOPort), INT_PRIORITY_LVL_1);
MAP_GPIOIntRegister(uiGPIOPort,pfnIntHandler);
#endif
//
// Enable Interrupt
//
MAP_GPIOIntClear(uiGPIOPort,ucGPIOPin);
MAP_GPIOIntEnable(uiGPIOPort,ucGPIOPin);
}
STATIC void pin_irq_enable (mp_obj_t self_in) {
const pin_obj_t *self = self_in;
uint hib_pin, idx;
pin_get_hibernate_pin_and_idx (self, &hib_pin, &idx);
if (idx < PYBPIN_NUM_WAKE_PINS) {
if (pybpin_wake_pin[idx].lpds != PYBPIN_WAKES_NOT) {
// enable GPIO as a wake source during LPDS
MAP_PRCMLPDSWakeUpGPIOSelect(idx, pybpin_wake_pin[idx].lpds);
MAP_PRCMLPDSWakeupSourceEnable(PRCM_LPDS_GPIO);
}
if (pybpin_wake_pin[idx].hib != PYBPIN_WAKES_NOT) {
// enable GPIO as a wake source during hibernate
MAP_PRCMHibernateWakeUpGPIOSelect(hib_pin, pybpin_wake_pin[idx].hib);
MAP_PRCMHibernateWakeupSourceEnable(hib_pin);
}
else {
MAP_PRCMHibernateWakeupSourceDisable(hib_pin);
}
}
// if idx is invalid, the pin supports active interrupts for sure
if (idx >= PYBPIN_NUM_WAKE_PINS || pybpin_wake_pin[idx].active) {
MAP_GPIOIntClear(self->port, self->bit);
MAP_GPIOIntEnable(self->port, self->bit);
}
// in case it was enabled before
else if (idx < PYBPIN_NUM_WAKE_PINS && !pybpin_wake_pin[idx].active) {
MAP_GPIOIntDisable(self->port, self->bit);
}
}
void Button_IF_DisableInterrupt(unsigned char ucSwitch)
{
if(ucSwitch & SW2)
{
//Clear and Disable GPIO Interrupt
MAP_GPIOIntDisable(GPIOA2_BASE,GPIO_PIN_6);
MAP_GPIOIntClear(GPIOA2_BASE,GPIO_PIN_6);
MAP_IntDisable(INT_GPIOA2);
}
if(ucSwitch & SW3)
{
//Clear and Disable GPIO Interrupt
MAP_GPIOIntDisable(GPIOA1_BASE,GPIO_PIN_5);
MAP_GPIOIntClear(GPIOA1_BASE,GPIO_PIN_5);
MAP_IntDisable(INT_GPIOA1);
}
}
//!
//! \return 0 - Success
//! -1 - Error
//!
//! \brief Initializes Audio Player Push Button Controls
//
//*****************************************************************************
long InitControl(P_AUDIO_HANDLER pAudioInControl,P_AUDIO_HANDLER pAudioOutControl)
{
long lRetVal = -1;
//
// Set Interrupt Type for GPIO
//
MAP_GPIOIntTypeSet(GPIOA1_BASE,GPIO_PIN_5,GPIO_FALLING_EDGE);
MAP_GPIOIntTypeSet(GPIOA2_BASE,GPIO_PIN_6,GPIO_FALLING_EDGE);
//
// Store Interrupt handlers
//
g_pAudioInControlHdl = pAudioInControl;
g_pAudioOutControlHdl = pAudioOutControl;
//
// Register Interrupt handler
//
lRetVal = osi_InterruptRegister(INT_GPIOA1,(P_OSI_INTR_ENTRY)MICButtonHandler,\
INT_PRIORITY_LVL_1);
ASSERT_ON_ERROR(lRetVal);
lRetVal = osi_InterruptRegister(INT_GPIOA2,(P_OSI_INTR_ENTRY) \
SpeakerButtonHandler,INT_PRIORITY_LVL_1);
ASSERT_ON_ERROR(lRetVal);
//
// Enable Interrupt
//
MAP_GPIOIntClear(GPIOA1_BASE,GPIO_PIN_5);
MAP_GPIOIntEnable(GPIOA1_BASE,GPIO_INT_PIN_5);
MAP_GPIOIntClear(GPIOA2_BASE,GPIO_PIN_6);
MAP_GPIOIntEnable(GPIOA2_BASE,GPIO_INT_PIN_6);
return SUCCESS;
}
//*****************************************************************************
//
//! MicroPhone Control Routine
//!
//! \param pValue - pointer to a memory structure that is passed
//! to the interrupt handler.
//!
//! \return None
//
//*****************************************************************************
void MicroPhoneControl(void* pValue)
{
int iCount=0;
unsigned long ulPin5Val = 1;
//Check whether GPIO Level is Stable As No Debouncing Circuit in LP
for(iCount=0;iCount<3;iCount++)
{
osi_Sleep(200);
ulPin5Val = MAP_GPIOPinRead(GPIOA1_BASE,GPIO_PIN_5);
if(ulPin5Val)
{
//False Alarm
return;
}
}
if (g_ucMicStartFlag == 0)
{
for(iCount = 0; iCount<3; iCount++)
{
//Blink LED 3 times to Indicate ON
GPIO_IF_LedOff(MCU_GREEN_LED_GPIO);
osi_Sleep(50);
GPIO_IF_LedOn(MCU_GREEN_LED_GPIO);
osi_Sleep(50);
}
g_ucMicStartFlag = 1;
}
else
{
//Blink LED 3 times to Indicate OFF
for(iCount = 0; iCount<3; iCount++)
{
GPIO_IF_LedOn(MCU_GREEN_LED_GPIO);
osi_Sleep(50);
GPIO_IF_LedOff(MCU_GREEN_LED_GPIO);
osi_Sleep(50);
}
g_ucMicStartFlag = 0;
}
//Enable GPIO Interrupt
MAP_GPIOIntClear(GPIOA1_BASE,GPIO_PIN_5);
MAP_IntPendClear(INT_GPIOA1);
MAP_IntEnable(INT_GPIOA1);
MAP_GPIOIntEnable(GPIOA1_BASE,GPIO_PIN_5);
}
// common interrupt handler
STATIC void EXTI_Handler(uint port) {
uint32_t bits = MAP_GPIOIntStatus(port, true);
MAP_GPIOIntClear(port, bits);
// might be that we have more than one Pin interrupt pending
// therefore we must loop through all of the 8 possible bits
for (int i = 0; i < 8; i++) {
uint32_t bit = (1 << i);
if (bit & bits) {
pin_obj_t *self = (pin_obj_t *)pin_find_pin_by_port_bit(&pin_cpu_pins_locals_dict, port, bit);
mp_obj_t _callback = mpcallback_find(self);
mpcallback_handler(_callback);
}
}
}
//*****************************************************************************
//
//! GPIO Interrupt Handler for S2 button
//!
//! \param None
//!
//! \return None
//
//*****************************************************************************
static void SpeakerButtonHandler()
{
unsigned long ulPinState = GPIOIntStatus(GPIOA2_BASE,1);
if(ulPinState & GPIO_PIN_6)
{
//Clear and Disable GPIO Interrupt
MAP_GPIOIntDisable(GPIOA2_BASE,GPIO_PIN_6);
MAP_GPIOIntClear(GPIOA2_BASE,GPIO_PIN_6);
MAP_IntDisable(INT_GPIOA2);
//Call Speaker Handler
if(g_pAudioOutControlHdl)
{
g_pAudioOutControlHdl();
}
}
}
// common interrupt handler
STATIC void EXTI_Handler(uint port) {
uint32_t bits = MAP_GPIOIntStatus(port, true);
MAP_GPIOIntClear(port, bits);
// might be that we have more than one pin interrupt pending
// therefore we must loop through all of the 8 possible bits
for (int i = 0; i < 8; i++) {
uint32_t bit = (1 << i);
if (bit & bits) {
pin_obj_t *self = (pin_obj_t *)pin_find_pin_by_port_bit(&pin_board_pins_locals_dict, port, bit);
if (self->irq_trigger == (PYB_PIN_FALLING_EDGE | PYB_PIN_RISING_EDGE)) {
// read the pin value (hoping that the pin level has remained stable)
self->irq_flags = MAP_GPIOPinRead(self->port, self->bit) ? PYB_PIN_RISING_EDGE : PYB_PIN_FALLING_EDGE;
} else {
// same as the triggers
self->irq_flags = self->irq_trigger;
}
mp_irq_handler(mp_irq_find(self));
// always clear the flags after leaving the user handler
self->irq_flags = 0;
}
}
}
//*****************************************************************************
//
// Called by the NVIC as a result of GPIO port S interrupt event. For this
// application GPIO port S pin 2 is the interrupt line for the MPU9150
//
//*****************************************************************************
void
GPIOSIntHandler(void)
{
uint32_t ui32Status;
ui32Status = MAP_GPIOIntStatus(GPIO_PORTS_BASE, true);
//
// Clear all the pin interrupts that are set
//
MAP_GPIOIntClear(GPIO_PORTS_BASE, ui32Status);
//
// Check which GPIO caused the interrupt event.
//
if(ui32Status & GPIO_PIN_2) {
//
// The MPU9150 data ready pin was asserted so start an I2C transfer
// to go get the latest data from the device.
//
MPU9150DataRead(&g_sMPU9150Inst, MotionCallback, &g_sMPU9150Inst);
}
}
//*****************************************************************************
//
//! Handles the GPIO A1 - SW3 - interrupt. Will turn off the red led.
//!
//! \param None
//!
//! This function
//! 1. Turns the red led off.
//!
//! \return None
//
//*****************************************************************************
void GPIOA1IntHandler(void) {
MAP_GPIOIntClear(GPIOA1_BASE, GPIO_PIN_5);
MAP_GPIOPinWrite(GPIOA1_BASE, GPIO_PIN_1, 0);
}
//*****************************************************************************
//
//! Handles the GPIO A2 - SW2 - interrupt. Will turn on the red led.
//!
//! \param None
//!
//! This function
//! 1. Turns the red led on.
//!
//! \return None
//
//*****************************************************************************
void GPIOA2IntHandler(void) {
MAP_GPIOIntClear(GPIOA2_BASE, GPIO_PIN_6);
MAP_GPIOPinWrite(GPIOA1_BASE, GPIO_PIN_1, GPIO_PIN_1);
}
void SpeakerControl(void* pValue)
{
int iCount=0;
unsigned long ulPin6Val = 1;
long lRetVal = -1;
//Check whether GPIO Level is Stable As No Debouncing Circuit in LP
for(iCount=0;iCount<3;iCount++)
{
osi_Sleep(200);
ulPin6Val = MAP_GPIOPinRead(GPIOA2_BASE,GPIO_PIN_6);
if(ulPin6Val)
{
//False Alarm
return;
}
}
if (g_ucSpkrStartFlag == 0)
{
#ifndef MULTICAST
//Un Register mDNS Service.
lRetVal = sl_NetAppMDNSUnRegisterService((signed char *)CC3200_MDNS_NAME,\
(unsigned char)strlen((const char *)CC3200_MDNS_NAME));
if(lRetVal < 0)
{
UART_PRINT("Unable to unregister MDNS service\n\r");
}
//Registering for the mDNS service.
lRetVal = sl_NetAppMDNSRegisterService((signed char *)CC3200_MDNS_NAME, \
(unsigned char)strlen((const char *)CC3200_MDNS_NAME),\
(signed char *)"multicast",\
(unsigned char)strlen((const char *)"multicast"),\
AUDIO_PORT,1000,0);
if(lRetVal < 0)
{
UART_PRINT("Unable to register MDNS service\n\r");
LOOP_FOREVER();
}
#endif
//Blink LED 3 times to Indicate ON
for(iCount = 0; iCount<3; iCount++)
{
GPIO_IF_LedOff(MCU_ORANGE_LED_GPIO);
osi_Sleep(50);
GPIO_IF_LedOn(MCU_ORANGE_LED_GPIO);
osi_Sleep(50);
}
g_ucSpkrStartFlag = 1;
}
else
{
//Un Register mDNS Service.
lRetVal = sl_NetAppMDNSUnRegisterService((signed char *)CC3200_MDNS_NAME,\
(unsigned char)strlen((const char *)CC3200_MDNS_NAME));
if(lRetVal < 0)
{
UART_PRINT("Unable to unregister MDNS service\n\r");
}
//Blink LED 3 times to Indicate OFF
for(iCount = 0; iCount<3; iCount++)
{
GPIO_IF_LedOn(MCU_ORANGE_LED_GPIO);
osi_Sleep(50);
GPIO_IF_LedOff(MCU_ORANGE_LED_GPIO);
osi_Sleep(50);
}
g_ucSpkrStartFlag = 0;
}
//Enable GPIO Interrupt
MAP_GPIOIntClear(GPIOA2_BASE,GPIO_PIN_6);
MAP_IntPendClear(INT_GPIOA2);
MAP_IntEnable(INT_GPIOA2);
MAP_GPIOIntEnable(GPIOA2_BASE,GPIO_PIN_6);
}
