void InfiniteLoopTask(void *pvParameters)
{
// GPIO Configuration
GPIO_IF_LedConfigure(LED1|LED3);
GPIO_IF_LedOff(MCU_RED_LED_GPIO);
TimerConfigNStart();
while(1);
}
void initBoard() {
#ifndef USE_TIRTOS
#if defined(ccs) || defined(gcc)
MAP_IntVTableBaseSet((unsigned long) &g_pfnVectors[0]);
#endif
#if defined(ewarm)
MAP_IntVTableBaseSet((unsigned long)&__vector_table);
#endif
#endif
MAP_IntMasterEnable();
MAP_IntEnable(FAULT_SYSTICK);
PRCMCC3200MCUInit();
PinMuxConfig();
GPIO_IF_LedConfigure(LED1);
GPIO_IF_LedOff(MCU_RED_LED_GPIO);
InitTerm();
ClearTerm();
UART_PRINT("Blink - Parse for IoT sample application\r\n");
UART_PRINT("----------------------------------------\r\n");
UART_PRINT("\r\n");
UART_PRINT("[Blink] Board init\r\n");
// start the spawn task
short status = VStartSimpleLinkSpawnTask(SPAWN_TASK_PRIORITY);
if (status < 0) {
UART_PRINT("[Blink] Spawn task failed\r\n");
ERR_PRINT(status);
LOOP_FOREVER();
}
// initialize the I2C bus
status = I2C_IF_Open(I2C_MASTER_MODE_FST);
if (status < 0) {
UART_PRINT("[Blink] I2C opening error\r\n");
ERR_PRINT(status);
LOOP_FOREVER();
}
UART_PRINT("[Blink] Device : TI SimpleLink CC3200\r\n");
#ifdef USE_TIRTOS
UART_PRINT("[Blink] Operating system : TI-RTOS\r\n");
#endif
#ifdef USE_FREERTOS
UART_PRINT("[Blink] Operating system : FreeRTOS\r\n");
#endif
#ifndef SL_PLATFORM_MULTI_THREADED
UART_PRINT("[Blink] Operating system : None\r\n");
#endif
}
int main(void)
{
long lRetVal = -1;
//
// initialize board configurations
//
BoardInit();
//
// Pinmux GPIO for LEDs
//
PinMuxConfig();
#ifndef NOTERM
//
// Configuring UART
//
InitTerm();
#endif
//
// Configure LEDs
//
GPIO_IF_LedConfigure(LED1|LED2|LED3);
GPIO_IF_LedOff(MCU_ALL_LED_IND);
//
// Simplelinkspawntask
//
lRetVal = VStartSimpleLinkSpawnTask(SPAWN_TASK_PRIORITY);
if(lRetVal < 0)
{
ERR_PRINT(lRetVal);
LOOP_FOREVER();
}
lRetVal = osi_TaskCreate(XmppClient, (const signed char*)"XmppClient",\
OSI_STACK_SIZE, NULL, 1, NULL );
if(lRetVal < 0)
{
ERR_PRINT(lRetVal);
LOOP_FOREVER();
}
osi_start();
while(1)
{
}
}
//*****************************************************************************
//
//! main function demonstrates the use of the timers to generate
//! periodic interrupts.
//!
//! \param None
//!
//! \return none
//
//*****************************************************************************
int
main(void)
{
//
// Initialize board configurations
BoardInit();
//
// Pinmuxing for LEDs
//
PinMuxConfig();
//
// configure the LED RED and GREEN
//
GPIO_IF_LedConfigure(LED1|LED3);
GPIO_IF_LedOff(MCU_RED_LED_GPIO);
GPIO_IF_LedOff(MCU_GREEN_LED_GPIO);
//
// Base address for first timer
//
g_ulBase = TIMERA0_BASE;
//
// Base address for second timer
//
g_ulRefBase = TIMERA1_BASE;
//
// Configuring the timers
//
Timer_IF_Init(PRCM_TIMERA0, g_ulBase, TIMER_CFG_PERIODIC, TIMER_A, 0);
Timer_IF_Init(PRCM_TIMERA1, g_ulRefBase, TIMER_CFG_PERIODIC, TIMER_A, 0);
//
// Setup the interrupts for the timer timeouts.
//
Timer_IF_IntSetup(g_ulBase, TIMER_A, TimerBaseIntHandler);
Timer_IF_IntSetup(g_ulRefBase, TIMER_A, TimerRefIntHandler);
//
// Turn on the timers feeding values in mSec
//
Timer_IF_Start(g_ulBase, TIMER_A, 500);
Timer_IF_Start(g_ulRefBase, TIMER_A, 1000);
//
// Loop forever while the timers run.
//
while(FOREVER)
{
}
}
int main() {
#ifndef USE_TIRTOS
MAP_IntVTableBaseSet((unsigned long) &g_pfnVectors[0]);
#endif
MAP_IntEnable(FAULT_SYSTICK);
MAP_IntMasterEnable();
PRCMCC3200MCUInit();
/* Console UART init. */
MAP_PRCMPeripheralClkEnable(CONSOLE_UART_PERIPH, PRCM_RUN_MODE_CLK);
MAP_PinTypeUART(PIN_55, PIN_MODE_3); /* PIN_55 -> UART0_TX */
MAP_PinTypeUART(PIN_57, PIN_MODE_3); /* PIN_57 -> UART0_RX */
MAP_UARTConfigSetExpClk(
CONSOLE_UART, MAP_PRCMPeripheralClockGet(CONSOLE_UART_PERIPH),
CONSOLE_BAUD_RATE,
(UART_CONFIG_WLEN_8 | UART_CONFIG_STOP_ONE | UART_CONFIG_PAR_NONE));
MAP_UARTFIFOLevelSet(CONSOLE_UART, UART_FIFO_TX1_8, UART_FIFO_RX4_8);
MAP_UARTFIFOEnable(CONSOLE_UART);
setvbuf(stdout, NULL, _IOLBF, 0);
setvbuf(stderr, NULL, _IOLBF, 0);
cs_log_set_level(LL_INFO);
cs_log_set_file(stdout);
LOG(LL_INFO, ("Hello, world!"));
MAP_PinTypeI2C(PIN_01, PIN_MODE_1); /* SDA */
MAP_PinTypeI2C(PIN_02, PIN_MODE_1); /* SCL */
I2C_IF_Open(I2C_MASTER_MODE_FST);
/* Set up the red LED. Note that amber and green cannot be used as they share
* pins with I2C. */
MAP_PRCMPeripheralClkEnable(PRCM_GPIOA1, PRCM_RUN_MODE_CLK);
MAP_PinTypeGPIO(PIN_64, PIN_MODE_0, false);
MAP_GPIODirModeSet(GPIOA1_BASE, 0x2, GPIO_DIR_MODE_OUT);
GPIO_IF_LedConfigure(LED1);
GPIO_IF_LedOn(MCU_RED_LED_GPIO);
if (VStartSimpleLinkSpawnTask(8) != 0) {
LOG(LL_ERROR, ("Failed to create SL task"));
}
if (!mg_start_task(MG_TASK_PRIORITY, MG_TASK_STACK_SIZE, mg_init)) {
LOG(LL_ERROR, ("Failed to create MG task"));
}
osi_start();
return 0;
}
//*****************************************************************************
// MAIN FUNCTION
//*****************************************************************************
void main() {
//
// Board Initialization
//
BoardInit();
//
// configure the GPIO pins for LEDs,UART
//
PinMuxConfig();
//
// Configure the UART
//
#ifndef NOTERM
InitTerm();
#endif //NOTERM
//
// Display Application Banner
//
DisplayBanner(APPLICATION_NAME);
//
// Configure all 3 LEDs
//
GPIO_IF_LedConfigure(LED1 | LED2 | LED3);
// switch off all LEDs
GPIO_IF_LedOff(MCU_ALL_LED_IND);
FileTest();
/*//
// Start the SimpleLink Host
//
VStartSimpleLinkSpawnTask(SPAWN_TASK_PRIORITY);
//
// Start the WlanStationMode task
//
osi_TaskCreate( WlanStationMode, (const signed char*)"Wlan Station Task",
OSI_STACK_SIZE, NULL, 1, NULL );
//
// Start the task scheduler
//
osi_start();*/
}
//*****************************************************************************
//
//! main function demonstrates the use of the watchdog timer to perform system
//! reset.
//!
//! \param None
//!
//! \return None
//
//*****************************************************************************
void main(void)
{
tBoolean bRetcode;
//
// Initialize the board
//
BoardInit();
//
// Pinmuxing for LEDs
//
PinMuxConfig();
//
// configure RED LED
//
GPIO_IF_LedConfigure(LED1);
GPIO_IF_LedOff(MCU_RED_LED_GPIO);
//
// Enable the peripherals used by this example.
//
MAP_PRCMPeripheralClkEnable(PRCM_WDT, PRCM_RUN_MODE_CLK);
//
// Set up the watchdog interrupt handler.
//
WDT_IF_Init(WatchdogIntHandler, MILLISECONDS_TO_TICKS(WD_PERIOD_MS));
//
// Start the timer. Once the timer is started, it cannot be disable.
//
MAP_WatchdogEnable(WDT_BASE);
bRetcode = MAP_WatchdogRunning(WDT_BASE);
if(!bRetcode)
{
WDT_IF_DeInit();
}
//
// Loop forever while the LED winks as watchdog interrupts are handled.
//
while(FOREVER)
{
}
}
//****************************************************************************
//
//! Main function
//!
//! \param none
//!
//! This function
//! 1. Invokes the LEDBlinkyTask
//!
//! \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();
#ifndef NOTERM
//
// Configuring UART
//
InitTerm();
#endif
DisplayBanner("Lab 0");
Message("\t\t****************************************************\n\r");
Message("\t\t\t CC3200 UART Echo Usage \n\r");
Message("\t\t To get to state 3, the user must press and hold SW2 \n\r");
Message("\t\t then press SW3 without releasing SW2 \n\r");
Message("\t\t and then release SW2 while continuing to press SW3\n\r");
Message("\n\n\n\r");
GPIO_IF_LedConfigure(LED1|LED2|LED3);
GPIO_IF_LedOff(MCU_ALL_LED_IND);
//
// Start the LEDBlinkyRoutine
//
LEDBlinkyRoutine();
return 0;
}
//****************************************************************************
//
//! Main function
//!
//! \param none
//!
//! This function
//! 1. Invokes the LEDBlinkyTask
//!
//! \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();
GPIO_IF_LedConfigure(LED1|LED2|LED3);
GPIO_IF_LedOff(MCU_ALL_LED_IND);
//
// Start the LEDBlinkyRoutine
//
LEDBlinkyRoutine();
return 0;
}
void launchpad_init(void){
long lRetVal = -1;
PinConfigSet(PIN_58, PIN_STRENGTH_2MA | PIN_STRENGTH_4MA, PIN_TYPE_STD_PD);
GPIO_IF_LedConfigure(LED1|LED2|LED3);
GPIO_IF_LedOff(MCU_ALL_LED_IND);
MAP_UtilsDelay(8000000);
GPIO_IF_LedOn(MCU_GREEN_LED_GPIO);
Report ("Initialize I2C...");
//
// I2C Init
//
lRetVal = I2C_IF_Open(I2C_MASTER_MODE_FST);
if(lRetVal < 0)
{
Report ("Fail!\r\n");
while(1);
}
Report ("Success\r\n");
}
//*****************************************************************************
//
//! main function demonstrates the use of the watchdog timer to perform system
//! reset.
//!
//! \param None
//!
//! \return None
//
//*****************************************************************************
void main(void)
{
tBoolean bRetcode;
//
// Initialize the board
//
BoardInit();
//
// Pinmuxing for LEDs
//
PinMuxConfig();
//
// configure RED LED
//
GPIO_IF_LedConfigure(LED1);
GPIO_IF_LedOff(MCU_RED_LED_GPIO);
//
// Set up the watchdog interrupt handler.
//
WDT_IF_Init(WatchdogIntHandler, MILLISECONDS_TO_TICKS(WD_PERIOD_MS));
bRetcode = MAP_WatchdogRunning(WDT_BASE);
if(!bRetcode)
{
WDT_IF_DeInit();
}
//
// Loop forever while the LED winks as watchdog interrupts are handled.
//
while(FOREVER)
{
}
}
//****************************************************************************
//
//! Task function implementing the TCP server and showcasing the
//! deepsleep functionality
//!
//! \param none
//!
//! This function
//! 1. Creates a TCP socket and binds to it
//! 2. Listens on the socket
//! 3. Accepts a client connection
//! 4. Receives a packet on the socket
//! 5. Closes the socket
//!
//! \return None.
//
//****************************************************************************
void TCPServerTask(void *pvParameters)
{
int iSocketDesc, iClientFD;
struct sockaddr_in sClientAddr;
int iRecvLen;
unsigned int iClientAddrLen = sizeof(sClientAddr);
unsigned char aucRecvBuffer[MAX_BUF];
DisplayBanner(APPLICATION_NAME);
DBG_PRINT("DEEPSLEEP: Test Begin\n\r");
//
// GPIO Configuration
//
GPIO_IF_LedConfigure(LED1|LED3);
GPIO_IF_LedOff(MCU_RED_LED_GPIO);
GPIO_IF_LedOff(MCU_GREEN_LED_GPIO);
//
// Start the driver
//
Network_IF_InitDriver(ROLE_STA);
GPIO_IF_LedOn(MCU_GREEN_LED_GPIO);
LedTimerConfigNStart();
// Initialize AP security params
SecurityParams.Key = SECURITY_KEY;
SecurityParams.KeyLen = strlen(SECURITY_KEY);
SecurityParams.Type = SECURITY_TYPE;
//
// Connect to the Access Point
//
Network_IF_ConnectAP(SSID_NAME,SecurityParams);
LedTimerDeinitStop();
//
// Switch ON RED LED to indicate that Device acquired an IP
//
GPIO_IF_LedOn(MCU_IP_ALLOC_IND);
//
// Create and Bind TCP server socket
//
iSocketDesc = CreateTCPServerSocket(APP_TCP_PORT);
if(iSocketDesc < 0)
{
DBG_PRINT("DEEPSLEEP: Socket create failed\n");
goto end;
}
DBG_PRINT("DEEPSLEEP: Socket created\n\r");
DBG_PRINT("DEEPSLEEP: Listening on Socket...\n\r");
//
// Start Listening on the socket
//
if( listen(iSocketDesc, 5) != 0)
{
DBG_PRINT("DEEPSLEEP: Listen failed\n\r");
goto end;
}
while(FOREVER)
{
//
// Accept new client connections (Here just one)
//
DBG_PRINT("DEEPSLEEP: Waiting for client.......\n\r");
iClientFD = accept(iSocketDesc,
(struct sockaddr*)&sClientAddr,
&iClientAddrLen);
DBG_PRINT("DEEPSLEEP: Connected to client [0x%x] \n\r",
htonl(sClientAddr.sin_addr.s_addr));
do
{
//
// Receive on the socket
//
iRecvLen = recv(iClientFD,aucRecvBuffer,MAX_BUF,0);
if(iRecvLen > 0)
{
DBG_PRINT("DEEPSLEEP: received %d bytes\n\r", iRecvLen);
DBG_PRINT("DEEPSLEEP: received message : %s\n\r", aucRecvBuffer);
}
}while(iRecvLen > 0);
//
// Close the client descriptor
//
close(iClientFD);
}
//
// Close the socket. Commented as not expected to reach here
//
//close(iSocketDesc);
end:
DBG_PRINT("DEEPSLEEP: Test Complete\n\r");
//
// Loop here
//
while(1);
}
//******************************************************************************
// MAIN FUNCTION
//******************************************************************************
int main()
{
long lRetVal = -1;
BoardInit();
//
// Pinmux Configuration
//
PinMuxConfig();
//
// Initialising the UART terminal
//
InitTerm();
//
// Create RX and TX Buffer
//
pTxBuffer = CreateCircularBuffer(TX_BUFFER_SIZE);
if(pTxBuffer == NULL)
{
UART_PRINT("Unable to Allocate Memory for Tx Buffer\n\r");
LOOP_FOREVER();
}
pRxBuffer = CreateCircularBuffer(RX_BUFFER_SIZE);
if(pRxBuffer == NULL)
{
UART_PRINT("Unable to Allocate Memory for Rx Buffer\n\r");
LOOP_FOREVER();
}
//
// Initialising the I2C Interface
//
lRetVal = I2C_IF_Open(1);
if(lRetVal < 0)
{
ERR_PRINT(lRetVal);
LOOP_FOREVER();
}
//
// Configure Audio Codec
//
ConfigureAudioCodec(CODEC_I2S_WORD_LEN_24);
GPIO_IF_LedConfigure(LED2|LED3);
GPIO_IF_LedOff(MCU_RED_LED_GPIO);
GPIO_IF_LedOff(MCU_GREEN_LED_GPIO);
//
// Configure PIN_01 for GPIOOutput
//
MAP_PinTypeGPIO(PIN_01, PIN_MODE_0, false);
MAP_GPIODirModeSet(GPIOA1_BASE, 0x4, GPIO_DIR_MODE_OUT);
//
// Configure PIN_02 for GPIOOutput
//
MAP_PinTypeGPIO(PIN_02, PIN_MODE_0, false);
MAP_GPIODirModeSet(GPIOA1_BASE, 0x8, GPIO_DIR_MODE_OUT);
//Turning off Green,Orange LED after i2c writes completed - First Time
GPIO_IF_LedOff(MCU_GREEN_LED_GPIO);
GPIO_IF_LedOff(MCU_ORANGE_LED_GPIO);
//
// Initialize the Audio(I2S) Module
//
AudioCapturerInit();
//
// Initialize the DMA Module
//
UDMAInit();
UDMAChannelSelect(UDMA_CH4_I2S_RX, NULL);
UDMAChannelSelect(UDMA_CH5_I2S_TX, NULL);
//
// Setup the DMA Mode
//
SetupPingPongDMATransferTx();
SetupPingPongDMATransferRx();
//
// Setup the Audio In/Out
//
lRetVal = AudioCapturerSetupDMAMode(DMAPingPongCompleteAppCB_opt, \
CB_EVENT_CONFIG_SZ);
if(lRetVal < 0)
{
ERR_PRINT(lRetVal);
LOOP_FOREVER();
}
AudioCaptureRendererConfigure();
//
// Start Audio Tx/Rx
//
Audio_Start();
//
// Start the simplelink thread
//
lRetVal = VStartSimpleLinkSpawnTask(9);
if(lRetVal < 0)
{
ERR_PRINT(lRetVal);
LOOP_FOREVER();
}
//
// Start the Network Task
//
lRetVal = osi_TaskCreate( Network, (signed char*)"NetworkTask",\
OSI_STACK_SIZE, NULL,
1, &g_NetworkTask );
if(lRetVal < 0)
{
ERR_PRINT(lRetVal);
LOOP_FOREVER();
}
//
// Start the Control Task
//
lRetVal = ControlTaskCreate();
if(lRetVal < 0)
{
ERR_PRINT(lRetVal);
LOOP_FOREVER();
}
//
// Start the Microphone Task
//
lRetVal = osi_TaskCreate( Microphone,(signed char*)"MicroPhone", \
OSI_STACK_SIZE, NULL,
1, &g_MicTask );
if(lRetVal < 0)
{
ERR_PRINT(lRetVal);
LOOP_FOREVER();
}
//
// Start the Speaker Task
//
lRetVal = osi_TaskCreate( Speaker, (signed char*)"Speaker",OSI_STACK_SIZE, \
NULL, 1, &g_SpeakerTask );
if(lRetVal < 0)
{
ERR_PRINT(lRetVal);
LOOP_FOREVER();
}
//
// Start the task scheduler
//
osi_start();
}
//****************************************************************************
// MAIN FUNCTION
//****************************************************************************
void main()
{
long lRetVal = -1;
//
// Board Initilization
//
BoardInit();
//
// Configure the pinmux settings for the peripherals exercised
//
PinMuxConfig();
PinConfigSet(PIN_58,PIN_STRENGTH_2MA|PIN_STRENGTH_4MA,PIN_TYPE_STD_PD);
// Initialize Global Variables
InitializeAppVariables();
//
// UART Init
//
InitTerm();
DisplayBanner(APP_NAME);
//
// LED Init
//
GPIO_IF_LedConfigure(LED1);
//Turn Off the LEDs
GPIO_IF_LedOff(MCU_RED_LED_GPIO);
//
// I2C Init
//
lRetVal = I2C_IF_Open(I2C_MASTER_MODE_FST);
if(lRetVal < 0)
{
ERR_PRINT(lRetVal);
LOOP_FOREVER();
}
//Init Temprature Sensor
lRetVal = TMP006DrvOpen();
if(lRetVal < 0)
{
ERR_PRINT(lRetVal);
LOOP_FOREVER();
}
//Init Accelerometer Sensor
lRetVal = BMA222Open();
if(lRetVal < 0)
{
ERR_PRINT(lRetVal);
LOOP_FOREVER();
}
//
// Simplelinkspawntask
//
lRetVal = VStartSimpleLinkSpawnTask(SPAWN_TASK_PRIORITY);
if(lRetVal < 0)
{
ERR_PRINT(lRetVal);
LOOP_FOREVER();
}
//
// Create OOB Task
//
lRetVal = osi_TaskCreate(OOBTask, (signed char*)"OOBTask", \
OSI_STACK_SIZE, NULL, \
OOB_TASK_PRIORITY, NULL );
if(lRetVal < 0)
{
ERR_PRINT(lRetVal);
LOOP_FOREVER();
}
//
// Start OS Scheduler
//
osi_start();
while (1)
{
}
}
//*****************************************************************************
// MAIN FUNCTION
//*****************************************************************************
void main()
{
long lRetVal = -1;
//
// Board Initialization
//
BoardInit();
//
// configure the GPIO pins for LEDs,UART
//
PinMuxConfig();
//
// Configure the UART
//
#ifndef NOTERM
InitTerm();
#endif //NOTERM
//
// Display Application Banner
//
DisplayBanner(APPLICATION_NAME);
//
// Configure all 3 LEDs
//
GPIO_IF_LedConfigure(LED1|LED2|LED3);
// switch off all LEDs
GPIO_IF_LedOff(MCU_ALL_LED_IND);
//
// SysTick Enabling
//
//SysTickIntRegister(SysTickHandler);
///SysTickPeriodSet(SYSTICK_RELOAD_VALUE);
//SysTickEnable();
//
// Base address for first timer
//
g_ulBase = TIMERA0_BASE;
//
// Configuring the timers
//
Timer_IF_Init(PRCM_TIMERA0, g_ulBase, TIMER_CFG_PERIODIC, TIMER_A, 0);
//
// Setup the interrupts for the timer timeouts.
//
Timer_IF_IntSetup(g_ulBase, TIMER_A, TimerBaseIntHandler);
//
// Turn on the timers feeding values in mSec
//
Timer_IF_Start(g_ulBase, TIMER_A, 1000);
//
// Start the SimpleLink Host
//
lRetVal = VStartSimpleLinkSpawnTask(SPAWN_TASK_PRIORITY);
if(lRetVal < 0)
{
ERR_PRINT(lRetVal);
LOOP_FOREVER();
}
//
// Start the WlanStationMode task
//
lRetVal = osi_TaskCreate( WlanStationMode, \
(const signed char*)"Wlan Station Task", \
OSI_STACK_SIZE, NULL, 1, NULL );
if(lRetVal < 0)
{
ERR_PRINT(lRetVal);
LOOP_FOREVER();
}
//
// Start the task scheduler
//
osi_start();
}
int main()
{
long lRetVal = -1;
//
// Initialize Board configurations
//
BoardInit();
//
// Pinmuxing for GPIO,UART
//
PinMuxConfig();
//
// configure LEDs
//
GPIO_IF_LedConfigure(LED1|LED2|LED3);
GPIO_IF_LedOff(MCU_ALL_LED_IND);
#ifndef NOTERM
//
// Configuring UART
//
InitTerm();
#endif
//
// Display Welcome Message
//
DisplayBanner(APP_NAME);
// Generate Menu Output for Application
OutputMenu();
// Initialize AP security params
SecurityParams.Key = (signed char *)SECURITY_KEY;
SecurityParams.KeyLen = strlen(SECURITY_KEY);
SecurityParams.Type = SECURITY_TYPE;
uiUartCmd=0;
//
// Simplelinkspawntask
//
lRetVal = VStartSimpleLinkSpawnTask(SPAWN_TASK_PRIORITY);
if(lRetVal < 0)
{
ERR_PRINT(lRetVal);
LOOP_FOREVER();
}
lRetVal = osi_MsgQCreate(&g_PBQueue,"PBQueue",sizeof(tPushButtonMsg),1);
if(lRetVal < 0)
{
ERR_PRINT(lRetVal);
LOOP_FOREVER();
}
lRetVal = osi_TaskCreate(PushButtonHandler, \
(signed char*)"PushButtonHandler", \
OSI_STACK_SIZE , NULL, \
TASK_PRIORITY+2, &g_PushButtonTask );
if(lRetVal < 0)
{
ERR_PRINT(lRetVal);
LOOP_FOREVER();
}
lRetVal = osi_TaskCreate(SimpleEmail, (signed char*)"SimpleEmail", \
OSI_STACK_SIZE, \
NULL, TASK_PRIORITY+1, NULL );
if(lRetVal < 0)
{
ERR_PRINT(lRetVal);
LOOP_FOREVER();
}
osi_start();
while(1)
{
}
}
//*****************************************************************************
//
//! \brief the aim of this example code is to demonstrate File-system
//! capabilities of the device.
//! For simplicity, the serial flash is used as the device under test.
//!
//! \param None
//!
//! \return none
//!
//! \note Green LED is turned solid in case of success
//! Red LED is turned solid in case of failure
//
//*****************************************************************************
void main()
{
long lRetVal;
unsigned char policyVal;
long lFileHandle;
unsigned long ulToken;
//
// Initialize Board configurations
//
BoardInit();
//
// Configure the pinmux settings for the peripherals exercised
//
PinMuxConfig();
//
// Configure LEDs
//
GPIO_IF_LedConfigure(LED1|LED3);
GPIO_IF_LedOff(MCU_RED_LED_GPIO);
GPIO_IF_LedOff(MCU_GREEN_LED_GPIO);
//
// Initializing the CC3200 networking layers
//
lRetVal = sl_Start(NULL, NULL, NULL);
if(lRetVal < 0)
{
GPIO_IF_LedOn(MCU_RED_LED_GPIO);
LOOP_FOREVER();
}
//
// reset all network policies
//
lRetVal = sl_WlanPolicySet( SL_POLICY_CONNECTION,
SL_CONNECTION_POLICY(0,0,0,0,0),
&policyVal,
1 /*PolicyValLen*/);
if(lRetVal < 0)
{
GPIO_IF_LedOn(MCU_RED_LED_GPIO);
LOOP_FOREVER();
}
if(WriteFileToDevice(&ulToken, &lFileHandle) < 0)
{
GPIO_IF_LedOn(MCU_RED_LED_GPIO);
LOOP_FOREVER();
}
if(ReadFileFromDevice(ulToken, lFileHandle) < 0)
{
GPIO_IF_LedOn(MCU_RED_LED_GPIO);
LOOP_FOREVER();
}
//
// turn ON the green LED indicating success
//
GPIO_IF_LedOn(MCU_GREEN_LED_GPIO);
lRetVal = sl_Stop(SL_STOP_TIMEOUT);
LOOP_FOREVER();
}
//*****************************************************************************
//
//! Main which invokes the WPS provisioning APIs
//!
//! \param none
//!
//! \return 0
//
//*****************************************************************************
void
main()
{
long lRetVal = -1;
//
// Initialize board configurations
BoardInit();
//
// Configure the pinmux settings for the peripherals exercised
//
PinMuxConfig();
#ifndef NOTERM
//
// Configuring UART
//
InitTerm();
#endif
// configure RED LED
GPIO_IF_LedConfigure(LED1);
GPIO_IF_LedOff(MCU_RED_LED_GPIO);
InitializeAppVariables();
//
// Following function configure the device to default state by cleaning
// the persistent settings stored in NVMEM (viz. connection profiles &
// policies, power policy etc)
//
// Applications may choose to skip this step if the developer is sure
// that the device is in its default state at start of applicaton
//
// Note that all profiles and persistent settings that were done on the
// device will be lost
//
lRetVal = ConfigureSimpleLinkToDefaultState();
if(lRetVal < 0)
{
if (DEVICE_NOT_IN_STATION_MODE == lRetVal)
UART_PRINT("Failed to configure the device in its default state \n\r");
LOOP_FOREVER();
}
UART_PRINT("Device is configured in default state \n\r");
//
// Initialzing the CC3200 networking layers
//
lRetVal = sl_Start(NULL, NULL, NULL);
if (lRetVal < 0 || ROLE_STA != lRetVal)
{
UART_PRINT("Failed to start the device \n\r");
LOOP_FOREVER();
}
UART_PRINT("Device started as STATION \n\r");
//
// Connecting to WLAN AP with WPS security, using Push Button method.
// The AP parameters are set with static values defined at the top.
// After this function call we will be connected and have IP address.
//
lRetVal = WpsConnectPushButton();
if(lRetVal < 0)
{
ERR_PRINT("Connect through push button failed\n\r");
LOOP_FOREVER();
}
//
// Turn ON the RED LED to indicate connection success
//
GPIO_IF_LedOn(MCU_RED_LED_GPIO);
//
// Wait for a while
//
MAP_UtilsDelay(80000000);
//
// Disconnect from the WLAN AP.
// After this function call we will be disconnected
//
lRetVal = WlanDisconnect();
if(lRetVal < 0)
{
ERR_PRINT("Disconect failed\n\r");
LOOP_FOREVER();
}
MAP_UtilsDelay(8000000);
//
// Turn OFF the RED LED to indicate connection disconnected
//
GPIO_IF_LedOff(MCU_RED_LED_GPIO);
//
// Connecting to WLAN AP with WPS security, using Pin Code method.
// The default pin code is as specified in WPS_PIN_CODE.
// The AP parameters are set with static values defined at the top.
// After this function call we will be connected and have IP address.
//
lRetVal = WpsConnectPinCode();
if(lRetVal < 0)
{
ERR_PRINT("Connect through pin code failed\n\r");
LOOP_FOREVER();
}
//
// Turn ON the RED LED to indicate connection success
//
GPIO_IF_LedOn(MCU_RED_LED_GPIO);
//
// Wait for a while
//
MAP_UtilsDelay(80000000);
//
// Disconnect from the WLAN AP.
// After this function call we will be disconnected
//
lRetVal = WlanDisconnect();
if(lRetVal < 0)
{
ERR_PRINT("Disconnect failed\n\r");
LOOP_FOREVER();
}
//
// Turn OFF the RED LED to indicate connection disconnected
//
GPIO_IF_LedOff(MCU_RED_LED_GPIO);
lRetVal = sl_Stop(SL_STOP_TIMEOUT);
while (1)
{
_SlNonOsMainLoopTask();
}
}
int main()
{
long lRetVal = -1;
//
// Initialize Board configurations
//
BoardInit();
//
// Pinmuxing for GPIO, UART
//
PinMuxConfig();
//
// configure LEDs
//
GPIO_IF_LedConfigure(LED1|LED2|LED3);
// off all LEDs
GPIO_IF_LedOff(MCU_ALL_LED_IND);
#ifndef NOTERM
//
// Configuring UART
//
InitTerm();
#endif
//
// Display the Application Banner
//
DisplayBanner(APP_NAME);
UART_PRINT("Scan Wi-FI direct device in your handheld device\n\r");
// Initializing the CC3200 device
lRetVal = StartDeviceInP2P();
if(lRetVal < 0)
{
UART_PRINT("Start Device in P2P mode failed \n\r");
LOOP_FOREVER();
}
lRetVal = P2PConfiguration();
if(lRetVal < 0)
{
UART_PRINT("Setting P2P configuration failed\n\r");
LOOP_FOREVER();
}
/* Connect to configure P2P device */
lRetVal = WlanConnect();
if(lRetVal == 0)
{
GPIO_IF_LedOn(MCU_IP_ALLOC_IND);
}
else
{
UART_PRINT("Reset the device and try again\n\r");
LOOP_FOREVER();
}
if(DisplayIP() < 0)
{
UART_PRINT("Get IP address failed \n\r");
LOOP_FOREVER();
}
UART_PRINT("Send TCP packets from your handheld device to CC3200's IP\n\r");
/*After calling this function, you can start sending data to CC3200 IP
* address on PORT_NUM */
if(!(IS_CONNECT_FAILED(g_ulStatus)))
{
lRetVal = BsdTcpServer(PORT_NUM);
if(lRetVal >= 0)
{
UART_PRINT("Received TCP packets successfully \n\r");
}
else if(lRetVal == CLIENT_DISCONNECTED)
{
UART_PRINT("P2P Client disconnected \n\r");
}
else
{
UART_PRINT("TCP packets receive failed \n\r");
}
}
if(lRetVal >=0)
{
UART_PRINT("Test passed, exiting application... \n\r");
}
else
{
UART_PRINT("Test failed, exiting application... \n\r");
}
// revert Device into STA mode and power off Network Processor
lRetVal = sl_WlanSetMode(ROLE_STA);
if(lRetVal < 0)
{
ERR_PRINT(lRetVal);
LOOP_FOREVER();
}
lRetVal = sl_Stop(SL_STOP_TIMEOUT);
GPIO_IF_LedOff(MCU_IP_ALLOC_IND);
while(1)
{
_SlNonOsMainLoopTask();
}
}
//*****************************************************************************
//
//! Task implementing MQTT client communication to other web client through
//! a broker
//!
//! \param none
//!
//! This function
//! 1. Initializes network driver and connects to the default AP
//! 2. Initializes the mqtt library and set up MQTT connection configurations
//! 3. set up the button events and their callbacks(for publishing)
//! 4. handles the callback signals
//!
//! \return None
//!
//*****************************************************************************
void MqttClient(void *pvParameters)
{
long lRetVal = -1;
int iCount = 0;
int iNumBroker = 0;
int iConnBroker = 0;
event_msg RecvQue;
unsigned char policyVal;
connect_config *local_con_conf = (connect_config *)app_hndl;
//
// Configure LED
//
GPIO_IF_LedConfigure(LED1|LED2|LED3);
GPIO_IF_LedOff(MCU_RED_LED_GPIO);
GPIO_IF_LedOff(MCU_GREEN_LED_GPIO);
//
// Reset The state of the machine
//
Network_IF_ResetMCUStateMachine();
//
// Start the driver
//
lRetVal = Network_IF_InitDriver(ROLE_STA);
if(lRetVal < 0)
{
UART_PRINT("Failed to start SimpleLink Device\n\r",lRetVal);
LOOP_FOREVER();
}
// switch on Green LED to indicate Simplelink is properly up
GPIO_IF_LedOn(MCU_ON_IND);
// Start Timer to blink Red LED till AP connection
LedTimerConfigNStart();
// Initialize AP security params
SecurityParams.Key = (signed char *)SECURITY_KEY;
SecurityParams.KeyLen = strlen(SECURITY_KEY);
SecurityParams.Type = SECURITY_TYPE;
//
// Connect to the Access Point
//
lRetVal = Network_IF_ConnectAP(SSID_NAME, SecurityParams);
if(lRetVal < 0)
{
UART_PRINT("Connection to an AP failed\n\r");
LOOP_FOREVER();
}
lRetVal = sl_WlanProfileAdd(SSID_NAME,strlen(SSID_NAME),0,&SecurityParams,0,1,0);
//set AUTO policy
lRetVal = sl_WlanPolicySet(SL_POLICY_CONNECTION,
SL_CONNECTION_POLICY(1,0,0,0,0),
&policyVal, 1 /*PolicyValLen*/);
//
// Disable the LED blinking Timer as Device is connected to AP
//
LedTimerDeinitStop();
//
// Switch ON RED LED to indicate that Device acquired an IP
//
GPIO_IF_LedOn(MCU_IP_ALLOC_IND);
UtilsDelay(20000000);
GPIO_IF_LedOff(MCU_RED_LED_GPIO);
GPIO_IF_LedOff(MCU_ORANGE_LED_GPIO);
GPIO_IF_LedOff(MCU_GREEN_LED_GPIO);
//
// Register Push Button Handlers
//
Button_IF_Init(pushButtonInterruptHandler2,pushButtonInterruptHandler3);
//
// Initialze MQTT client lib
//
lRetVal = sl_ExtLib_MqttClientInit(&Mqtt_Client);
if(lRetVal != 0)
{
// lib initialization failed
UART_PRINT("MQTT Client lib initialization failed\n\r");
LOOP_FOREVER();
}
/******************* connection to the broker ***************************/
iNumBroker = sizeof(usr_connect_config)/sizeof(connect_config);
if(iNumBroker > MAX_BROKER_CONN)
{
UART_PRINT("Num of brokers are more then max num of brokers\n\r");
LOOP_FOREVER();
}
connect_to_broker:
while(iCount < iNumBroker)
{
//create client context
local_con_conf[iCount].clt_ctx =
sl_ExtLib_MqttClientCtxCreate(&local_con_conf[iCount].broker_config,
&local_con_conf[iCount].CallBAcks,
&(local_con_conf[iCount]));
//
// Set Client ID
//
sl_ExtLib_MqttClientSet((void*)local_con_conf[iCount].clt_ctx,
SL_MQTT_PARAM_CLIENT_ID,
local_con_conf[iCount].client_id,
strlen((char*)(local_con_conf[iCount].client_id)));
//
// Set will Params
//
if(local_con_conf[iCount].will_params.will_topic != NULL)
{
sl_ExtLib_MqttClientSet((void*)local_con_conf[iCount].clt_ctx,
SL_MQTT_PARAM_WILL_PARAM,
&(local_con_conf[iCount].will_params),
sizeof(SlMqttWill_t));
}
//
// setting username and password
//
if(local_con_conf[iCount].usr_name != NULL)
{
sl_ExtLib_MqttClientSet((void*)local_con_conf[iCount].clt_ctx,
SL_MQTT_PARAM_USER_NAME,
local_con_conf[iCount].usr_name,
strlen((char*)local_con_conf[iCount].usr_name));
if(local_con_conf[iCount].usr_pwd != NULL)
{
sl_ExtLib_MqttClientSet((void*)local_con_conf[iCount].clt_ctx,
SL_MQTT_PARAM_PASS_WORD,
local_con_conf[iCount].usr_pwd,
strlen((char*)local_con_conf[iCount].usr_pwd));
}
}
//
// connectin to the broker
//
if((sl_ExtLib_MqttClientConnect((void*)local_con_conf[iCount].clt_ctx,
local_con_conf[iCount].is_clean,
local_con_conf[iCount].keep_alive_time) & 0xFF) != 0)
{
UART_PRINT("\n\rBroker connect fail for conn no. %d \n\r",iCount+1);
//delete the context for this connection
sl_ExtLib_MqttClientCtxDelete(local_con_conf[iCount].clt_ctx);
break;
}
else
{
UART_PRINT("\n\rSuccess: conn to Broker no. %d\n\r ", iCount+1);
local_con_conf[iCount].is_connected = true;
iConnBroker++;
}
//
// Subscribe to topics
//
if(sl_ExtLib_MqttClientSub((void*)local_con_conf[iCount].clt_ctx,
local_con_conf[iCount].topic,
local_con_conf[iCount].qos, TOPIC_COUNT) < 0)
{
UART_PRINT("\n\r Subscription Error for conn no. %d\n\r", iCount+1);
UART_PRINT("Disconnecting from the broker\r\n");
sl_ExtLib_MqttClientDisconnect(local_con_conf[iCount].clt_ctx);
local_con_conf[iCount].is_connected = false;
//delete the context for this connection
sl_ExtLib_MqttClientCtxDelete(local_con_conf[iCount].clt_ctx);
iConnBroker--;
break;
}
else
{
int iSub;
UART_PRINT("Client subscribed on following topics:\n\r");
for(iSub = 0; iSub < local_con_conf[iCount].num_topics; iSub++)
{
UART_PRINT("%s\n\r", local_con_conf[iCount].topic[iSub]);
}
}
iCount++;
}
if(iConnBroker < 1)
{
//
// no succesful connection to broker
//
goto end;
}
iCount = 0;
for(;;)
{
osi_MsgQRead( &g_PBQueue, &RecvQue, OSI_WAIT_FOREVER);
if(PUSH_BUTTON_SW2_PRESSED == RecvQue.event)
{
Button_IF_EnableInterrupt(SW2);
//
// send publish message
//
sl_ExtLib_MqttClientSend((void*)local_con_conf[iCount].clt_ctx,
pub_topic_sw2,data_sw2,strlen((char*)data_sw2),QOS2,RETAIN);
UART_PRINT("\n\r CC3200 Publishes the following message \n\r");
UART_PRINT("Topic: %s\n\r",pub_topic_sw2);
UART_PRINT("Data: %s\n\r",data_sw2);
}
else if(PUSH_BUTTON_SW3_PRESSED == RecvQue.event)
{
Button_IF_EnableInterrupt(SW3);
//
// send publish message
//
sl_ExtLib_MqttClientSend((void*)local_con_conf[iCount].clt_ctx,
pub_topic_sw3,data_sw3,strlen((char*)data_sw3),QOS2,RETAIN);
UART_PRINT("\n\r CC3200 Publishes the following message \n\r");
UART_PRINT("Topic: %s\n\r",pub_topic_sw3);
UART_PRINT("Data: %s\n\r",data_sw3);
}
else if(BROKER_DISCONNECTION == RecvQue.event)
{
iConnBroker--;
/* Derive the value of the local_con_conf or clt_ctx from the message */
sl_ExtLib_MqttClientCtxDelete(((connect_config*)(RecvQue.hndl))->clt_ctx);
if(!IS_CONNECTED(g_ulStatus))
{
UART_PRINT("device has disconnected from AP \n\r");
UART_PRINT("retry connection to the AP\n\r");
while(!(IS_CONNECTED(g_ulStatus)) || !(IS_IP_ACQUIRED(g_ulStatus)))
{
osi_Sleep(10);
}
goto connect_to_broker;
}
if(iConnBroker < 1)
{
//
// device not connected to any broker
//
goto end;
}
}
}
end:
//
// Deinitializating the client library
//
sl_ExtLib_MqttClientExit();
UART_PRINT("\n\r Exiting the Application\n\r");
LOOP_FOREVER();
}
//****************************************************************************
// MAIN FUNCTION
//****************************************************************************
void main()
{
/* Display banner */
Report("\r\n\r\nTexas Instruments CC3200 Application - Powered by 2lemetry's ThingFabric Cloud\r\n\r\n");
BoardInit();
//
// Configure the pinmux settings for the peripherals exercised
//
PinMuxConfig();
PinConfigSet(PIN_58,PIN_STRENGTH_2MA|PIN_STRENGTH_4MA,PIN_TYPE_STD_PD);
//
// UART Init
//
InitTerm();
//
// LED Init
//
GPIO_IF_LedConfigure(LED1);
//Turn Off the LEDs
GPIO_IF_LedOff(MCU_RED_LED_GPIO);
//
// I2C Init
//
I2C_IF_Open(I2C_MASTER_MODE_FST);
//Init Temprature Sensor
TMP006DrvOpen();
//Init Accelerometer Sensor
BMA222Open();
//
// Simplelinkspawntask
//
VStartSimpleLinkSpawnTask(SPAWN_TASK_PRIORITY);
// Create semaphore to indicate CC3200 connected to an access point
if (osi_SyncObjCreate(&semaphore_Connected) != 0)
{
Report("Semaphore not created\r\n");
}
//
// Create OOB Task
//
Report("Starting OOBTask\r\n");
osi_TaskCreate(OOBTask, (signed char*)"OOBTask", OSI_STACK_SIZE, NULL, OOB_TASK_PRIORITY, NULL );
//
// Create mqtt Task
//
Report("Starting mqttTask\r\n");
osi_TaskCreate(mqttTask, (signed char*)"mqttTask", OSI_STACK_SIZE, NULL, OOB_TASK_PRIORITY, NULL );
//
// Start OS Scheduler
//
osi_start();
while (1)
{
}
}
//****************************************************************************
//
//! Task function implementing the UDP client and showcasing the hibernate
//! functionality
//!
//! \param none
//!
//! This function
//! 1. Creates a UDP socket
//! 2. Broadcasts a packet on the socket
//! 3. Closes the socket
//! 4. Enters the HIBernate mode
//!
//! \return None.
//
//****************************************************************************
void HIBUDPBroadcastTask(void *pvParameters)
{
int iSocketDesc;
long lRetVal;
struct sockaddr_in sBroadcastAddr;
char pcBroadcastMessage[]="32xx HIB example application";
//
// Check the wakeup source. If first itme entry or wakeup from HIB
//
if(MAP_PRCMSysResetCauseGet() == 0)
{
DisplayBanner(APPNAME);
DBG_PRINT("HIB: Wake up on Power ON\n\r");
}
else if(MAP_PRCMSysResetCauseGet() == PRCM_HIB_EXIT)
{
DBG_PRINT("HIB: Woken up from Hibernate\n\r");
}
else
{
}
GPIO_IF_LedConfigure(LED1);
GPIO_IF_LedOff(MCU_RED_LED_GPIO);
//
// Configure Timer for blinking the LED for IP acquisition
//
LedTimerConfigNStart();
//
//
// Reset The state of the machine
//
Network_IF_ResetMCUStateMachine();
//
// Start the driver
//
lRetVal = Network_IF_InitDriver(ROLE_STA);
if(lRetVal < 0)
{
UART_PRINT("Failed to start SimpleLink Device\n\r");
LOOP_FOREVER();
}
// Initialize AP security params
SecurityParams.Key = (signed char*)SECURITY_KEY;
SecurityParams.KeyLen = strlen(SECURITY_KEY);
SecurityParams.Type = SECURITY_TYPE;
//
// Connect to the Access Point
//
lRetVal = Network_IF_ConnectAP(SSID_NAME, SecurityParams);
if(lRetVal < 0)
{
UART_PRINT("Connection to AP failed\n\r",lRetVal);
LOOP_FOREVER();
}
//
// Disable the LED blinking Timer as Device is connected to AP
//
LedTimerDeinitStop();
//
// Switch ON RED LED to indicate that Device acquired an IP
//
GPIO_IF_LedOn(MCU_IP_ALLOC_IND);
//
// Create UDP socket
//
iSocketDesc = sl_Socket(AF_INET, SOCK_DGRAM, 0);
if(iSocketDesc < 0)
{
DBG_PRINT("HIB: Socket create failed\n\r");
goto end;
}
DBG_PRINT("HIB: Socket created\n\r");
//
// Assign socket structure values for a braodcast message
//
sBroadcastAddr.sin_family = AF_INET;
sBroadcastAddr.sin_addr.s_addr= sl_Htonl(0xFFFFFFFF);
sBroadcastAddr.sin_port= sl_Htons(APP_UDP_PORT);
//
// Broadcast message
//
lRetVal = sendto(iSocketDesc, (char *)&pcBroadcastMessage[0],
sizeof(pcBroadcastMessage), 0,
(struct sockaddr *)&sBroadcastAddr,sizeof(sBroadcastAddr));
if(lRetVal < 0)
{
ERR_PRINT(lRetVal);
LOOP_FOREVER();
}
UNUSED(lRetVal);
DBG_PRINT("HIB: sent message\n\r");
//
// Close the socket
//
close(iSocketDesc);
DBG_PRINT("HIB: Socket closed\n\r");
//
// Stop the driver
//
lRetVal = Network_IF_DeInitDriver();
if(lRetVal < 0)
{
UART_PRINT("Failed to stop SimpleLink Device\n\r");
LOOP_FOREVER();
}
//
// Switch Off RED & Green LEDs to indicate that Device is
// disconnected from AP and Simplelink is shutdown
//
GPIO_IF_LedOff(MCU_IP_ALLOC_IND);
GPIO_IF_LedOff(MCU_GREEN_LED_GPIO);
//
// Enter HIB here configuring the wakeup-timer
//
EnterHIBernate();
end:
DBG_PRINT("HIB: Test Complete\n\r");
//
// Loop here
//
LOOP_FOREVER();
}
int main()
{
unsigned char ucP2PParam[4];
long lRetVal = -1;
//
// Initialize Board configurations
//
BoardInit();
//
// Pinmuxing for GPIO, UART
//
PinMuxConfig();
//
// configure LEDs
//
GPIO_IF_LedConfigure(LED1|LED2|LED3);
// off all LEDs
GPIO_IF_LedOff(MCU_ALL_LED_IND);
#ifndef NOTERM
//
// Configuring UART
//
InitTerm();
#endif
//
// Display the Application Banner
//
DisplayBanner(APP_NAME);
UART_PRINT("Scan Wi-FI direct device in your handheld device\n\r");
// Initializing the CC3200 device
lRetVal = StartDeviceInP2P();
if(lRetVal < 0)
{
LOOP_FOREVER(__LINE__);
}
// Set any p2p option (SL_CONNECTION_POLICY(0,0,0,any_p2p,0)) to connect to
// first available p2p device
sl_WlanPolicySet(SL_POLICY_CONNECTION,SL_CONNECTION_POLICY(1,0,0,0,0),NULL,0);
// Set the negotiation role (SL_P2P_ROLE_NEGOTIATE).
// CC3200 will negotiate with remote device GO/client mode.
// Other valid options are:
// - SL_P2P_ROLE_GROUP_OWNER
// - SL_P2P_ROLE_CLIENT
sl_WlanPolicySet(SL_POLICY_P2P, SL_P2P_POLICY(SL_P2P_ROLE_NEGOTIATE,
SL_P2P_NEG_INITIATOR_ACTIVE),NULL,0);
// Set P2P Device name
sl_NetAppSet(SL_NET_APP_DEVICE_CONFIG_ID, NETAPP_SET_GET_DEV_CONF_OPT_DEVICE_URN,
strlen(P2P_DEVICE_NAME), (unsigned char *)P2P_DEVICE_NAME);
// Set P2P device type
sl_WlanSet(SL_WLAN_CFG_P2P_PARAM_ID, WLAN_P2P_OPT_DEV_TYPE,
strlen(P2P_CONFIG_VALUE), (unsigned char*)P2P_CONFIG_VALUE);
// setting P2P channel parameters
ucP2PParam[0] = LISENING_CHANNEL;
ucP2PParam[1] = REGULATORY_CLASS;
ucP2PParam[2] = OPERATING_CHANNEL;
ucP2PParam[3] = REGULATORY_CLASS;
// Set P2P Device listen and open channel valid channels are 1/6/11
sl_WlanSet(SL_WLAN_CFG_P2P_PARAM_ID, WLAN_P2P_OPT_CHANNEL_N_REGS,
sizeof(ucP2PParam), ucP2PParam);
// Restart as P2P device
sl_Stop(SL_STOP_TIMEOUT);
lRetVal = sl_Start(NULL,NULL,NULL);
if(lRetVal < 0 || lRetVal != ROLE_P2P)
{
UART_PRINT("Failed to start the device \n\r");
LOOP_FOREVER(__LINE__);
}
else
{
UART_PRINT("Connect to %s \n\r",P2P_DEVICE_NAME);
}
/* Connect to configure P2P device */
lRetVal = WlanConnect();
if(lRetVal == 0)
{
GPIO_IF_LedOn(MCU_IP_ALLOC_IND);
}
else
{
UART_PRINT("Reset the device and try again\n\r");
LOOP_FOREVER(__LINE__);
}
DisplayIP();
UART_PRINT("Send TCP packets from your handheld device to CC3200's IP\n\r");
/*After calling this function, you can start sending data to CC3200 IP
* address on PORT_NUM */
if(!(IS_CONNECT_FAILED(g_ulStatus)))
BsdTcpServer(PORT_NUM);
UART_PRINT("Received TCP packets successfully \n\r");
// revert Device into STA mode and power off Network Processor
sl_WlanSetMode(ROLE_STA);
sl_Stop(SL_STOP_TIMEOUT);
UART_PRINT("Test passed, exiting application... \n\r");
while(1)
{
_SlNonOsMainLoopTask();
}
}
int connectToAccessPoint(){
long lRetVal = -1;
GPIO_IF_LedConfigure(LED1|LED3);
GPIO_IF_LedOff(MCU_RED_LED_GPIO);
GPIO_IF_LedOff(MCU_GREEN_LED_GPIO);
lRetVal = InitializeAppVariables();
ASSERT_ON_ERROR(lRetVal);
//
// Following function configure the device to default state by cleaning
// the persistent settings stored in NVMEM (viz. connection profiles &
// policies, power policy etc)
//
// Applications may choose to skip this step if the developer is sure
// that the device is in its default state at start of applicaton
//
// Note that all profiles and persistent settings that were done on the
// device will be lost
//
lRetVal = ConfigureSimpleLinkToDefaultState();
if(lRetVal < 0)
{
if (DEVICE_NOT_IN_STATION_MODE == lRetVal)
UART_PRINT("Failed to configure the device in its default state \n\r");
return lRetVal;
}
UART_PRINT("Device is configured in default state \n\r");
CLR_STATUS_BIT_ALL(g_ulStatus);
///
// Assumption is that the device is configured in station mode already
// and it is in its default state
//
lRetVal = sl_Start(0, 0, 0);
if (lRetVal < 0 || ROLE_STA != lRetVal)
{
UART_PRINT("Failed to start the device \n\r");
return lRetVal;
}
UART_PRINT("Device started as STATION \n\r");
//
//Connecting to WLAN AP
//
lRetVal = WlanConnect();
if(lRetVal < 0)
{
UART_PRINT("Failed to establish connection w/ an AP \n\r");
GPIO_IF_LedOn(MCU_RED_LED_GPIO);
return lRetVal;
}
UART_PRINT("Connection established w/ AP and IP is aquired \n\r");
return 0;
}
int main(void)
{
long lRetVal = -1;
//
// Initialize Board configurations
//
BoardInit();
//
// Configure the pinmux settings for the peripherals exercised
//
PinMuxConfig();
#ifndef NOTERM
InitTerm();
#endif
// configure RED LED
GPIO_IF_LedConfigure(LED1);
GPIO_IF_LedOff(MCU_RED_LED_GPIO);
InitializeAppVariables();
//
// Following function configure the device to default state by cleaning
// the persistent settings stored in NVMEM (viz. connection profiles &
// policies, power policy etc)
//
// Applications may choose to skip this step if the developer is sure
// that the device is in its default state at start of applicaton
//
// Note that all profiles and persistent settings that were done on the
// device will be lost
//
lRetVal = ConfigureSimpleLinkToDefaultState();
if(lRetVal < 0)
{
if (DEVICE_NOT_IN_STATION_MODE == lRetVal)
UART_PRINT("Failed to configure the device in its "
"default state \n\r");
LOOP_FOREVER();
}
UART_PRINT("Device is configured in default state \n\r");
CLR_STATUS_BIT_ALL(g_ulStatus);
//Start simplelink
lRetVal = sl_Start(0,0,0);
if (lRetVal < 0 || ROLE_STA != lRetVal)
{
UART_PRINT("Failed to start the device \n\r");
LOOP_FOREVER();
}
UART_PRINT("Device started as STATION \n\r");
/* Connect to our AP using SmartConfig method */
lRetVal = SmartConfigConnect();
if(lRetVal < 0)
{
ERR_PRINT(lRetVal);
}
LOOP_FOREVER();
}
//****************************************************************************
// MAIN FUNCTION
//****************************************************************************
void main()
{
long lRetVal = -1;
//Board Initialization
BoardInit();
//Pin Configuration
PinMuxConfig();
//Change Pin 58 Configuration from Default to Pull Down
MAP_PinConfigSet(PIN_58,PIN_STRENGTH_2MA|PIN_STRENGTH_4MA,PIN_TYPE_STD_PD);
//
// Initialize GREEN and ORANGE LED
//
GPIO_IF_LedConfigure(LED1|LED2|LED3);
//Turn Off the LEDs
GPIO_IF_LedOff(MCU_ALL_LED_IND);
//UART Initialization
MAP_PRCMPeripheralReset(PRCM_UARTA0);
MAP_UARTConfigSetExpClk(CONSOLE,MAP_PRCMPeripheralClockGet(CONSOLE_PERIPH),
UART_BAUD_RATE,(UART_CONFIG_WLEN_8 |
UART_CONFIG_STOP_ONE | UART_CONFIG_PAR_NONE));
//Display Application Banner on UART Terminal
DisplayBanner(APPLICATION_NAME);
//
// Simplelinkspawntask
//
lRetVal = VStartSimpleLinkSpawnTask(SPAWN_TASK_PRIORITY);
if(lRetVal < 0)
{
UART_PRINT("Unable to start simpelink spawn task\n\r");
LOOP_FOREVER();
}
//
// Create HTTP Server Task
//
lRetVal = osi_TaskCreate(HTTPServerTask, (signed char*)"HTTPServerTask",
OSI_STACK_SIZE, NULL, OOB_TASK_PRIORITY, NULL );
if(lRetVal < 0)
{
UART_PRINT("Unable to create task\n\r");
LOOP_FOREVER();
}
//
// Start OS Scheduler
//
osi_start();
while (1)
{
}
}
//******************************************************************************
// MAIN FUNCTION
//******************************************************************************
int main()
{
long lRetVal = -1;
unsigned char RecordPlay;
BoardInit();
//
// Pinmux Configuration
//
PinMuxConfig();
//
// Initialising the UART terminal
//
InitTerm();
//
// Initialising the I2C Interface
//
lRetVal = I2C_IF_Open(1);
if(lRetVal < 0)
{
ERR_PRINT(lRetVal);
LOOP_FOREVER();
}
RecordPlay = I2S_MODE_RX_TX;
g_loopback = 1;
//
// Create RX and TX Buffer
//
if(RecordPlay == I2S_MODE_RX_TX)
{
pRecordBuffer = CreateCircularBuffer(RECORD_BUFFER_SIZE);
if(pRecordBuffer == NULL)
{
UART_PRINT("Unable to Allocate Memory for Tx Buffer\n\r");
LOOP_FOREVER();
}
}
/* Play */
if(RecordPlay & I2S_MODE_TX)
{
pPlayBuffer = CreateCircularBuffer(PLAY_BUFFER_SIZE);
if(pPlayBuffer == NULL)
{
UART_PRINT("Unable to Allocate Memory for Rx Buffer\n\r");
LOOP_FOREVER();
}
}
//
// Configure Audio Codec
//
AudioCodecReset(AUDIO_CODEC_TI_3254, NULL);
AudioCodecConfig(AUDIO_CODEC_TI_3254, AUDIO_CODEC_16_BIT, 16000,
AUDIO_CODEC_STEREO, AUDIO_CODEC_SPEAKER_ALL,
AUDIO_CODEC_MIC_ALL);
AudioCodecSpeakerVolCtrl(AUDIO_CODEC_TI_3254, AUDIO_CODEC_SPEAKER_ALL, 50);
AudioCodecMicVolCtrl(AUDIO_CODEC_TI_3254, AUDIO_CODEC_SPEAKER_ALL, 50);
GPIO_IF_LedConfigure(LED2|LED3);
GPIO_IF_LedOff(MCU_RED_LED_GPIO);
GPIO_IF_LedOff(MCU_GREEN_LED_GPIO);
//
// Configure PIN_01 for GPIOOutput
//
//MAP_PinTypeGPIO(PIN_01, PIN_MODE_0, false);
// MAP_GPIODirModeSet(GPIOA1_BASE, 0x4, GPIO_DIR_MODE_OUT);
//
// Configure PIN_02 for GPIOOutput
//
//MAP_PinTypeGPIO(PIN_02, PIN_MODE_0, false);
// MAP_GPIODirModeSet(GPIOA1_BASE, 0x8, GPIO_DIR_MODE_OUT);
//Turning off Green,Orange LED after i2c writes completed - First Time
GPIO_IF_LedOff(MCU_GREEN_LED_GPIO);
GPIO_IF_LedOff(MCU_ORANGE_LED_GPIO);
//
// Initialize the Audio(I2S) Module
//
AudioInit();
//
// Initialize the DMA Module
//
UDMAInit();
if(RecordPlay & I2S_MODE_TX)
{
UDMAChannelSelect(UDMA_CH5_I2S_TX, NULL);
SetupPingPongDMATransferRx(pPlayBuffer);
}
if(RecordPlay == I2S_MODE_RX_TX)
{
UDMAChannelSelect(UDMA_CH4_I2S_RX, NULL);
SetupPingPongDMATransferTx(pRecordBuffer);
}
//
// Setup the Audio In/Out
//
lRetVal = AudioSetupDMAMode(DMAPingPongCompleteAppCB_opt, \
CB_EVENT_CONFIG_SZ, RecordPlay);
if(lRetVal < 0)
{
ERR_PRINT(lRetVal);
LOOP_FOREVER();
}
AudioCaptureRendererConfigure(AUDIO_CODEC_16_BIT, 16000, AUDIO_CODEC_STEREO, RecordPlay, 1);
//
// Start Audio Tx/Rx
//
Audio_Start(RecordPlay);
//
// Start the simplelink thread
//
lRetVal = VStartSimpleLinkSpawnTask(9);
if(lRetVal < 0)
{
ERR_PRINT(lRetVal);
LOOP_FOREVER();
}
//
// Start the Network Task
//
lRetVal = osi_TaskCreate( Network, (signed char*)"NetworkTask",\
OSI_STACK_SIZE, NULL,
1, &g_NetworkTask );
if(lRetVal < 0)
{
ERR_PRINT(lRetVal);
LOOP_FOREVER();
}
//
// Start the Control Task
//
lRetVal = ControlTaskCreate();
if(lRetVal < 0)
{
ERR_PRINT(lRetVal);
LOOP_FOREVER();
}
//
// Start the Microphone Task
//
lRetVal = osi_TaskCreate( Microphone,(signed char*)"MicroPhone", \
OSI_STACK_SIZE, NULL,
1, &g_MicTask );
if(lRetVal < 0)
{
ERR_PRINT(lRetVal);
LOOP_FOREVER();
}
//
// Start the Speaker Task
//
lRetVal = osi_TaskCreate( Speaker, (signed char*)"Speaker",OSI_STACK_SIZE, \
NULL, 1, &g_SpeakerTask );
if(lRetVal < 0)
{
ERR_PRINT(lRetVal);
LOOP_FOREVER();
}
//
// Start the task scheduler
//
osi_start();
}
// Initialize LEDs
void LedInit() {
GPIO_IF_LedConfigure(LED1|LED2|LED3);
GPIO_IF_LedOff(MCU_ALL_LED_IND);
}
//*****************************************************************************
//
//! This function demonstrates how certificate can be used with SSL.
//! The procedure includes the following steps:
//! 1) connect to an open AP
//! 2) get the server name via a DNS request
//! 3) define all socket options and point to the CA certificate
//! 4) connect to the server via TCP
//!
//! \param None
//!
//! \return 0 on success else error code
//! \return LED1 is turned solid in case of success
//! LED2 is turned solid in case of failure
//!
//*****************************************************************************
static long ssl()
{
SlSockAddrIn_t Addr;
int iAddrSize;
unsigned char ucMethod = SL_SO_SEC_METHOD_SSLV3;
unsigned int uiIP,uiCipher = SL_SEC_MASK_SSL_RSA_WITH_RC4_128_SHA;
long lRetVal = -1;
int iSockID;
GPIO_IF_LedConfigure(LED1|LED3);
GPIO_IF_LedOff(MCU_RED_LED_GPIO);
GPIO_IF_LedOff(MCU_GREEN_LED_GPIO);
lRetVal = InitializeAppVariables();
ASSERT_ON_ERROR(lRetVal);
//
// Following function configure the device to default state by cleaning
// the persistent settings stored in NVMEM (viz. connection profiles &
// policies, power policy etc)
//
// Applications may choose to skip this step if the developer is sure
// that the device is in its default state at start of applicaton
//
// Note that all profiles and persistent settings that were done on the
// device will be lost
//
lRetVal = ConfigureSimpleLinkToDefaultState();
if(lRetVal < 0)
{
if (DEVICE_NOT_IN_STATION_MODE == lRetVal)
UART_PRINT("Failed to configure the device in its default state \n\r");
return lRetVal;
}
UART_PRINT("Device is configured in default state \n\r");
CLR_STATUS_BIT_ALL(g_ulStatus);
///
// Assumption is that the device is configured in station mode already
// and it is in its default state
//
lRetVal = sl_Start(0, 0, 0);
if (lRetVal < 0 || ROLE_STA != lRetVal)
{
UART_PRINT("Failed to start the device \n\r");
return lRetVal;
}
UART_PRINT("Device started as STATION \n\r");
//
//Connecting to WLAN AP
//
lRetVal = WlanConnect();
if(lRetVal < 0)
{
UART_PRINT("Failed to establish connection w/ an AP \n\r");
GPIO_IF_LedOn(MCU_RED_LED_GPIO);
return lRetVal;
}
UART_PRINT("Connection established w/ AP and IP is aquired \n\r");
//Set time of the device for certificate verification.
lRetVal = set_time();
if(lRetVal < 0)
{
UART_PRINT("Unable to set time in the device");
return lRetVal;
}
lRetVal = sl_NetAppDnsGetHostByName(g_Host, strlen((const char *)g_Host),
(unsigned long*)&uiIP, SL_AF_INET);
if(lRetVal < 0)
{
UART_PRINT("Device couldn't retrive the host name \n\r");
GPIO_IF_LedOn(MCU_RED_LED_GPIO);
return lRetVal;
}
Addr.sin_family = SL_AF_INET;
Addr.sin_port = sl_Htons(GOOGLE_DST_PORT);
Addr.sin_addr.s_addr = sl_Htonl(uiIP);
iAddrSize = sizeof(SlSockAddrIn_t);
//
// opens a secure socket
//
iSockID = sl_Socket(SL_AF_INET,SL_SOCK_STREAM, SL_SEC_SOCKET);
if( iSockID < 0 )
{
UART_PRINT("Device unable to create secure socket \n\r");
GPIO_IF_LedOn(MCU_RED_LED_GPIO);
return lRetVal;
}
//
// configure the socket as SSLV3.0
//
lRetVal = sl_SetSockOpt(iSockID, SL_SOL_SOCKET, SL_SO_SECMETHOD, &ucMethod,\
sizeof(ucMethod));
if(lRetVal < 0)
{
UART_PRINT("Device couldn't set socket options \n\r");
GPIO_IF_LedOn(MCU_RED_LED_GPIO);
return lRetVal;
}
//
//configure the socket as RSA with RC4 128 SHA
//
lRetVal = sl_SetSockOpt(iSockID, SL_SOL_SOCKET, SL_SO_SECURE_MASK, &uiCipher,\
sizeof(uiCipher));
if(lRetVal < 0)
{
UART_PRINT("Device couldn't set socket options \n\r");
GPIO_IF_LedOn(MCU_RED_LED_GPIO);
return lRetVal;
}
//
//configure the socket with GOOGLE CA certificate - for server verification
//
lRetVal = sl_SetSockOpt(iSockID, SL_SOL_SOCKET, \
SL_SO_SECURE_FILES_CA_FILE_NAME, \
SL_SSL_CA_CERT_FILE_NAME, \
strlen(SL_SSL_CA_CERT_FILE_NAME));
if(lRetVal < 0)
{
UART_PRINT("Device couldn't set socket options \n\r");
GPIO_IF_LedOn(MCU_RED_LED_GPIO);
return lRetVal;
}
lRetVal = sl_SetSockOpt(iSockID, SL_SOL_SOCKET, \
SO_SECURE_DOMAIN_NAME_VERIFICATION, \
g_Host, strlen((const char *)g_Host));
if( lRetVal < 0 )
{
UART_PRINT("Device couldn't set socket options \n\r");
GPIO_IF_LedOn(MCU_RED_LED_GPIO);
return lRetVal;
}
/* connect to the peer device - Google server */
lRetVal = sl_Connect(iSockID, ( SlSockAddr_t *)&Addr, iAddrSize);
if(lRetVal < 0)
{
UART_PRINT("Device couldn't connect to Google server \n\r");
GPIO_IF_LedOn(MCU_RED_LED_GPIO);
return lRetVal;
}
GPIO_IF_LedOff(MCU_RED_LED_GPIO);
GPIO_IF_LedOn(MCU_GREEN_LED_GPIO);
return SUCCESS;
}
//****************************************************************************
//
//! Task function implementing the gettime functionality using an NTP server
//!
//! \param none
//!
//! This function
//! 1. Initializes the required peripherals
//! 2. Initializes network driver and connects to the default AP
//! 3. Creates a UDP socket, gets the NTP server IP address using DNS
//! 4. Periodically gets the NTP time and displays the time
//!
//! \return None.
//
//****************************************************************************
void GetNTPTimeTask(void *pvParameters)
{
int iSocketDesc;
long lRetVal = -1;
UART_PRINT("GET_TIME: Test Begin\n\r");
//
// Configure LED
//
GPIO_IF_LedConfigure(LED1|LED3);
GPIO_IF_LedOff(MCU_RED_LED_GPIO);
GPIO_IF_LedOff(MCU_GREEN_LED_GPIO);
//
// Reset The state of the machine
//
Network_IF_ResetMCUStateMachine();
//
// Start the driver
//
lRetVal = Network_IF_InitDriver(ROLE_STA);
if(lRetVal < 0)
{
UART_PRINT("Failed to start SimpleLink Device\n\r",lRetVal);
LOOP_FOREVER();
}
// switch on Green LED to indicate Simplelink is properly up
GPIO_IF_LedOn(MCU_ON_IND);
// Start Timer to blink Red LED till AP connection
LedTimerConfigNStart();
// Initialize AP security params
SecurityParams.Key = (signed char *)SECURITY_KEY;
SecurityParams.KeyLen = strlen(SECURITY_KEY);
SecurityParams.Type = SECURITY_TYPE;
//
// Connect to the Access Point
//
lRetVal = Network_IF_ConnectAP(SSID_NAME, SecurityParams);
if(lRetVal < 0)
{
UART_PRINT("Connection to an AP failed\n\r");
LOOP_FOREVER();
}
//
// Disable the LED blinking Timer as Device is connected to AP
//
LedTimerDeinitStop();
//
// Switch ON RED LED to indicate that Device acquired an IP
//
GPIO_IF_LedOn(MCU_IP_ALLOC_IND);
//
// Create UDP socket
//
iSocketDesc = sl_Socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
if(iSocketDesc < 0)
{
ERR_PRINT(iSocketDesc);
goto end;
}
g_sAppData.iSockID = iSocketDesc;
UART_PRINT("Socket created\n\r");
//
// Get the NTP server host IP address using the DNS lookup
//
lRetVal = Network_IF_GetHostIP((char*)g_acSNTPserver, \
&g_sAppData.ulDestinationIP);
if( lRetVal >= 0)
{
struct SlTimeval_t timeVal;
timeVal.tv_sec = SERVER_RESPONSE_TIMEOUT; // Seconds
timeVal.tv_usec = 0; // Microseconds. 10000 microseconds resolution
lRetVal = sl_SetSockOpt(g_sAppData.iSockID,SL_SOL_SOCKET,SL_SO_RCVTIMEO,\
(unsigned char*)&timeVal, sizeof(timeVal));
if(lRetVal < 0)
{
ERR_PRINT(lRetVal);
LOOP_FOREVER();
}
while(1)
{
//
// Get the NTP time and display the time
//
lRetVal = GetSNTPTime(GMT_DIFF_TIME_HRS, GMT_DIFF_TIME_MINS);
if(lRetVal < 0)
{
UART_PRINT("Server Get Time failed\n\r");
break;
}
//
// Wait a while before resuming
//
MAP_UtilsDelay(SLEEP_TIME);
}
}
else
{
UART_PRINT("DNS lookup failed. \n\r");
}
//
// Close the socket
//
close(iSocketDesc);
UART_PRINT("Socket closed\n\r");
end:
//
// Stop the driver
//
lRetVal = Network_IF_DeInitDriver();
if(lRetVal < 0)
{
UART_PRINT("Failed to stop SimpleLink Device\n\r");
LOOP_FOREVER();
}
//
// Switch Off RED & Green LEDs to indicate that Device is
// disconnected from AP and Simplelink is shutdown
//
GPIO_IF_LedOff(MCU_IP_ALLOC_IND);
GPIO_IF_LedOff(MCU_GREEN_LED_GPIO);
UART_PRINT("GET_TIME: Test Complete\n\r");
//
// Loop here
//
LOOP_FOREVER();
}
