void mode2unset()
{
GPIOIntClear(GPIO_PORTF_BASE, GPIO_PIN_4); //Clear any existing interrupts
GPIOIntDisable(GPIO_PORTF_BASE, GPIO_PIN_4); //Enable the GPIO Interrupts on Port F
IntDisable(INT_TIMER1A);
TimerIntDisable(TIMER1_BASE,TIMER_TIMA_TIMEOUT);
}
void CC3100_InterruptDisable()
{
GPIOIntDisable(CC3100_IRQBASE,CC3100_IRQPIN);
#ifdef SL_IF_TYPE_UART
ROM_UARTIntDisable(CC3100_UARTBASE, UART_INT_RX);
#endif
}
void GPIOIntHandler(){
//THis function is called when a button on the remote is pressed
//Disables the GPIO interrupt
GPIOIntDisable(GPIOA1_BASE, 0x10);
//Enables Systick
SysTickEnable();
}
/*****************************************************
* Function: init_BtnHandler
* Description: Initializes button interrupt
* Initializes timer for button counter
* Input: NONE
* Output: NONE
*****************************************************/
void init_BtnHandler(void)
{
// Unlock un-maskable pin
HWREG(BTN_OVERRIDE_REG + GPIO_O_LOCK) = GPIO_LOCK_KEY;
// Set up our interrupt for button presses
IntMasterDisable(); // Disable all interrupts
GPIOIntDisable(BTN_OVERRIDE_REG, BTN_OVERRIDE);
GPIOPinTypeGPIOInput(BTN_OVERRIDE_REG, BTN_OVERRIDE);
GPIOPadConfigSet(BTN_OVERRIDE_REG, BTN_OVERRIDE, GPIO_STRENGTH_4MA, GPIO_PIN_TYPE_STD_WPU); // Set Pull-up
GPIOIntTypeSet(BTN_OVERRIDE_REG, BTN_OVERRIDE, GPIO_BOTH_EDGES); // Set edge to trigger on
GPIOIntClear(BTN_OVERRIDE_REG, BTN_OVERRIDE); // Clear the interrupt bit
GPIOIntEnable(BTN_OVERRIDE_REG, BTN_OVERRIDE); // Enable the interrupt
IntEnable(INT_GPIOE);
// Lock un-maskable pin
HWREG(BTN_OVERRIDE_REG + GPIO_O_LOCK) = 0;
// Setup timer interrupt for button pressing
// This timer will run up and when it is released we will check how long it was running
SysCtlPeripheralEnable(SYSCTL_PERIPH_TIMER0);
TimerConfigure(BTN_OVERRIDE_TIM_BASE, TIMER_CFG_PERIODIC); // Setup interrupt as 32 bit timer counting up
TimerLoadSet(BTN_OVERRIDE_TIM_BASE, BTN_OVERRIDE_TIM, clockTime/1000); // Load Timer
IntEnable(INT_TIMER0A);
TimerIntEnable(BTN_OVERRIDE_TIM_BASE, TIMER_TIMA_TIMEOUT);
// Turn the input pin to the button high
GPIOPinTypeGPIOOutput(BTN_OVERRIDE_CONTROL_REG, BTN_OVERRIDE_CONTROL);
GPIOPinWrite(BTN_OVERRIDE_CONTROL_REG, BTN_OVERRIDE_CONTROL, BTN_OVERRIDE_CONTROL);
}
void spi_gpio_init(uint8_t int_flag)
{
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF);
//F0-----MISO ----- INPUT
ROM_GPIOPinTypeGPIOInput(GPIO_PORTF_BASE, GPIO_PIN_0);
//F1，F2，F3：MOSI,CLK，CSN ----- OUTPUT
ROM_GPIOPinTypeGPIOOutput(GPIO_PORTF_BASE, GPIO_PIN_1 | GPIO_PIN_2 | GPIO_PIN_3);
//CE-----PA6 ----- OUTPUT
ROM_GPIOPinTypeGPIOOutput(GPIO_PORTA_BASE, GPIO_PIN_6);
//IRQ-----PA7 ----- INPUT
ROM_GPIOPinTypeGPIOInput(GPIO_PORTA_BASE, GPIO_PIN_7);
if(int_flag == 1) //开引脚外部中断
{
GPIOIntTypeSet(GPIO_PORTA_BASE,GPIO_PIN_7,GPIO_FALLING_EDGE);
GPIOIntEnable(GPIO_PORTA_BASE,GPIO_INT_PIN_7); //打开PA7外部中断进行数据读取
GPIOIntRegister(GPIO_PORTA_BASE, PA7_int_hander);//指定外部中断处理函数
}
else
{
GPIOIntDisable(GPIO_PORTA_BASE,GPIO_INT_PIN_7);
}
}
/*
* ======== WiFiCC3100_close ========
*/
void WiFiCC3100_close(WiFi_Handle handle)
{
unsigned int key;
WiFiCC3100_Object *object = handle->object;
WiFiCC3100_HWAttrs const *hwAttrs = handle->hwAttrs;
#if defined(MSP430WARE) || defined(MSP432WARE)
MAP_GPIO_disableInterrupt(hwAttrs->irqPort, hwAttrs->irqPin);
#else
GPIOIntDisable(hwAttrs->irqPort, hwAttrs->irqPin);
#endif
#if !defined(MSP430WARE)
Hwi_destruct(&(object->wifiHwi));
#endif
Semaphore_destruct(&(object->readSemaphore));
Semaphore_destruct(&(object->writeSemaphore));
Log_print0(Diags_USER1, "WiFi Object closed.");
key = Hwi_disable();
object->spiState = WiFiCC3100_SPI_UNINITIALIZED;
object->isOpen = false;
Hwi_restore(key);
}
void detachInterrupt(uint8_t interruptNum)
{
uint32_t i;
uint8_t bit = digitalPinToBitMask(interruptNum);
uint8_t port = digitalPinToPort(interruptNum);
uint32_t portBase = (uint32_t) portBASERegister(port);
if (port == NOT_A_PIN) return;
GPIOIntDisable(portBase, bit);
for (i=0; i<8; i++, bit>>=1) {
if ((bit & 0x1) == 1)
break;
}
switch(portBase) {
case GPIO_PORTA_BASE:
cbFuncsA[i] = 0;
case GPIO_PORTB_BASE:
cbFuncsB[i] = 0;
case GPIO_PORTC_BASE:
cbFuncsC[i] = 0;
case GPIO_PORTD_BASE:
cbFuncsD[i] = 0;
case GPIO_PORTE_BASE:
cbFuncsE[i] = 0;
case GPIO_PORTF_BASE:
cbFuncsF[i] = 0;
case GPIO_PORTG_BASE:
cbFuncsG[i] = 0;
case GPIO_PORTH_BASE:
cbFuncsH[i] = 0;
case GPIO_PORTJ_BASE:
cbFuncsJ[i] = 0;
case GPIO_PORTK_BASE:
cbFuncsK[i] = 0;
case GPIO_PORTL_BASE:
cbFuncsL[i] = 0;
case GPIO_PORTM_BASE:
cbFuncsM[i] = 0;
case GPIO_PORTN_BASE:
cbFuncsN[i] = 0;
case GPIO_PORTP_BASE:
cbFuncsP[i] = 0;
case GPIO_PORTQ_BASE:
cbFuncsQ[i] = 0;
#ifdef TARGET_IS_SNOWFLAKE_RA0
case GPIO_PORTR_BASE:
cbFuncsR[i] = 0;
case GPIO_PORTS_BASE:
cbFuncsS[i] = 0;
case GPIO_PORTT_BASE:
cbFuncsT[i] = 0;
#endif
}
}
void Interrupt_PB3Init(void)
{
GPIOIntRegister(GPIO_PORTB_BASE,Interrupt_PB3Handler);
ROM_GPIOPinTypeGPIOInput(GPIO_PORTB_BASE, GPIO_PIN_3);
ROM_GPIOPadConfigSet(GPIO_PORTB_BASE,GPIO_PIN_3,GPIO_STRENGTH_2MA,GPIO_PIN_TYPE_STD_WPU);
GPIOIntDisable(GPIO_PORTB_BASE,GPIO_INT_PIN_3);
GPIOIntClear(GPIO_PORTB_BASE,GPIO_INT_PIN_3);
GPIOIntTypeSet(GPIO_PORTB_BASE,GPIO_INT_PIN_3,GPIO_LOW_LEVEL);
}
/**
* @brief calculate time between sucessive AC trigger pulses, or read a DC signal,
* depending on configuration, return trigger status if signal is valid
*
* @return TRIGGER_ACTIVE or NO_TRIGGER
* */
int trigInputRead(void)
{
int ret = NO_TRIGGER;
#ifdef TRIG_ON_AC
/* atomic section, no IRQ's while calculating */
GPIOIntDisable( TRIG_IN_PORT_1, TRIG_IN_PIN_1);
GPIOIntDisable( TRIG_IN_PORT_2, TRIG_IN_PIN_2);
/* any changes wich is not noise ?*/
if ((timeEdge1 - timeLast1) > TRIG_TIME_MS_MIN)
{
//GPIOSetValue( 1, 11, 1);
ret |= TRIGGER1_ACTIVE;
/* allign timers */
timeEdge1 = millis();
timeLast1 =timeEdge1;
//GPIOSetValue( 1, 11, 0);
}
/* any changes wich is not noise ?*/
if ((timeEdge2 - timeLast2) > TRIG_TIME_MS_MAX)
{
ret |= TRIGGER2_ACTIVE;
timeEdge2 = millis();
timeLast2 =timeEdge2;
}
GPIOIntEnable( TRIG_IN_PORT_1, TRIG_IN_PIN_1);
GPIOIntEnable( TRIG_IN_PORT_2, TRIG_IN_PIN_2);
/* atomic section ends here */
#endif
//#ifdef TRIG_ON_DC
#if 0
/* if trigger is low, we have DC*/
if (!(LPC_GPIO_PORT->PIN0 & TRIG_IN_PIN))
{
return TRIGGER_ACTIVE;
}
#endif
return ret;
}
void interrupt_setup(void)
{
// Interrupt setuü
GPIOIntDisable(GPIO_PORTF_BASE, GPIO_PIN_4); // Disable interrupt for PF4 (in case it was enabled)
GPIOIntClear(GPIO_PORTF_BASE, GPIO_PIN_4); // Clear pending interrupts for PF4
GPIOIntRegister(GPIO_PORTF_BASE, onButtonDown); // Register our handler function for port F
GPIOIntTypeSet(GPIO_PORTF_BASE, GPIO_PIN_4,
GPIO_FALLING_EDGE); // Configure PF4 for falling edge trigger
GPIOIntEnable(GPIO_PORTF_BASE, GPIO_PIN_4); // Enable interrupt for PF4
}
void Timer4ISR(void) {
/// pulisce le interruzione del timer4
ROM_TimerIntClear(TIMER4_BASE, TIMER_TIMA_TIMEOUT);
/// disabilita la porta D a generare interruzioni
GPIOIntDisable(GPIO_PORTD_BASE, GPIO_INT_PIN_1);
/// disabilita il timer 4
TimerDisable(TIMER4_BASE, TIMER_A);
/// segnala lo scadere del timer
procCom4 = 1;
/// spento il dispositivo
HWREG(GPIO_PORTD_BASE + (GPIO_O_DATA + (GPIO_PIN_0 << 2))) = 0;
}
void Interrupt_PB3Handler(void)
{
uint16_t x,y;
GPIOIntDisable(GPIO_PORTB_BASE,GPIO_INT_PIN_3);
IODevice_LaserOn(false);
TowerLight_ErrorMode();
LCD_ClearWindow();
LCD_DisplayWidget(ErrorWarning);
TouchPanel_GetPixel(&x,&y);
do
{
TouchPanel_GetPixel(&x,&y);
__Delay50ms();
}
while(y<200|y>280);
LCD_DisplayInterface(CurrentUI);
}
/*
* Initialize GPIO port to support SHT1X I/O operations.
* Data pin is set in weak pull-up configuration.
*
* Unlike AVR the TM4C123 does not allow to read actual logic level from
* output pins. That is why an addition SHT1X_DATA_IN_PIN is used.
*/
void sht1x_gpio_init(void)
{
SysCtlPeripheralEnable(SHT1X_GPIO_PERIPH);
GPIOIntDisable(SHT1X_PORT_BASE, SHT1X_DATA_INTERRUPT);
GPIOPinTypeGPIOOutput(SHT1X_PORT_BASE, SHT1X_CLOCK_PIN);
GPIOPinWrite(SHT1X_PORT_BASE, SHT1X_CLOCK_PIN, 0x00);
GPIODirModeSet(SHT1X_PORT_BASE, SHT1X_DATA_OUT_PIN, GPIO_DIR_MODE_OUT);
GPIOPadConfigSet(SHT1X_PORT_BASE, SHT1X_DATA_OUT_PIN, GPIO_STRENGTH_2MA, GPIO_PIN_TYPE_STD_WPU);
GPIOPinWrite(SHT1X_PORT_BASE, SHT1X_DATA_OUT_PIN, SHT1X_DATA_OUT_PIN);
GPIOPinTypeGPIOInput(SHT1X_PORT_BASE, SHT1X_DATA_IN_PIN);
GPIOIntTypeSet(SHT1X_PORT_BASE, SHT1X_DATA_IN_PIN, GPIO_FALLING_EDGE);
IntEnable(SHT1X_GPIO_INTERRUPT);
}
void SystickIntHandler(){
//Samples the voltage on pin 3
if (GPIOPinRead(GPIOA1_BASE, 0x10)){
//modify the bitsequence using logic AND
//Use bitwise operation here to save memory. Another option is to use an aray
bitsequence = bitsequence | (1LL << (64-index));
}
//Increments the next index of the bit in bitsequence to be modified
index++;
//Clear the GPIO interrupt
GPIOIntClear(GPIOA1_BASE, 0x10);
//Enables the GPIO interrupt
GPIOIntEnable(GPIOA1_BASE, 0x10);
if(index == 60)
{
//If 60 bits have been written, it's time to check what number on the remote the bit sequence reprensent.
SysTickDisable();
GPIOIntDisable(GPIOA1_BASE, 0x10);
}
}
void CC3100_InterruptDisable()
{
GPIOIntDisable(GPIO_PORTM_BASE,GPIO_PIN_7);
}
//*****************************************************************************
//
//! Prepare a pin for use with a TOF sensor.
//!
//! \param GPIOPin is on the pin for the TOF sensor.
//!
//! This function initializes the GPIO interrupts and peripherals necessary
//! to run the corresponding GPIO port.
//!
//! The \e GPIOPin parameter can take on the following values:
//!
//! - \b PA0 - Pin PA0
//! - \b PA1 - Pin PA1
//! - \b PA2 - Pin PA2
//! - \b PA3 - Pin PA3
//! - \b PA4 - Pin PA4
//! - \b PA5 - Pin PA5
//! - \b PA6 - Pin PA6
//! - \b PA7 - Pin PA7
//! - \b PB0 - Pin PB0
//! - \b PB1 - Pin PB1
//! - \b PB2 - Pin PB2
//! - \b PB3 - Pin PB3
//! - \b PB4 - Pin PB4
//! - \b PB5 - Pin PB5
//! - \b PB6 - Pin PB6
//! - \b PB7 - Pin PB7
//! - \b PC0 - Pin PC0
//! - \b PC1 - Pin PC1
//! - \b PC2 - Pin PC2
//! - \b PC3 - Pin PC3
//! - \b PC4 - Pin PC4
//! - \b PC5 - Pin PC5
//! - \b PC6 - Pin PC6
//! - \b PC7 - Pin PC7
//! - \b PD0 - Pin PD0
//! - \b PD1 - Pin PD1
//! - \b PD2 - Pin PD2
//! - \b PD3 - Pin PD3
//! - \b PD4 - Pin PD4
//! - \b PD5 - Pin PD5
//! - \b PD6 - Pin PD6
//! - \b PD7 - Pin PD7
//! - \b PE0 - Pin PE0
//! - \b PE1 - Pin PE1
//! - \b PE2 - Pin PE2
//! - \b PE3 - Pin PE3
//! - \b PE4 - Pin PE4
//! - \b PE5 - Pin PE5
//! - \b PE6 - Pin PE6
//! - \b PE7 - Pin PE7
//! - \b PF0 - Pin PF0
//! - \b PF1 - Pin PF1
//! - \b PF2 - Pin PF2
//! - \b PF3 - Pin PF3
//! - \b PF4 - Pin PF4
//! - \b PF5 - Pin PF5
//! - \b PF6 - Pin PF6
//! - \b PF7 - Pin PF7
//!
//! \return None.
//!
//*****************************************************************************
void
TOFEchoInit(uint8_t GPIOPin)
{
//
// Enable Peripheral Clocks
//
#ifdef USEPORTA
MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);
MAP_SysCtlDelay(3);
#endif
#ifdef USEPORTB
MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB);
MAP_SysCtlDelay(3);
#endif
#ifdef USEPORTC
MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOC);
MAP_SysCtlDelay(3);
#endif
#ifdef USEPORTD
MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOD);
MAP_SysCtlDelay(3);
#endif
#ifdef USEPORTE
MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOE);
MAP_SysCtlDelay(3);
#endif
#ifdef USEPORTF
MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF);
MAP_SysCtlDelay(3);
#endif
switch(GPIOPin){
#ifdef USEPORTA
//Puerto A
#ifdef USEPORTAPIN0
case PA0:{
if(!ConfigGPIO.GPIOS.PoA0){
//
// Enable pin PA0 for GPIOInput
//
ConfigGPIO.GPIOS.PoA0 = 1;
MAP_GPIOPinTypeGPIOInput(GPIO_PORTA_BASE, GPIO_PIN_0);
GPIOIntTypeSet(GPIO_PORTA_BASE,GPIO_PIN_0,GPIO_HIGH_LEVEL);
Mask[0] += GPIO_INT_PIN_0;
}
break;
}
#endif
#ifdef USEPORTAPIN1
case PA1:{
if(!ConfigGPIO.GPIOS.PoA1){
//
// Enable pin PA1 for GPIOInput
//
ConfigGPIO.GPIOS.PoA1 = 1;
MAP_GPIOPinTypeGPIOInput(GPIO_PORTA_BASE, GPIO_PIN_1);
GPIOIntTypeSet(GPIO_PORTA_BASE,GPIO_PIN_1,GPIO_HIGH_LEVEL);
Mask[0] += GPIO_INT_PIN_1;
}
break;
}
#endif
#ifdef USEPORTAPIN2
case PA2:{
if(!ConfigGPIO.GPIOS.PoA2){
//
// Enable pin PA2 for GPIOInput
//
ConfigGPIO.GPIOS.PoA2 = 1;
MAP_GPIOPinTypeGPIOInput(GPIO_PORTA_BASE, GPIO_PIN_2);
GPIOIntTypeSet(GPIO_PORTA_BASE,GPIO_PIN_2,GPIO_HIGH_LEVEL);
Mask[0] += GPIO_INT_PIN_2;
}
break;
}
#endif
#ifdef USEPORTAPIN3
case PA3:{
if(!ConfigGPIO.GPIOS.PoA3){
//
// Enable pin PA3 for GPIOInput
//
ConfigGPIO.GPIOS.PoA3 = 1;
GPIOPinTypeGPIOInput(GPIO_PORTA_BASE, GPIO_PIN_3);
GPIOIntTypeSet(GPIO_PORTA_BASE,GPIO_PIN_3,GPIO_HIGH_LEVEL);
Mask[0] += GPIO_INT_PIN_3;
}
break;
}
#endif
#ifdef USEPORTAPIN4
case PA4:{
if(!ConfigGPIO.GPIOS.PoA4){
//
// Enable pin PA4 for GPIOInput
//
ConfigGPIO.GPIOS.PoA4 = 1;
MAP_GPIOPinTypeGPIOInput(GPIO_PORTA_BASE, GPIO_PIN_4);
GPIOIntTypeSet(GPIO_PORTA_BASE,GPIO_PIN_4,GPIO_HIGH_LEVEL);
Mask[0] += GPIO_INT_PIN_4;
}
break;
}
#endif
#ifdef USEPORTAPIN5
case PA5:{
if(!ConfigGPIO.GPIOS.PoA5){
//
// Enable pin PA5 for GPIOInput
//
ConfigGPIO.GPIOS.PoA5 = 1;
MAP_GPIOPinTypeGPIOInput(GPIO_PORTA_BASE, GPIO_PIN_5);
GPIOIntTypeSet(GPIO_PORTA_BASE,GPIO_PIN_5,GPIO_HIGH_LEVEL);
Mask[0] += GPIO_INT_PIN_5;
}
break;
}
#endif
#ifdef USEPORTAPIN6
case PA6:{
if(!ConfigGPIO.GPIOS.PoA6){
//
// Enable pin PA6 for GPIOInput
//
ConfigGPIO.GPIOS.PoA6 = 1;
MAP_GPIOPinTypeGPIOInput(GPIO_PORTA_BASE, GPIO_PIN_6);
GPIOIntTypeSet(GPIO_PORTA_BASE,GPIO_PIN_6,GPIO_HIGH_LEVEL);
Mask[0] += GPIO_INT_PIN_6;
}
break;
}
#endif
#ifdef USEPORTAPIN7
case PA7:{
if(!ConfigGPIO.GPIOS.PoA7){
//
// Enable pin PA7 for GPIOInput
//
ConfigGPIO.GPIOS.PoA7 = 1;
MAP_GPIOPinTypeGPIOInput(GPIO_PORTA_BASE, GPIO_PIN_7);
GPIOIntTypeSet(GPIO_PORTA_BASE,GPIO_PIN_7,GPIO_HIGH_LEVEL);
Mask[0] += GPIO_INT_PIN_7;
}
break;
}
#endif
#endif
#ifdef USEPORTB
//Puerto B
#ifdef USEPORTBPIN0
case PB0:{
if(!ConfigGPIO.GPIOS.PoB0){
//
// Enable pin PB0 for GPIOInput
//
ConfigGPIO.GPIOS.PoB0 = 1;
MAP_GPIOPinTypeGPIOInput(GPIO_PORTB_BASE, GPIO_PIN_0);
GPIOIntTypeSet(GPIO_PORTB_BASE,GPIO_PIN_0,GPIO_HIGH_LEVEL);
Mask[1] += GPIO_INT_PIN_0;
}
break;
}
#endif
#ifdef USEPORTBPIN1
case PB1:{
if(!ConfigGPIO.GPIOS.PoB1){
//
// Enable pin PB1 for GPIOInput
//
ConfigGPIO.GPIOS.PoB1 = 1;
MAP_GPIOPinTypeGPIOInput(GPIO_PORTB_BASE, GPIO_PIN_1);
GPIOIntTypeSet(GPIO_PORTB_BASE,GPIO_PIN_1,GPIO_HIGH_LEVEL);
Mask[1] += GPIO_INT_PIN_0;
}
break;
}
#endif
#ifdef USEPORTBPIN2
case PB2:{
if(!ConfigGPIO.GPIOS.PoB2){
//
// Enable pin PB2 for GPIOInput
//
ConfigGPIO.GPIOS.PoB2 = 1;
MAP_GPIOPinTypeGPIOInput(GPIO_PORTB_BASE, GPIO_PIN_2);
GPIOIntTypeSet(GPIO_PORTB_BASE,GPIO_PIN_2,GPIO_HIGH_LEVEL);
Mask[1] += GPIO_INT_PIN_2;
}
break;
}
#endif
#ifdef USEPORTBPIN3
case PB3:{
if(!ConfigGPIO.GPIOS.PoB3){
//
// Enable pin PB3 for GPIOInput
//
ConfigGPIO.GPIOS.PoB3 = 1;
MAP_GPIOPinTypeGPIOInput(GPIO_PORTB_BASE, GPIO_PIN_3);
GPIOIntTypeSet(GPIO_PORTB_BASE,GPIO_PIN_3,GPIO_RISING_EDGE );
Mask[1] += GPIO_INT_PIN_3;
}
break;
}
#endif
#ifdef USEPORTBPIN4
case PB4:{
if(!ConfigGPIO.GPIOS.PoB4){
//
// Enable pin PB4 for GPIOInput
//
ConfigGPIO.GPIOS.PoB4 = 1;
MAP_GPIOPinTypeGPIOInput(GPIO_PORTB_BASE, GPIO_PIN_4);
GPIOIntTypeSet(GPIO_PORTB_BASE,GPIO_PIN_4,GPIO_HIGH_LEVEL);
Mask[1] += GPIO_INT_PIN_4;
}
break;
}
#endif
#ifdef USEPORTBPIN5
case PB5:{
if(!ConfigGPIO.GPIOS.PoB5){
//
// Enable pin PB5 for GPIOInput
//
ConfigGPIO.GPIOS.PoB5 = 1;
MAP_GPIOPinTypeGPIOInput(GPIO_PORTB_BASE, GPIO_PIN_5);
GPIOIntTypeSet(GPIO_PORTB_BASE,GPIO_PIN_5,GPIO_HIGH_LEVEL);
Mask[1] += GPIO_INT_PIN_5;
}
break;
}
#endif
#ifdef USEPORTBPIN6
case PB6:{
if(!ConfigGPIO.GPIOS.PoB6){
//
// Enable pin PB6 for GPIOInput
//
ConfigGPIO.GPIOS.PoB6 = 1;
MAP_GPIOPinTypeGPIOInput(GPIO_PORTB_BASE, GPIO_PIN_6);
GPIOIntTypeSet(GPIO_PORTB_BASE,GPIO_PIN_6,GPIO_HIGH_LEVEL);
Mask[1] += GPIO_INT_PIN_6;
}
break;
}
#endif
#ifdef USEPORTBPIN7
case PB7:{
if(!ConfigGPIO.GPIOS.PoB7){
//
// Enable pin PB7 for GPIOInput
//
ConfigGPIO.GPIOS.PoB7 = 1;
MAP_GPIOPinTypeGPIOInput(GPIO_PORTB_BASE, GPIO_PIN_7);
GPIOIntTypeSet(GPIO_PORTB_BASE,GPIO_PIN_7,GPIO_HIGH_LEVEL);
Mask[1] += GPIO_INT_PIN_7;
}
break;
}
#endif
#endif
#ifdef USEPORTC
//Puerto C
#ifdef USEPORTCPIN4
case PC4:{
if(!ConfigGPIO.GPIOS.PoC4){
//
// Enable pin PC4 for GPIOInput
//
ConfigGPIO.GPIOS.PoC4 = 1;
MAP_GPIOPinTypeGPIOInput(GPIO_PORTC_BASE, GPIO_PIN_4);
GPIOIntTypeSet(GPIO_PORTC_BASE,GPIO_PIN_4,GPIO_HIGH_LEVEL);
Mask[2] += GPIO_INT_PIN_4;
}
break;
}
#endif
#ifdef USEPORTCPIN5
case PC5:{
if(!ConfigGPIO.GPIOS.PoC5){
//
// Enable pin PC5 for GPIOInput
//
ConfigGPIO.GPIOS.PoC5 = 1;
MAP_GPIOPinTypeGPIOInput(GPIO_PORTC_BASE, GPIO_PIN_5);
GPIOIntTypeSet(GPIO_PORTC_BASE,GPIO_PIN_5,GPIO_HIGH_LEVEL);
Mask[2] += GPIO_INT_PIN_5;
}
break;
}
#endif
#ifdef USEPORTCPIN6
case PC6:{
if(!ConfigGPIO.GPIOS.PoC6){
//
// Enable pin PC6 for GPIOInput
//
ConfigGPIO.GPIOS.PoC6 = 1;
MAP_GPIOPinTypeGPIOInput(GPIO_PORTC_BASE, GPIO_PIN_6);
GPIOIntTypeSet(GPIO_PORTC_BASE,GPIO_PIN_6,GPIO_HIGH_LEVEL);
Mask[2] += GPIO_INT_PIN_6;
}
break;
}
#endif
#ifdef USEPORTCPIN7
case PC7:{
if(!ConfigGPIO.GPIOS.PoC7){
//
// Enable pin PC7 for GPIOInput
//
ConfigGPIO.GPIOS.PoC7 = 1;
MAP_GPIOPinTypeGPIOInput(GPIO_PORTC_BASE, GPIO_PIN_7);
GPIOIntTypeSet(GPIO_PORTC_BASE,GPIO_PIN_7,GPIO_HIGH_LEVEL);
Mask[2] += GPIO_INT_PIN_7;
}
break;
}
#endif
#endif
#ifdef USEPORTD
//Puerto D
#ifdef USEPORTDPIN0
case PD0:{
if(!ConfigGPIO.GPIOS.PoD0){
//
// Enable pin PD0 for GPIOInput
//
ConfigGPIO.GPIOS.PoD0 = 1;
MAP_GPIOPinTypeGPIOInput(GPIO_PORTD_BASE, GPIO_PIN_0);
GPIOIntTypeSet(GPIO_PORTD_BASE,GPIO_PIN_0,GPIO_HIGH_LEVEL);
Mask[3] += GPIO_INT_PIN_0;
}
break;
}
#endif
#ifdef USEPORTDPIN1
case PD1:{
if(!ConfigGPIO.GPIOS.PoD1){
//
// Enable pin PD1 for GPIOInput
//
ConfigGPIO.GPIOS.PoD1 = 1;
MAP_GPIOPinTypeGPIOInput(GPIO_PORTD_BASE, GPIO_PIN_1);
GPIOIntTypeSet(GPIO_PORTD_BASE,GPIO_PIN_1,GPIO_HIGH_LEVEL);
Mask[3] += GPIO_INT_PIN_1;
}
break;
}
#endif
#ifdef USEPORTDPIN2
case PD2:{
if(!ConfigGPIO.GPIOS.PoD2){
//
// Enable pin PD2 for GPIOInput
//
ConfigGPIO.GPIOS.PoD2 = 1;
MAP_GPIOPinTypeGPIOInput(GPIO_PORTD_BASE, GPIO_PIN_2);
GPIOIntTypeSet(GPIO_PORTD_BASE,GPIO_PIN_2,GPIO_HIGH_LEVEL);
Mask[3] += GPIO_INT_PIN_2;
}
break;
}
#endif
#ifdef USEPORTDPIN3
case PD3:{
if(!ConfigGPIO.GPIOS.PoD3){
//
// Enable pin PD3 for GPIOInput
//
ConfigGPIO.GPIOS.PoD3 = 1;
MAP_GPIOPinTypeGPIOInput(GPIO_PORTD_BASE, GPIO_PIN_3);
GPIOIntTypeSet(GPIO_PORTD_BASE,GPIO_PIN_3,GPIO_HIGH_LEVEL);
Mask[3] += GPIO_INT_PIN_3;
}
break;
}
#endif
#ifdef USEPORTDPIN4
case PD4:{
if(!ConfigGPIO.GPIOS.PoD4){
//
// Enable pin PD4 for GPIOInput
//
ConfigGPIO.GPIOS.PoD4 = 1;
MAP_GPIOPinTypeGPIOInput(GPIO_PORTD_BASE, GPIO_PIN_4);
GPIOIntTypeSet(GPIO_PORTD_BASE,GPIO_PIN_4,GPIO_HIGH_LEVEL);
Mask[3] += GPIO_INT_PIN_4;
}
break;
}
#endif
#ifdef USEPORTDPIN5
case PD5:{
if(!ConfigGPIO.GPIOS.PoD5){
//
// Enable pin PD5 for GPIOInput
//
ConfigGPIO.GPIOS.PoD5 = 1;
MAP_GPIOPinTypeGPIOInput(GPIO_PORTD_BASE, GPIO_PIN_5);
GPIOIntTypeSet(GPIO_PORTD_BASE,GPIO_PIN_5,GPIO_HIGH_LEVEL);
Mask[3] += GPIO_INT_PIN_5;
}
break;
}
#endif
#ifdef USEPORTDPIN6
case PD6:{
if(!ConfigGPIO.GPIOS.PoD6){
//
// Enable pin PD6 for GPIOInput
//
ConfigGPIO.GPIOS.PoD6 = 1;
MAP_GPIOPinTypeGPIOInput(GPIO_PORTD_BASE, GPIO_PIN_6);
GPIOIntTypeSet(GPIO_PORTD_BASE,GPIO_PIN_6,GPIO_HIGH_LEVEL);
Mask[3] += GPIO_INT_PIN_6;
}
break;
}
#endif
#ifdef USEPORTDPIN7
case PD7:{
if(!ConfigGPIO.GPIOS.PoD7){
//
// Enable pin PD7 for GPIOInput
//
//
//First open the lock and select the bits we want to modify in the GPIO commit register.
//
HWREG(GPIO_PORTD_BASE + GPIO_O_LOCK) = GPIO_LOCK_KEY;
HWREG(GPIO_PORTD_BASE + GPIO_O_CR) = 0x80;
//
//Now modify the configuration of the pins that we unlocked.
//
ConfigGPIO.GPIOS.PoD7 = 1;
MAP_GPIOPinTypeGPIOInput(GPIO_PORTD_BASE, GPIO_PIN_7);
GPIOIntTypeSet(GPIO_PORTD_BASE,GPIO_PIN_7,GPIO_HIGH_LEVEL);
Mask[3] += GPIO_INT_PIN_7;
}
break;
}
#endif
#endif
#ifdef USEPORTE
//Puerto E
#ifdef USEPORTEPIN0
case PE0:{
if(!ConfigGPIO.GPIOS.PoE0){
//
// Enable pin PE0 for GPIOInput
//
ConfigGPIO.GPIOS.PoE0 = 1;
MAP_GPIOPinTypeGPIOInput(GPIO_PORTE_BASE, GPIO_PIN_0);
GPIOIntTypeSet(GPIO_PORTE_BASE,GPIO_PIN_0,GPIO_HIGH_LEVEL);
Mask[4] += GPIO_INT_PIN_0;
}
break;
}
#endif
#ifdef USEPORTEPIN1
case PE1:{
if(!ConfigGPIO.GPIOS.PoE1){
//
// Enable pin PE1 for GPIOInput
//
ConfigGPIO.GPIOS.PoE1 = 1;
MAP_GPIOPinTypeGPIOInput(GPIO_PORTE_BASE, GPIO_PIN_1);
GPIOIntTypeSet(GPIO_PORTE_BASE,GPIO_PIN_1,GPIO_HIGH_LEVEL);
Mask[4] += GPIO_INT_PIN_1;
}
break;
}
#endif
#ifdef USEPORTEPIN2
case PE2:{
if(!ConfigGPIO.GPIOS.PoE2){
//
// Enable pin PE2 for GPIOInput
//
ConfigGPIO.GPIOS.PoE2 = 1;
MAP_GPIOPinTypeGPIOInput(GPIO_PORTE_BASE, GPIO_PIN_2);
GPIOIntTypeSet(GPIO_PORTE_BASE,GPIO_PIN_2,GPIO_HIGH_LEVEL);
Mask[4] += GPIO_INT_PIN_2;
}
// break;
}
#endif
#ifdef USEPORTEPIN3
case PE3:{
if(!ConfigGPIO.GPIOS.PoE3){
// Enable pin PE3 for GPIOInput
//
ConfigGPIO.GPIOS.PoE3 = 1;
MAP_GPIOPinTypeGPIOInput(GPIO_PORTE_BASE, GPIO_PIN_3);
GPIOIntTypeSet(GPIO_PORTE_BASE,GPIO_PIN_3,GPIO_HIGH_LEVEL);
Mask[4] += GPIO_INT_PIN_3;
}
break;
}
#endif
#ifdef USEPORTEPIN4
case PE4:{
if(!ConfigGPIO.GPIOS.PoE4){
//
// Enable pin PE4 for GPIOInput
//
ConfigGPIO.GPIOS.PoE4 = 1;
MAP_GPIOPinTypeGPIOInput(GPIO_PORTE_BASE, GPIO_PIN_4);
GPIOIntTypeSet(GPIO_PORTE_BASE,GPIO_PIN_4,GPIO_HIGH_LEVEL);
Mask[4] += GPIO_INT_PIN_4;
}
break;
}
#endif
#ifdef USEPORTEPIN5
case PE5:{
if(!ConfigGPIO.GPIOS.PoE5){
//
// Enable pin PE5 for GPIOInput
//
ConfigGPIO.GPIOS.PoE5 = 1;
MAP_GPIOPinTypeGPIOInput(GPIO_PORTE_BASE, GPIO_PIN_5);
GPIOIntTypeSet(GPIO_PORTE_BASE,GPIO_PIN_5,GPIO_HIGH_LEVEL);
Mask[4] += GPIO_INT_PIN_5;
}
break;
}
#endif
#endif
#ifdef USEPORTF
//Puerto F
#ifdef USEPORTFPIN0
case PF0:{
if(!ConfigGPIO.GPIOS.PoF0){
//
// Enable pin PF0 for GPIOInput
//
//
//First open the lock and select the bits we want to modify in the GPIO commit register.
//
HWREG(GPIO_PORTF_BASE + GPIO_O_LOCK) = GPIO_LOCK_KEY;
HWREG(GPIO_PORTF_BASE + GPIO_O_CR) = 0x1;
//
//Now modify the configuration of the pins that we unlocked.
//
ConfigGPIO.GPIOS.PoF0 = 1;
MAP_GPIOPinTypeGPIOInput(GPIO_PORTF_BASE, GPIO_PIN_0);
GPIOIntTypeSet(GPIO_PORTF_BASE,GPIO_PIN_0,GPIO_HIGH_LEVEL);
Mask[5] += GPIO_INT_PIN_0;
}
break;
}
#endif
#ifdef USEPORTFPIN1
case PF1:{
if(!ConfigGPIO.GPIOS.PoF1){
//
// Enable pin PF1 for GPIOInput
//
ConfigGPIO.GPIOS.PoF1 = 1;
MAP_GPIOPinTypeGPIOInput(GPIO_PORTF_BASE, GPIO_PIN_1);
GPIOIntTypeSet(GPIO_PORTF_BASE,GPIO_PIN_1,GPIO_HIGH_LEVEL);
Mask[5] += GPIO_INT_PIN_1;
}
break;
}
#endif
#ifdef USEPORTFPIN2
case PF2:{
if(!ConfigGPIO.GPIOS.PoF2){
//
// Enable pin PF2 for GPIOInput
//
ConfigGPIO.GPIOS.PoF2 = 1;
MAP_GPIOPinTypeGPIOInput(GPIO_PORTF_BASE, GPIO_PIN_2);
GPIOIntTypeSet(GPIO_PORTF_BASE,GPIO_PIN_2,GPIO_HIGH_LEVEL);
Mask[5] += GPIO_INT_PIN_2;
}
break;
}
#endif
#ifdef USEPORTFPIN3
case PF3:{
if(!ConfigGPIO.GPIOS.PoF3){
//
// Enable pin PF3 for GPIOInput
//
ConfigGPIO.GPIOS.PoF3 = 1;
MAP_GPIOPinTypeGPIOInput(GPIO_PORTF_BASE, GPIO_PIN_3);
GPIOIntTypeSet(GPIO_PORTF_BASE,GPIO_PIN_3,GPIO_HIGH_LEVEL);
Mask[5] += GPIO_INT_PIN_3;
}
break;
}
#endif
#ifdef USEPORTFPIN4
case PF4:{
if(!ConfigGPIO.GPIOS.PoF4){
//
// Enable pin PF4 for GPIOInput
//
ConfigGPIO.GPIOS.PoF4 = 1;
MAP_GPIOPinTypeGPIOInput(GPIO_PORTF_BASE, GPIO_PIN_4);
GPIOIntTypeSet(GPIO_PORTF_BASE,GPIO_PIN_4,GPIO_HIGH_LEVEL);
Mask[5] += GPIO_INT_PIN_4;
}
break;
}
#endif
#endif
default: break;
}
GPIOIntClear(GPIO_PORTA_BASE,0x0F);
GPIOIntClear(GPIO_PORTB_BASE,0x0F);
GPIOIntClear(GPIO_PORTC_BASE,0x0F);
GPIOIntClear(GPIO_PORTD_BASE,0x0F);
GPIOIntClear(GPIO_PORTE_BASE,0x0F);
GPIOIntClear(GPIO_PORTF_BASE,0x0F);
GPIOIntDisable(GPIO_PORTA_BASE,0x0F);
GPIOIntDisable(GPIO_PORTB_BASE,0x0F);
GPIOIntDisable(GPIO_PORTC_BASE,0x0F);
GPIOIntDisable(GPIO_PORTD_BASE,0x0F);
GPIOIntDisable(GPIO_PORTE_BASE,0x0F);
GPIOIntDisable(GPIO_PORTF_BASE,0x0F);
#ifdef USEPORTA
//Habilitacion de las interrupciones:
//Puerto A con algo configurado
if(ConfigGPIO.PortGpio[0] >0){
//Primero deshabilita configura habilita
//IntEnable(INT_GPIOA);
GPIOIntEnable(GPIO_PORTA_BASE,Mask[0]);
//GPIOPadConfigSet(GPIO_PORTA_BASE,Mask[0],GPIO_STRENGTH_2MA,GPIO_PIN_TYPE_STD_WPD);
GPIOIntRegister(GPIO_PORTA_BASE,TOFProcess);
//GPIOIntTypeSet(GPIO_PORTA_BASE,Mask[0],GPIO_RISING_EDGE);
}
#endif
#ifdef USEPORTB
//Puerto B con algo configurado
if(ConfigGPIO.PortGpio[1] >0){
// GPIOIntTypeSet(GPIO_PORTB_BASE,Mask[1],GPIO_PIN_TYPE_STD_WPD);
GPIOIntRegister(GPIO_PORTB_BASE,TOFProcess);
GPIOIntEnable(GPIO_PORTB_BASE,Mask[1]);
}
#endif
#ifdef USEPORTC
//Puerto C con algo configurado
if(ConfigGPIO.PortGpio[2] >0){
GPIOIntEnable(GPIO_PORTC_BASE,Mask[2]);
GPIOIntRegister(GPIO_PORTC_BASE,TOFProcess);
}
#endif
#ifdef USEPORTD
//Puerto D con algo configurado
if(ConfigGPIO.PortGpio[3] >0){
GPIOIntEnable(GPIO_PORTD_BASE,Mask[3]);
GPIOIntRegister(GPIO_PORTD_BASE,TOFProcess);
}
#endif
#ifdef USEPORTE
//Puerto E con algo configurado
if(ConfigGPIO.PortGpio[4] >0){
GPIOIntEnable(GPIO_PORTE_BASE,Mask[4]);
GPIOIntRegister(GPIO_PORTE_BASE,TOFProcess);
}
#endif
#ifdef USEPORTF
//Puerto F con algo configurado
if(ConfigGPIO.PortGpio[5] >0){
GPIOIntEnable(GPIO_PORTF_BASE,Mask[5]);
GPIOIntRegister(GPIO_PORTF_BASE,TOFProcess);
}
#endif
// IntMasterEnable();
}
Fd_t uart_Open(char *ifName, unsigned long flags)
{
/* Configure CS (PE0) and nHIB (PE4) lines */
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOE);
ROM_GPIOPinTypeGPIOOutput(GPIO_PORTE_BASE, GPIO_PIN_4);
ROM_GPIOPinWrite(GPIO_PORTE_BASE,GPIO_PIN_4, PIN_LOW);
/* configuring UART interface */
SysCtlPeripheralEnable(SYSCTL_PERIPH_UART1);
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB);
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOC);
GPIOPinConfigure(GPIO_PB0_U1RX);
GPIOPinConfigure(GPIO_PB1_U1TX);
ROM_GPIOPinTypeUART(GPIO_PORTB_BASE, GPIO_PIN_0 | GPIO_PIN_1);
GPIOPinConfigure(GPIO_PC4_U1RTS);
GPIOPinConfigure(GPIO_PC5_U1CTS);
ROM_GPIOPinTypeUART(GPIO_PORTC_BASE, GPIO_PIN_4 | GPIO_PIN_5);
GPIOPadConfigSet(GPIO_PORTB_BASE, GPIO_PIN_0, GPIO_STRENGTH_2MA,
GPIO_PIN_TYPE_STD_WPU);
/* configure with baud rate 115200 */
ROM_UARTConfigSetExpClk(UART1_BASE, ROM_SysCtlClockGet(), 115200,
(UART_CONFIG_WLEN_8 | UART_CONFIG_STOP_ONE |
UART_CONFIG_PAR_NONE));
UARTFlowControlSet(UART1_BASE, UART_FLOWCONTROL_TX | UART_FLOWCONTROL_RX);
UARTFIFOLevelSet(UART1_BASE, UART_FIFO_TX1_8, UART_FIFO_RX1_8);
ROM_UARTEnable(UART1_BASE);
ROM_UARTFIFOEnable(UART1_BASE);
ROM_IntEnable(INT_UART1);
ROM_UARTIntEnable(UART1_BASE, UART_INT_RX);
ROM_UARTIntDisable(UART1_BASE, UART_INT_TX | UART_INT_RT);
/* configure host IRQ line */
GPIOPinTypeGPIOInput(GPIO_PORTB_BASE, GPIO_PIN_2);
GPIOPadConfigSet(GPIO_PORTB_BASE, GPIO_PIN_2, GPIO_STRENGTH_2MA,
GPIO_PIN_TYPE_STD_WPD);
GPIOIntTypeSet(GPIO_PORTB_BASE, GPIO_PIN_2, GPIO_RISING_EDGE);
GPIOIntClear(GPIO_PORTB_BASE,GPIO_PIN_2);
GPIOIntDisable(GPIO_PORTB_BASE,GPIO_PIN_2);
ROM_IntEnable(INT_GPIOB);
ROM_IntMasterEnable();
IntIsMasked = FALSE;
/* Enable WLAN interrupt */
CC3100_InterruptEnable();
/* 50 ms delay */
ROM_SysCtlDelay((ROM_SysCtlClockGet()/(3*1000))*50 );
return NONOS_RET_OK;
}
void lswitch::stop() {
GPIOIntDisable(base, pin);
}
Fd_t spi_Open(char *ifName, unsigned long flags)
{
//
// Enable required SSI and GPIO peripherals.
//
SysCtlPeripheralEnable(SYSCTL_PERIPH_SPI_PORT);
SysCtlPeripheralEnable(SYSCTL_PERIPH_IRQ_PORT);
SysCtlPeripheralEnable(SYSCTL_PERIPH_nHIB_PORT);
SysCtlPeripheralEnable(SYSCTL_PERIPH_SPI);
SysCtlPeripheralEnable(SYSCTL_PERIPH_SPI_BASE);
//
// Set pin muxing to route the SPI signals to the relevant pins.
//
GPIOPinConfigure(SPI_CLK_MUX_SEL);
GPIOPinConfigure(SPI_RX_MUX_SEL);
GPIOPinConfigure(SPI_TX_MUX_SEL);
//GPIOPinConfigure(GPIO_PB5_SSI2FSS);
//
// Configure the appropriate pins to be SSI instead of GPIO
//
GPIOPinTypeSSI(SPI_PORT,(SPI_TX_PIN | SPI_RX_PIN | SPI_CLK_PIN));
//
// Ensure that the SSI is disabled before making any configuration
// changes.
//
SSIDisable(SPI_BASE);
//
// Configure SSI with 8 bit data, Polarity '0', Phase '1' and clock
// frequency of 4Mhz.
//
SSIConfigSetExpClk(SPI_BASE, g_ui32SysClock, SSI_FRF_MOTO_MODE_0,
SSI_MODE_MASTER, 4000000, 8);
// Configure CS and nHIB/Enable lines (CS High, nHIB Low)
GPIOPinTypeGPIOOutput(SPI_CS_PORT, SPI_CS_PIN);
GPIOPinTypeGPIOOutput(SPI_GPIO_nHIB_BASE, SPI_nHIB_PIN);
GPIOPinWrite(SPI_GPIO_nHIB_BASE,SPI_nHIB_PIN, PIN_LOW); // not necesary on cc3100
GPIOPinWrite(SPI_CS_PORT,SPI_CS_PIN, PIN_HIGH);
//
// Enable the SSI now that configuration is complete.
//
SSIEnable(SPI_BASE);
//
// configure host IRQ line
//
GPIOPinTypeGPIOInput(SPI_GPIO_IRQ_BASE, SPI_IRQ_PIN);
GPIOPadConfigSet(SPI_GPIO_IRQ_BASE, SPI_IRQ_PIN, GPIO_STRENGTH_2MA,
GPIO_PIN_TYPE_STD_WPD);
GPIOIntTypeSet(SPI_GPIO_IRQ_BASE, SPI_IRQ_PIN, GPIO_RISING_EDGE);
GPIOIntClear(SPI_GPIO_IRQ_BASE,SPI_IRQ_PIN);
GPIOIntDisable(SPI_GPIO_IRQ_BASE,SPI_IRQ_PIN);
IntEnable(INT_GPIO_SPI);
IntMasterEnable();
/* 1 ms delay */
ROM_SysCtlDelay( (g_ui32SysClock/(3*1000))*1 );
/* Enable WLAN interrupt */
CC3100_InterruptEnable();
return NONOS_RET_OK;
}
