//*****************************************************************************************************************************
//*****************************************************************************************************************************
//*****************************************************************************************************************************
void waitForConnection(void)
{
setup_data_packet_header();
//RESET ADC and DMA:
refresh_ADC();
ADC_STATE = HALTED;
//RESET DMA STATE.
refresh_DMA();
DMA_STATE = HALTED;
if(currentCC3000State() & CC3000_SERVER_INIT) // Check whether the server functionality is successfully initialized
{
while(1) // Begin waiting for client and handle the connection
{
hci_unsolicited_event_handler();
addrlen = sizeof(clientaddr);
// accept blocks until we receive a connection
while ( (clientDescriptor == -1) || (clientDescriptor == -2) )
{
clientDescriptor = accept(serverSocket, (sockaddr *) &clientaddr, &addrlen);
}
hci_unsolicited_event_handler();
if(clientDescriptor >= 0) // Connection Accepted, Wait for data exchange
{
setCC3000MachineState(CC3000_CLIENT_CONNECTED);
unsolicicted_events_timer_disable();
//**********************
// Important Function. Manages incoming Message aswell as initiating outgoing message.
incomingPacketManager();
//**********************
}
else if(clientDescriptor == SOCKET_INACTIVE_ERR)
{
clientDescriptor = -1;
// Reinitialize the server
shutdownServer();
initServer();
}
if(bytesRecvd < 0){check_socket_connection();} //If the recieve function goes inactive, shuts down. This checks for that case
hci_unsolicited_event_handler();
}
}
}
//*****************************************************************************
//
//! SpiReceiveHandler
//!
//! @param pvBuffer - pointer to the received data buffer
//! The function triggers Received event/data processing
//!
//! @param Pointer to the received data
//! @return none
//!
//! @brief The function triggers Received event/data processing. It is
//! called from the SPI library to receive the data
//
//*****************************************************************************
void SpiReceiveHandler(void *pvBuffer)
{
tSLInformation.usEventOrDataReceived = 1;
tSLInformation.pucReceivedData = (unsigned char *)pvBuffer;
hci_unsolicited_event_handler();
}
void main(void)
{
WDTCTL = WDTPW + WDTHOLD; // Stop WDT
resetCC3000StateMachine(); // Start CC3000 State Machine
initDriver(); // Initialize Board and CC3000
unsolicicted_events_timer_init(); // Initialize CC3000 Unsolicited Events Timer
__enable_interrupt(); // Enable interrupts for UART
DefaultWifiConnection(); // Do a default connection
while (1)
{
hci_unsolicited_event_handler(); // Handle any un-solicited event if required - the function shall be triggered few times in a second
unsolicicted_events_timer_init();
if(currentCC3000State() & CC3000_IP_ALLOC)
{
turnLedOn(CC3000_IP_ALLOC_IND);
unsolicicted_events_timer_disable();
// Attempt to start data server
initServer();
if(currentCC3000State() & CC3000_SERVER_INIT)
{
waitForConnection();
}
else//Wait for a bit, and try again.
{
__delay_cycles(100000);
}
unsolicicted_events_timer_init();
}
}
}
//*****************************************************************************
//
//! exoHAL_SocketSend
//!
//! \param socket - socket handle; buffer - string buffer containing info to
//! send; len - size of string in bytes;
//!
//! \return Number of bytes sent
//!
//! \brief Sends data out the network interface
//
//*****************************************************************************
unsigned char
exoHAL_SocketSend(long socket, char * buffer, unsigned char len)
{
int result;
result = send(socket, buffer, (long)len, 0); //always set flags to 0 for CC3000
hci_unsolicited_event_handler();
return (unsigned char)result;
}
//*****************************************************************************
//
//! SpiReceiveHandler
//!
//! @param pvBuffer - pointer to the received data buffer
//! The function triggers Received event/data processing
//!
//! @param Pointer to the received data
//! @return none
//!
//! @brief The function triggers Received event/data processing. It is
//! called from the SPI library to receive the data
//
//*****************************************************************************
void SpiReceiveHandler(void *pvBuffer)
{
tSLInformation.usEventOrDataReceived = 1;
tSLInformation.pucReceivedData = (unsigned char *)pvBuffer;
// TM_DEBUG("processing spi recieve handler %ul", (unsigned char *)tSLInformation.pucReceivedData[0]);
hci_unsolicited_event_handler();
}
//*****************************************************************************
//
//! SpiReceiveHandler
//!
//! @param pvBuffer - pointer to the received data buffer
//! The function triggers Received event/data processing
//!
//! @param Pointer to the received data
//! @return none
//!
//! @brief The function triggers Received event/data processing. It is
//! called from the SPI library to receive the data
//
//*****************************************************************************
void SpiReceiveHandler(void *pvBuffer)
{
// if (DEBUG_MODE) {
// digitalWrite(DEBUG_LED, HIGH);
// }
tSLInformation.usEventOrDataReceived = 1;
tSLInformation.pucReceivedData = (unsigned char *)pvBuffer;
hci_unsolicited_event_handler();
}
void SpiReceiveHandler(void *pvBuffer)
{
tSLInformation.pucReceivedData = (uint8_t *)pvBuffer;
tSLInformation.usEventOrDataReceived = 1;
uint16_t event_type;
STREAM_TO_UINT16((char *)tSLInformation.pucReceivedData, HCI_EVENT_OPCODE_OFFSET,event_type);
nllvdbg("Evtn:0x%x\n", event_type);
hci_unsolicited_event_handler();
}
//*****************************************************************************
//
// The interrupt handler for the SysTick timer. This handler is called every 1ms
//
//
//*****************************************************************************
void
SysTickHandler(void)
{
static unsigned long ulTickCount = 0;
//
// Increment the tick counter.
//
ulTickCount++;
//Process after 500 ms
if(ulTickCount >= 500)
{
//
// Handle any un-solicited event if required - the function shall be triggered
// few times in a second
//
hci_unsolicited_event_handler();
ulTickCount = 1;
}
}
void SimpleLinkWaitData(uint8_t *pBuf, uint8_t *from, uint8_t *fromlen)
{
/* In the blocking implementation the control to caller will be returned only
* after the end of current transaction, i.e. only after data will be received
*/
nllvdbg("Looking for Data\n");
uint16_t event_type;
uint16_t opcode = tSLInformation.usRxEventOpcode;
do
{
tSLInformation.pucReceivedData = cc3000_wait();
tSLInformation.usEventOrDataReceived = 1;
if (*tSLInformation.pucReceivedData == HCI_TYPE_DATA)
{
tSLInformation.usRxDataPending = 1;
hci_event_handler(pBuf, from, fromlen);
break;
}
else
{
STREAM_TO_UINT16((char *)tSLInformation.pucReceivedData, HCI_EVENT_OPCODE_OFFSET, event_type);
nllvdbg("Evtn:0x%x\n", event_type);
if (hci_unsolicited_event_handler() == 1)
{
nllvdbg("Processed Event 0x%x want Data! Opcode 0x%x\n", event_type, opcode);
}
else
{
nllvdbg("!!!!!opcode 0x%x\n", opcode);
}
UNUSED(event_type);
}
}
while (*tSLInformation.pucReceivedData == HCI_TYPE_EVNT);
nllvdbg("Done for Data 0x%x\n", opcode);
UNUSED(opcode);
}
void SimpleLinkWaitEvent(uint16_t opcode, void *pRetParams)
{
/* In the blocking implementation the control to caller will be returned only
* after the end of current transaction
*/
tSLInformation.usRxEventOpcode = opcode;
nllvdbg("Looking for opcode 0x%x\n", opcode);
uint16_t event_type;
do
{
nllvdbg("cc3000_wait\n");
tSLInformation.pucReceivedData = cc3000_wait();
tSLInformation.usEventOrDataReceived = 1;
STREAM_TO_UINT16((FAR char *)tSLInformation.pucReceivedData,
HCI_EVENT_OPCODE_OFFSET, event_type);
if (*tSLInformation.pucReceivedData == HCI_TYPE_EVNT)
{
nllvdbg("Evtn:0x%x\n", event_type);
}
if (event_type != opcode)
{
if (hci_unsolicited_event_handler() == 1)
{
nllvdbg("Processed Event 0x%x want 0x%x\n", event_type, opcode);
}
}
else
{
nllvdbg("Processing opcode 0x%x\n", opcode);
hci_event_handler(pRetParams, 0, 0);
}
}
while (tSLInformation.usRxEventOpcode != 0);
nllvdbg("Done for opcode 0x%x\n", opcode);
}
/*******************************************************************************
* Function Name : Start_Smart_Config.
* Description : The function triggers a smart configuration process on CC3000.
* Input : None.
* Output : None.
* Return : None.
*******************************************************************************/
void Start_Smart_Config(void)
{
WLAN_SMART_CONFIG_FINISHED = 0;
WLAN_SMART_CONFIG_STOP = 0;
WLAN_SERIAL_CONFIG_DONE = 0;
WLAN_CONNECTED = 0;
WLAN_DHCP = 0;
WLAN_CAN_SHUTDOWN = 0;
SPARK_SOCKET_CONNECTED = 0;
SPARK_HANDSHAKE_COMPLETED = 0;
SPARK_FLASH_UPDATE = 0;
SPARK_LED_FADE = 0;
LED_SetRGBColor(RGB_COLOR_BLUE);
LED_On(LED_RGB);
/* Reset all the previous configuration */
wlan_ioctl_set_connection_policy(DISABLE, DISABLE, DISABLE);
NVMEM_Spark_File_Data[WLAN_POLICY_FILE_OFFSET] = 0;
nvmem_write(NVMEM_SPARK_FILE_ID, 1, WLAN_POLICY_FILE_OFFSET, &NVMEM_Spark_File_Data[WLAN_POLICY_FILE_OFFSET]);
/* Wait until CC3000 is disconnected */
while (WLAN_CONNECTED == 1)
{
//Delay 100ms
Delay(100);
hci_unsolicited_event_handler();
}
/* Create new entry for AES encryption key */
nvmem_create_entry(NVMEM_AES128_KEY_FILEID,16);
/* Write AES key to NVMEM */
aes_write_key((unsigned char *)(&smartconfigkey[0]));
wlan_smart_config_set_prefix((char*)aucCC3000_prefix);
/* Start the SmartConfig start process */
wlan_smart_config_start(1);
WiFiCredentialsReader wifi_creds_reader(wifi_add_profile_callback);
/* Wait for SmartConfig/SerialConfig to finish */
while (!(WLAN_SMART_CONFIG_FINISHED | WLAN_SERIAL_CONFIG_DONE))
{
if(WLAN_DELETE_PROFILES && wlan_ioctl_del_profile(255) == 0)
{
int toggle = 25;
while(toggle--)
{
LED_Toggle(LED_RGB);
Delay(50);
}
NVMEM_Spark_File_Data[WLAN_PROFILE_FILE_OFFSET] = 0;
nvmem_write(NVMEM_SPARK_FILE_ID, 1, WLAN_PROFILE_FILE_OFFSET, &NVMEM_Spark_File_Data[WLAN_PROFILE_FILE_OFFSET]);
WLAN_DELETE_PROFILES = 0;
}
else
{
LED_Toggle(LED_RGB);
Delay(250);
wifi_creds_reader.read();
}
}
LED_On(LED_RGB);
/* read count of wlan profiles stored */
nvmem_read(NVMEM_SPARK_FILE_ID, 1, WLAN_PROFILE_FILE_OFFSET, &NVMEM_Spark_File_Data[WLAN_PROFILE_FILE_OFFSET]);
// if(NVMEM_Spark_File_Data[WLAN_PROFILE_FILE_OFFSET] >= 7)
// {
// if(wlan_ioctl_del_profile(255) == 0)
// NVMEM_Spark_File_Data[WLAN_PROFILE_FILE_OFFSET] = 0;
// }
if(WLAN_SMART_CONFIG_FINISHED)
{
/* Decrypt configuration information and add profile */
wlan_profile_index = wlan_smart_config_process();
}
if(wlan_profile_index != -1)
{
NVMEM_Spark_File_Data[WLAN_PROFILE_FILE_OFFSET] = wlan_profile_index + 1;
}
/* write count of wlan profiles stored */
nvmem_write(NVMEM_SPARK_FILE_ID, 1, WLAN_PROFILE_FILE_OFFSET, &NVMEM_Spark_File_Data[WLAN_PROFILE_FILE_OFFSET]);
/* Configure to connect automatically to the AP retrieved in the Smart config process */
wlan_ioctl_set_connection_policy(DISABLE, DISABLE, ENABLE);
NVMEM_Spark_File_Data[WLAN_POLICY_FILE_OFFSET] = 1;
nvmem_write(NVMEM_SPARK_FILE_ID, 1, WLAN_POLICY_FILE_OFFSET, &NVMEM_Spark_File_Data[WLAN_POLICY_FILE_OFFSET]);
/* Reset the CC3000 */
wlan_stop();
Delay(100);
wlan_start(0);
SPARK_WLAN_STARTED = 1;
/* Mask out all non-required events */
wlan_set_event_mask(HCI_EVNT_WLAN_KEEPALIVE | HCI_EVNT_WLAN_UNSOL_INIT | HCI_EVNT_WLAN_ASYNC_PING_REPORT);
LED_SetRGBColor(RGB_COLOR_GREEN);
LED_On(LED_RGB);
Set_NetApp_Timeout();
WLAN_SMART_CONFIG_START = 0;
}
//*****************************************************************************
//
//! checkWiFiConnected
//!
//! \param None
//!
//! \return TRUE if connected, FALSE if not
//!
//! \brief Checks to see that WiFi is still connected. If not associated
//! with an AP for 5 consecutive retries, it will reset the board.
//
//*****************************************************************************
unsigned char
checkWiFiConnected(void)
{
unsigned char ipInfoFlagSet = 0;
if(!(currentCC3000State() & CC3000_ASSOC)) //try to associate with an Access Point
{
//
// Check whether Smart Config was run previously. If it was, we
// use it to connect to an access point. Otherwise, we connect to the
// default.
//
if((isFTCSet() == 0)&&(ConnectUsingSmartConfig==0)&&(*SmartConfigProfilestored != SMART_CONFIG_SET))
{
// Smart Config not set, check whether we have an SSID
// from the assoc terminal command. If not, use fixed SSID.
//sendString("== ConnectUsingSSID==\r\n");
ConnectUsingSSID(SSID);
}
unsolicicted_events_timer_init();
// Wait until connection is finished
//sendString("== Wait until connection is finished==\r\n");
while (!(currentCC3000State() & CC3000_ASSOC))
{
WDTCTL = WDT_ARST_1000;
__delay_cycles(100);
// Handle any un-solicited event if required - the function will get triggered
// few times in a second
hci_unsolicited_event_handler();
// Check if user pressed button to do Smart Config
if(runSmartConfig == 1)
break;
}
}
// Handle un-solicited events - will be triggered few times per second
hci_unsolicited_event_handler();
WDTCTL = WDTPW + WDTHOLD;
// Check if we are in a connected state. If so, set flags and LED
if(currentCC3000State() & CC3000_IP_ALLOC)
{
unsolicicted_events_timer_disable(); // Turn our timer off since isr-driven routines set LEDs too...
if (obtainIpInfoFlag == FALSE)
{
//sendString("== CC3000_IP_ALLOC_IND==\r\n");
obtainIpInfoFlag = TRUE; // Set flag so we don't constantly turn the LED on
turnLedOn(CC3000_IP_ALLOC_IND);
ipInfoFlagSet = 1;
unsolicicted_events_timer_init();
}
if (obtainIpInfoFlag == TRUE)
{
WDTCTL = WDT_ARST_1000;
//If Smart Config was performed, we need to send complete notification to the configure (Smart Phone App)
if (ConnectUsingSmartConfig==1)
{
mdnsAdvertiser(1,DevServname, sizeof(DevServname));
ConnectUsingSmartConfig = 0;
*SmartConfigProfilestored = SMART_CONFIG_SET;
}
//Start mDNS timer in order to send mDNS Advertisement every 30 seconds
mDNS_packet_trigger_timer_enable();
unsolicicted_events_timer_init();
}
WDTCTL = WDTPW + WDTHOLD;
if( ipInfoFlagSet == 1)
{
// Initialize an Exosite connection
//sendString("== Exosite Activate ==\r\n");
cloud_status = Exosite_Activate();
ipInfoFlagSet = 0;
}
return TRUE;
}
return FALSE;
}
//*****************************************************************************
//
//! main
//!
//! \param None
//!
//! \return none
//!
//! \brief The main loop is executed here
//
//*****************************************************************************
void main(void)
{
unsigned char loopCount = 0;
int loop_time = 2000;
ulCC3000Connected = 0;
SendmDNSAdvertisment = 0;
// Initialize hardware and interfaces
board_init();
initUart();
sendString("System init : \r\n");
// Must initialize one time for MAC address prepare..
if (!Exosite_Init("exosite", "cc3000wifismartconfig", IF_WIFI, 0))
{
show_status();
while(1);
}
// Main Loop
while (1)
{
// Perform Smart Config if button pressed in current run or if flag set in FRAM
// from previous MSP430 Run.
if(runSmartConfig == 1 || *ptrFtcAtStartup == SMART_CONFIG_SET)
{
// Clear flag
ClearFTCflag();
unsetCC3000MachineState(CC3000_ASSOC);
// Start the Smart Config Process
StartSmartConfig();
runSmartConfig = 0;
}
WDTCTL = WDTPW + WDTHOLD;
// If connectivity is good, run the primary functionality
if(checkWiFiConnected())
{
char * pbuf = exo_buffer;
//unsolicicted_events_timer_disable();
if (0 == cloud_status)
{ //check to see if we have a valid connection
loop_time = 2000;
loopCount = 1;
while (loopCount++ <= (WRITE_INTERVAL+1))
{
// WDTCTL = WDT_ARST_1000;
if (Exosite_Read("led7_ctrl", pbuf, EXO_BUFFER_SIZE))
{
// Read success
turnLedOn(CC3000_CLIENT_CONNECTED_IND);
if (!strncmp(pbuf, "0", 1))
turnLedOff(LED7);
else if (!strncmp(pbuf, "1", 1))
turnLedOn(LED7);
}
else
{
if (EXO_STATUS_NOAUTH == Exosite_StatusCode())
{
turnLedOff(CC3000_CLIENT_CONNECTED_IND);
// Activate device again
cloud_status = Exosite_Activate();
}
}
hci_unsolicited_event_handler();
unsolicicted_events_timer_init();
//sendString("== Exosite Read==\r\n");
WDTCTL = WDTPW + WDTHOLD;
busyWait(loop_time); //delay before looping again
}
unsolicicted_events_timer_init();
if (EXO_STATUS_NOAUTH != Exosite_StatusCode())
{
unsigned char sensorCount = 0;
int value;
char strRead[6]; //largest value of an int in ascii is 5 + null terminate
WDTCTL = WDT_ARST_1000;
for (sensorCount = 0; sensorCount < SENSOR_END; sensorCount++)
{
value = getSensorResult(sensorCount); //get the sensor reading
itoa(value, strRead, 10); //convert to a string
unsolicicted_events_timer_init();
//for each reading / data source (alias), we need to build the string "alias=value" (must be URL encoded)
//this is all just an iteration of, for example, Exosite_Write("mydata=hello_world",18);
memcpy(pbuf,&sensorNames[sensorCount][0],strlen(&sensorNames[sensorCount][0])); //copy alias name into buffer
pbuf += strlen(&sensorNames[sensorCount][0]);
*pbuf++ = 0x3d; //put an '=' into buffer
memcpy(pbuf,strRead, strlen(strRead)); //copy value into buffer
pbuf += strlen(strRead);
*pbuf++ = 0x26; //put an '&' into buffer, the '&' ties successive alias=val pairs together
}
pbuf--; //back out the last '&'
WDTCTL = WDT_ARST_1000;
Exosite_Write(exo_buffer,(pbuf - exo_buffer - 1)); //write all sensor values to the cloud
if (EXO_STATUS_OK == Exosite_StatusCode())
{ // Write success
turnLedOn(CC3000_CLIENT_CONNECTED_IND);
}
}
} else {
//we don't have a good connection yet - we keep retrying to authenticate
WDTCTL = WDTPW + WDTHOLD;
//sendString("== Exosite Activate==\r\n");
cloud_status = Exosite_Activate();
if (0 != cloud_status) loop_time = 30000; //delay 30 seconds before retrying...
}
unsolicicted_events_timer_init();
}
WDTCTL = WDTPW + WDTHOLD;
// TODO - make this a sleep instead of busy wait
busyWait(loop_time); //delay before looping again
}
}
/* TODO removed buffer, set it in init */
void cc3000_event::received_handler(uint8_t *buffer) {
_simple_link.set_data_received_flag(1);
_simple_link.set_received_data(buffer);
hci_unsolicited_event_handler();
}
void StartSmartConfig(void)
{
ulSmartConfigFinished = 0;
ulCC3000Connected = 0;
ulCC3000DHCP = 0;
OkToDoShutDown=0;
// Reset all the previous configuration
wlan_ioctl_set_connection_policy(DISABLE, DISABLE, DISABLE);
wlan_ioctl_del_profile(255);
//Wait until CC3000 is disconnected
while (ulCC3000Connected == 1)
{
SysCtlDelay(100);
hci_unsolicited_event_handler();
}
// Start blinking LED1 during Smart Configuration process
turnLedOn(1);
wlan_smart_config_set_prefix((char*)aucCC3000_prefix);
turnLedOff(1);
// Start the SmartConfig start process
wlan_smart_config_start(1);
turnLedOn(1);
// Wait for Smart config to finish
while (ulSmartConfigFinished == 0)
{
turnLedOff(1);
SysCtlDelay(16500000);
turnLedOn(1);
SysCtlDelay(16500000);
}
turnLedOn(1);
// create new entry for AES encryption key
nvmem_create_entry(NVMEM_AES128_KEY_FILEID,16);
// write AES key to NVMEM
aes_write_key((unsigned char *)(&smartconfigkey[0]));
// Decrypt configuration information and add profile
wlan_smart_config_process();
// Configure to connect automatically to the AP retrieved in the
// Smart config process
wlan_ioctl_set_connection_policy(DISABLE, DISABLE, ENABLE);
// reset the CC3000
wlan_stop();
DispatcherUartSendPacket((unsigned char*)pucUARTCommandSmartConfigDoneString,
sizeof(pucUARTCommandSmartConfigDoneString));
SysCtlDelay(100000);
wlan_start(0);
// Mask out all non-required events
wlan_set_event_mask(HCI_EVNT_WLAN_KEEPALIVE|HCI_EVNT_WLAN_UNSOL_INIT|
HCI_EVNT_WLAN_ASYNC_PING_REPORT);
}
//*****************************************************************************
//
//! DemoHandleUartCommand
//!
//! @param buffer
//!
//! @return none
//!
//! @brief The function handles commands arrived from CLI
//
//*****************************************************************************
void
DemoHandleUartCommand(unsigned char *usBuffer)
{
char *pcSsid, *pcData, *pcSockAddrAscii;
unsigned long ulSsidLen, ulDataLength;
volatile signed long iReturnValue;
sockaddr tSocketAddr;
socklen_t tRxPacketLength;
unsigned char pucIP_Addr[4];
unsigned char pucIP_DefaultGWAddr[4];
unsigned char pucSubnetMask[4];
unsigned char pucDNS[4];
// usBuffer[0] contains always 0
// usBuffer[1] maps the command
// usBuffer[2..end] optional parameters
switch(usBuffer[1])
{
// Start a smart configuration process
case UART_COMMAND_CC3000_SIMPLE_CONFIG_START:
StartSmartConfig();
break;
// Start a WLAN Connect process
case UART_COMMAND_CC3000_CONNECT:
{
ulSsidLen = atoc(usBuffer[2]);
pcSsid = (char *)&usBuffer[3];
#ifndef CC3000_TINY_DRIVER
wlan_connect(WLAN_SEC_UNSEC, pcSsid, ulSsidLen,NULL, NULL, 0);
#else
wlan_connect(pcSsid,ulSsidLen);
#endif
}
break;
// Handle open socket command
case UART_COMMAND_SOCKET_OPEN:
// wait for DHCP process to finish. if you are using a static IP address
// please delete the wait for DHCP event - ulCC3000DHCP
while ((ulCC3000DHCP == 0) || (ulCC3000Connected == 0))
{
hci_unsolicited_event_handler();
SysCtlDelay(1000);
}
ulSocket = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
break;
// Handle close socket command
case UART_COMMAND_SOCKET_CLOSE:
closesocket(ulSocket);
ulSocket = 0xFFFFFFFF;
break;
// Handle receive data command
case UART_COMMAND_RCV_DATA:
iReturnValue = recvfrom(ulSocket, pucCC3000_Rx_Buffer,
CC3000_APP_BUFFER_SIZE, 0, &tSocketAddr,
&tRxPacketLength);
if (iReturnValue <= 0)
{
// No data received by device
DispatcherUartSendPacket((unsigned char*)pucUARTNoDataString,
sizeof(pucUARTNoDataString));
}
else
{
// Send data to UART...
DispatcherUartSendPacket(pucCC3000_Rx_Buffer, CC3000_APP_BUFFER_SIZE);
}
break;
// Handle send data command
case UART_COMMAND_SEND_DATA:
// data pointer
pcData = (char *)&usBuffer[4];
// data length to send
ulDataLength = atoshort(usBuffer[2], usBuffer[3]);
pcSockAddrAscii = (pcData + ulDataLength);
// the family is always AF_INET
tSocketAddr.sa_family = atoshort(pcSockAddrAscii[0], pcSockAddrAscii[1]);
// the destination port
tSocketAddr.sa_data[0] = ascii_to_char(pcSockAddrAscii[2], pcSockAddrAscii[3]);
tSocketAddr.sa_data[1] = ascii_to_char(pcSockAddrAscii[4], pcSockAddrAscii[5]);
// the destination IP address
tSocketAddr.sa_data[2] = ascii_to_char(pcSockAddrAscii[6], pcSockAddrAscii[7]);
tSocketAddr.sa_data[3] = ascii_to_char(pcSockAddrAscii[8], pcSockAddrAscii[9]);
tSocketAddr.sa_data[4] = ascii_to_char(pcSockAddrAscii[10], pcSockAddrAscii[11]);
tSocketAddr.sa_data[5] = ascii_to_char(pcSockAddrAscii[12], pcSockAddrAscii[13]);
sendto(ulSocket, pcData, ulDataLength, 0, &tSocketAddr, sizeof(sockaddr));
break;
// Handle bind command
case UART_COMMAND_BSD_BIND:
tSocketAddr.sa_family = AF_INET;
// the source port
tSocketAddr.sa_data[0] = ascii_to_char(usBuffer[2], usBuffer[3]);
tSocketAddr.sa_data[1] = ascii_to_char(usBuffer[4], usBuffer[5]);
// all 0 IP address
memset (&tSocketAddr.sa_data[2], 0, 4);
bind(ulSocket, &tSocketAddr, sizeof(sockaddr));
break;
// Handle IP configuration command
case UART_COMMAND_IP_CONFIG:
// Network mask is assumed to be 255.255.255.0
pucSubnetMask[0] = 0xFF;
pucSubnetMask[1] = 0xFF;
pucSubnetMask[2] = 0xFF;
pucSubnetMask[3] = 0x0;
pucIP_Addr[0] = ascii_to_char(usBuffer[2], usBuffer[3]);
pucIP_Addr[1] = ascii_to_char(usBuffer[4], usBuffer[5]);
pucIP_Addr[2] = ascii_to_char(usBuffer[6], usBuffer[7]);
pucIP_Addr[3] = ascii_to_char(usBuffer[8], usBuffer[9]);
pucIP_DefaultGWAddr[0] = ascii_to_char(usBuffer[10], usBuffer[11]);
pucIP_DefaultGWAddr[1] = ascii_to_char(usBuffer[12], usBuffer[13]);
pucIP_DefaultGWAddr[2] = ascii_to_char(usBuffer[14], usBuffer[15]);
pucIP_DefaultGWAddr[3] = ascii_to_char(usBuffer[16], usBuffer[17]);
pucDNS[0] = 0;
pucDNS[1] = 0;
pucDNS[2] = 0;
pucDNS[3] = 0;
netapp_dhcp((unsigned long *)pucIP_Addr, (unsigned long *)pucSubnetMask,
(unsigned long *)pucIP_DefaultGWAddr, (unsigned long *)pucDNS);
break;
// Handle WLAN disconnect command
case UART_COMMAND_CC3000_DISCONNECT:
wlan_disconnect();
break;
// Handle erase policy command
case UART_COMMAND_CC3000_DEL_POLICY:
wlan_ioctl_set_connection_policy(DISABLE, DISABLE, DISABLE);
break;
// Handle send DNS Discovery command
case UART_COMMAND_SEND_DNS_ADVERTIZE:
if(ulCC3000DHCP)
{
mdnsAdvertiser(1,device_name,strlen(device_name));
}
break;
default:
DispatcherUartSendPacket((unsigned char*)pucUARTIllegalCommandString,
sizeof(pucUARTIllegalCommandString));
break;
}
// Send a response - the command handling has finished
DispatcherUartSendPacket((unsigned char *)(pucUARTCommandDoneString),
sizeof(pucUARTCommandDoneString));
}
/*------------------------------------------------------------------------
Spider_SmartConfig
Use Smart config function set Spider connect to a exist AP.
return 0, Connect success.
-----------------------------------------------------------------------*/
int Spider_SmartConfig(void){
SmartConfigFinished = 0;
SpiderConnected = 0;
SpiderDHCP = 0;
SpiderCanShutDown = 0;
// Reset all the previous configuration
wlan_ioctl_set_connection_policy(0, 0, 0);
wlan_ioctl_del_profile(255);
//Wait until Spider is disconnected
while (SpiderConnected == 1){
delay(1);
hci_unsolicited_event_handler();
}
// create new entry for AES encryption key
nvmem_create_entry(NVMEM_AES128_KEY_FILEID, AES128_KEY_SIZE);
// write AES key to NVMEM
aes_write_key((unsigned char *)(&SmartConfig_key[0]));
// Start blinking LED1 during Smart Configuration process
digitalWrite(13, HIGH);
wlan_smart_config_set_prefix((char*)SmartConfig_prefix);
digitalWrite(13, LOW);
// Start the SmartConfig start process
if(wlan_smart_config_start(0) != 0){
return -1;
}
// Wait for Smart config to finish
while (SmartConfigFinished == 0){
digitalWrite(13, HIGH);
delay(500);
digitalWrite(13, LOW);
delay(500);
}
digitalWrite(13, LOW);
// Decrypt configuration information and add profile
//wlan_smart_config_process();
#if 1
// Configure to connect automatically to the AP retrieved in the
// Smart config process
wlan_ioctl_set_connection_policy(0, 0, 1);
// reset the CC3000
wlan_stop();
delay(100);
wlan_start(0);
// Set CC3000 event masking, right now without ping report.
wlan_set_event_mask(HCI_EVNT_WLAN_KEEPALIVE|HCI_EVNT_WLAN_UNSOL_INIT|HCI_EVNT_WLAN_ASYNC_PING_REPORT);
#endif
return 0;
}
