//!
//! \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_EnableInterrupt(unsigned char ucSwitch)
{
if(ucSwitch & SW2)
{
//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);
}
if(ucSwitch & SW3)
{
//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);
}
}
//!
//! \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);
}
//*****************************************************************************
//
// Initialize the I2C, MPU9150 and Gesture systems.
//
//*****************************************************************************
void
MotionInit(void)
{
//
// Enable port S used for motion interrupt.
//
MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOS);
//
// The I2C3 peripheral must be enabled before use.
//
MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_I2C3);
MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOG);
//
// Configure the pin muxing for I2C3 functions on port G4 and G5.
//
MAP_GPIOPinConfigure(GPIO_PG4_I2C3SCL);
MAP_GPIOPinConfigure(GPIO_PG5_I2C3SDA);
//
// Select the I2C function for these pins. This function will also
// configure the GPIO pins pins for I2C operation, setting them to
// open-drain operation with weak pull-ups. Consult the data sheet
// to see which functions are allocated per pin.
//
MAP_GPIOPinTypeI2CSCL(GPIO_PORTG_BASE, GPIO_PIN_4);
MAP_GPIOPinTypeI2C(GPIO_PORTG_BASE, GPIO_PIN_5);
//
// Configure and Enable the GPIO interrupt. Used for INT signal from the
// MPU9150
//
MAP_GPIOPinTypeGPIOInput(GPIO_PORTS_BASE, GPIO_PIN_2);
MAP_GPIOIntEnable(GPIO_PORTS_BASE, GPIO_PIN_2);
MAP_GPIOIntTypeSet(GPIO_PORTS_BASE, GPIO_PIN_2, GPIO_FALLING_EDGE);
MAP_IntEnable(INT_GPIOS);
//
// Enable interrupts to the processor.
//
MAP_IntMasterEnable();
//
// Initialize I2C3 peripheral.
//
I2CMInit(&g_sI2CInst, I2C3_BASE, INT_I2C3, 0xff, 0xff,
g_ui32SysClock);
//
// Set the motion state to initializing.
//
g_ui8MotionState = MOTION_STATE_INIT;
//
// Initialize the MPU9150 Driver.
//
MPU9150Init(&g_sMPU9150Inst, &g_sI2CInst, MPU9150_I2C_ADDRESS,
MotionCallback, &g_sMPU9150Inst);
//
// Wait for transaction to complete
//
MotionI2CWait(__FILE__, __LINE__);
//
// Write application specifice sensor configuration such as filter settings
// and sensor range settings.
//
g_sMPU9150Inst.pui8Data[0] = MPU9150_CONFIG_DLPF_CFG_94_98;
g_sMPU9150Inst.pui8Data[1] = MPU9150_GYRO_CONFIG_FS_SEL_250;
g_sMPU9150Inst.pui8Data[2] = (MPU9150_ACCEL_CONFIG_ACCEL_HPF_5HZ |
MPU9150_ACCEL_CONFIG_AFS_SEL_2G);
MPU9150Write(&g_sMPU9150Inst, MPU9150_O_CONFIG, g_sMPU9150Inst.pui8Data, 3,
MotionCallback, &g_sMPU9150Inst);
//
// Wait for transaction to complete
//
MotionI2CWait(__FILE__, __LINE__);
//
// Configure the data ready interrupt pin output of the MPU9150.
//
g_sMPU9150Inst.pui8Data[0] = (MPU9150_INT_PIN_CFG_INT_LEVEL |
MPU9150_INT_PIN_CFG_INT_RD_CLEAR |
MPU9150_INT_PIN_CFG_LATCH_INT_EN);
g_sMPU9150Inst.pui8Data[1] = MPU9150_INT_ENABLE_DATA_RDY_EN;
MPU9150Write(&g_sMPU9150Inst, MPU9150_O_INT_PIN_CFG,
g_sMPU9150Inst.pui8Data, 2, MotionCallback, &g_sMPU9150Inst);
//
// Wait for transaction to complete
//
MotionI2CWait(__FILE__, __LINE__);
//
// Initialize the DCM system.
//
CompDCMInit(&g_sCompDCMInst, 1.0f / ((float) MOTION_SAMPLE_FREQ_HZ),
DCM_ACCEL_WEIGHT, DCM_GYRO_WEIGHT, DCM_MAG_WEIGHT);
//
// Initialize the gesture instance and establish a initial state estimate.
//
GestureInit(&g_sGestureInst, g_pfInitProb, g_ppfPath, g_ppfTransitionProb,
g_ppfEmitProb, GESTURE_PATH_LENGTH, GESTURE_NUM_STATES,
GESTURE_STATE_IDLE);
}
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);
}
/*
* initialize tm4c
*/
void init_satellite()
{
FPUEnable();
FPULazyStackingEnable();
/*
* init clock
*/
MAP_SysCtlClockSet(SYSCTL_SYSDIV_3 | SYSCTL_USE_PLL | SYSCTL_XTAL_16MHZ | SYSCTL_OSC_MAIN); //66.6..MHz
MAP_IntMasterEnable();
/*
* Enable peripherals
*/
MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF); //for LED indication
MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA); //for UART
MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0);
MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB); //for IRQ and SW_EN
MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOE); //for SPI
/*
* configure
*/
MAP_GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE, GPIO_PIN_1|GPIO_PIN_2|GPIO_PIN_3);
MAP_GPIOPinWrite(GPIO_PORTF_BASE, GPIO_PIN_1|GPIO_PIN_2|GPIO_PIN_3, SIGNAL_LOW); //off
MAP_GPIOPinConfigure(GPIO_PA0_U0RX);
MAP_GPIOPinConfigure(GPIO_PA1_U0TX);
MAP_GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1);
UARTStdioConfig(UART_PORT, UART_BAUDRATE, SysCtlClockGet());
MAP_GPIOIntDisable(GPIO_PORTB_BASE, SIGNAL_HIGH); //interrupt disable
MAP_GPIOPinTypeGPIOInput(GPIO_PORTB_BASE, GPIO_PIN_2); //IRQ as input
MAP_GPIOPadConfigSet(GPIO_PORTB_BASE, GPIO_PIN_2, GPIO_STRENGTH_2MA, GPIO_PIN_TYPE_STD_WPU);
MAP_GPIOIntTypeSet(GPIO_PORTB_BASE, GPIO_PIN_2, GPIO_FALLING_EDGE); //enable interrupt
MAP_GPIOPinTypeGPIOOutput(GPIO_PORTB_BASE, GPIO_PIN_5); //sw enable
MAP_GPIODirModeSet(GPIO_PORTB_BASE, GPIO_PIN_5, GPIO_DIR_MODE_OUT);
MAP_GPIOPadConfigSet(GPIO_PORTB_BASE, GPIO_PIN_5, GPIO_STRENGTH_2MA, GPIO_PIN_TYPE_STD_WPD);
MAP_GPIOPinWrite(GPIO_PORTB_BASE, GPIO_PIN_5, SIGNAL_LOW);
MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOE);
MAP_GPIOPinTypeGPIOOutput(GPIO_PORTE_BASE, GPIO_PIN_0);
MAP_GPIOPadConfigSet(GPIO_PORTE_BASE, GPIO_PIN_0, GPIO_STRENGTH_2MA, GPIO_PIN_TYPE_STD_WPU);
MAP_GPIOPinWrite(GPIO_PORTE_BASE, GPIO_PIN_0, SIGNAL_HIGH); //chip select
MAP_GPIOIntEnable(GPIO_PORTB_BASE, GPIO_PIN_2); //enable interrupt for WLAN_IRQ pin
SpiCleanGPIOISR(); //clear interrupt status
MAP_IntEnable(INT_GPIOB); //spi
init_worker();
setState(READY);
}
