//*****************************************************************************
//
//! initDriver
//!
//! @param None
//!
//! @return none
//!
//! @brief The function initializes a CC3000 device and triggers it to
//! start operation
//
//*****************************************************************************
int
initDriver(void)
{
// Init GPIO's
pio_init();
//Init Spi
init_spi();
DispatcherUARTConfigure();
// WLAN On API Implementation
wlan_init( CC3000_UsynchCallback, sendWLFWPatch, sendDriverPatch, sendBootLoaderPatch, ReadWlanInterruptPin, WlanInterruptEnable, WlanInterruptDisable, WriteWlanPin);
// Trigger a WLAN device
wlan_start(0);
// Turn on the LED 5 to indicate that we are active and initiated WLAN successfully
turnLedOn(5);
// Mask out all non-required events from CC3000
wlan_set_event_mask(HCI_EVNT_WLAN_KEEPALIVE|HCI_EVNT_WLAN_UNSOL_INIT|HCI_EVNT_WLAN_ASYNC_PING_REPORT);
// Generate the event to CLI: send a version string
{
char cc3000IP[50];
char *ccPtr;
unsigned short ccLen;
DispatcherUartSendPacket((unsigned char*)pucUARTExampleAppString, sizeof(pucUARTExampleAppString));
ccPtr = &cc3000IP[0];
ccLen = my_itoa(PALTFORM_VERSION, ccPtr);
ccPtr += ccLen;
*ccPtr++ = '.';
ccLen = my_itoa(APPLICATION_VERSION, ccPtr);
ccPtr += ccLen;
*ccPtr++ = '.';
ccLen = my_itoa(SPI_VERSION_NUMBER, ccPtr);
ccPtr += ccLen;
*ccPtr++ = '.';
ccLen = my_itoa(DRIVER_VERSION_NUMBER, ccPtr);
ccPtr += ccLen;
*ccPtr++ = '\f';
*ccPtr++ = '\r';
*ccPtr++ = '\0';
DispatcherUartSendPacket((unsigned char*)cc3000IP, strlen(cc3000IP));
}
wakeup_timer_init();
ucStopSmartConfig = 0;
return(0);
}
main(void)
{
ulCC3000DHCP = 0;
ulCC3000Connected = 0;
ulSocket = 0;
ulSmartConfigFinished=0;
// Board Initialization start
initDriver();
// Initialize the UART RX Buffer
memset(g_ucUARTBuffer, 0xFF, UART_IF_BUFFER);
uart_have_cmd =0;
// Loop forever waiting for commands from PC...
while(1)
{
if (uart_have_cmd && !(UARTBusy(UART0_BASE)) )
{
while(UARTBusy(UART0_BASE));
//Process the cmd in RX buffer
DemoHandleUartCommand(g_ucUARTBuffer);
//Clear cmd and reset buffer pointer
uart_have_cmd = 0;
memset(g_ucUARTBuffer, 0xFF, UART_IF_BUFFER);
}
// complete smart config process:
// 1. if smart config is done
// 2. CC3000 established AP connection
// 3. DHCP IP is configured
// then send mDNS packet to stop external SmartConfig application
if ((ucStopSmartConfig == 1) && (ulCC3000DHCP == 1) && (ulCC3000Connected == 1))
{
unsigned char loop_index = 0;
while (loop_index < 3)
{
mdnsAdvertiser(1,device_name,strlen(device_name));
loop_index++;
}
ucStopSmartConfig = 0;
}
if( (ulCC3000DHCP == 1) && (ulCC3000Connected == 1) && (printOnce == 1) )
{
printOnce = 0;
DispatcherUartSendPacket((unsigned char*)pucCC3000_Rx_Buffer, strlen((char const*)pucCC3000_Rx_Buffer));
}
}
}
//*****************************************************************************
//
//! \brief Starts Smart Configuration
//!
//! \param none
//!
//! \return void
//! \note
//! \warning
//*****************************************************************************
void SmartConfigTask(void* pValue)
{
long lRetVal = -1;
DispatcherUartSendPacket((char*)pucUARTSmartConfigString,
sizeof(pucUARTSmartConfigString));
//Turn off the Network Status LED
GPIO_IF_LedOff(MCU_IP_ALLOC_IND);
LedTimerConfigNStart();
//Reset the Network Status before Entering Smart Config
Network_IF_UnsetMCUMachineState(STATUS_BIT_CONNECTION);
Network_IF_UnsetMCUMachineState(STATUS_BIT_IP_AQUIRED);
lRetVal = SmartConfigConnect();
if(lRetVal < 0)
{
ERR_PRINT(lRetVal);
LOOP_FOREVER();
}
//
// Wait until IP is acquired
//
while (!(IS_CONNECTED(Network_IF_CurrentMCUState())) ||
!(IS_IP_ACQUIRED(Network_IF_CurrentMCUState())));
LedTimerDeinitStop();
// Red LED on
GPIO_IF_LedOn(MCU_IP_ALLOC_IND);
//Enable GPIO Interrupt
Button_IF_EnableInterrupt(SW2);
}
//*****************************************************************************
//
//! 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));
}
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);
}
//*****************************************************************************
//
//! initDriver
//!
//! @param None
//!
//! @return none
//!
//! @brief The function initializes a CC3000 device and triggers it to start
//! operation
//
//*****************************************************************************
int
initDriver(void)
{
// Init GPIO's
pio_init();
// Init Spi
init_spi();
// Enable processor interrupts
MAP_IntMasterEnable();
// WLAN On API Implementation
wlan_init( CC3000_UsynchCallback, sendWLFWPatch, sendDriverPatch,
sendBootLoaderPatch, ReadWlanInterruptPin, WlanInterruptEnable,
WlanInterruptDisable, WriteWlanPin);
// Trigger a WLAN device
wlan_start(0);
// Turn on the LED 1 (RED) to indicate that we are active and initiated WLAN successfully
turnLedOn(1);
// Mask out all non-required events from CC3000
wlan_set_event_mask(HCI_EVNT_WLAN_KEEPALIVE|HCI_EVNT_WLAN_UNSOL_INIT
|HCI_EVNT_WLAN_ASYNC_PING_REPORT);
DispatcherUARTConfigure(SysCtlClockGet());
SysCtlDelay(1000000);
// Generate teh event to CLI: send a version string
{
char cc3000IP[50];
char *ccPtr;
unsigned short ccLen;
DispatcherUartSendPacket((unsigned char*)pucUARTExampleAppString,
sizeof(pucUARTExampleAppString));
ccPtr = &cc3000IP[0];
ccLen = itoa(PALTFORM_VERSION, ccPtr);
ccPtr += ccLen;
*ccPtr++ = '.';
ccLen = itoa(APPLICATION_VERSION, ccPtr);
ccPtr += ccLen;
*ccPtr++ = '.';
ccLen = itoa(SPI_VERSION_NUMBER, ccPtr);
ccPtr += ccLen;
*ccPtr++ = '.';
ccLen = itoa(DRIVER_VERSION_NUMBER, ccPtr);
ccPtr += ccLen;
*ccPtr++ = '\f';
*ccPtr++ = '\r';
*ccPtr++ = '\0';
DispatcherUartSendPacket((unsigned char*)cc3000IP, strlen(cc3000IP));
}
ucStopSmartConfig = 0;
// Configure SysTick to occur X times per second, to use as a time
// reference. Enable SysTick to generate interrupts.
InitSysTick();
return(0);
}
//*****************************************************************************
//
//! \brief Generates Random Message and Sends Email to the preconfigured
//! Recipient Email Id
//!
//! \param pValue - pointer to Input Data
//!
//! \return void
//! \note
//! \warning
//*****************************************************************************
void PushButtonMailSend(void* pValue)
{
int iIndex;
long lRetVal = -1;
// reset Orange LED
GPIO_IF_LedOff(MCU_SENDING_DATA_IND);
if(!IS_CONNECTED(Network_IF_CurrentMCUState()))
{
LedTimerConfigNStart();
lRetVal = Network_IF_ConnectAP(SSID_NAME,SecurityParams);
if(lRetVal < 0)
{
UART_PRINT("Error: %d Connecting to an AP.\n\r",lRetVal);
return;
}
}
//
// 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);
MAP_UtilsDelay(10000);
GenerateRandomMessage();
g_cConnectStatus = sl_NetAppEmailConnect();
// If return -1, throw connect error
if(g_cConnectStatus == -1)
{
DispatcherUartSendPacket((char*)pucUARTErrorSocketCreateString, \
sizeof(pucUARTErrorSocketCreateString));
}
// If return -2, throw socket option error
if(g_cConnectStatus == -2)
{
DispatcherUartSendPacket((char*)pucUARTErrorSocketOptionString, \
sizeof(pucUARTErrorSocketOptionString));
}
if(g_cConnectStatus == 0)
{
SlNetAppServerError_t sEmailErrorInfo;
long lRetCode = SL_EMAIL_ERROR_FAILED;
if((lRetCode = sl_NetAppEmailSend(pcEmailto,pcEmailsubject,\
pcEmailmessage, \
&sEmailErrorInfo)) == SL_EMAIL_ERROR_NONE)
{
// Blink LED7 to indicate email has been sent
for(iIndex=0 ;iIndex<5 ;iIndex++)
{
MAP_UtilsDelay(6000000);
GPIO_IF_LedOff(MCU_SENDING_DATA_IND);
MAP_UtilsDelay(6000000);
GPIO_IF_LedOn(MCU_SENDING_DATA_IND);
}
DispatcherUartSendPacket((char*)putUARTFinishString, \
sizeof(putUARTFinishString));
}
else
{
lRetVal = EmailHandleERROR(lRetCode,(char*)sEmailErrorInfo.Value);
}
UART_PRINT("Cmd#");
}
//Enable GPIO Interrupt
Button_IF_EnableInterrupt(SW3);
return;
}
//*****************************************************************************
//
//! UARTCommandHandler
//!
//! @brief The function handles commands arrived from CLI
//!
//! @param usBuffer is the receive buffer from the UART interface to PC
//!
//! @return 0 on success or error code on failure
//!
//
//*****************************************************************************
long UARTCommandHandler(char *usBuffer)
{
int iIndex = 0;
int iParamcount = 0;
long lRetVal = -1;
signed char cStatus1 = 0;
signed char cStatus2 = 0;
if(usBuffer == NULL)
{
UART_PRINT("Null pointer\r\n");
return -1;
}
switch(usBuffer[1])
{
//**********************************************
// Case 01: Connect to default AP
//**********************************************
case UART_COMMAND_SIMPLE_CONFIG_START:
if(!IS_CONNECTED(Network_IF_CurrentMCUState()))
{
LedTimerConfigNStart();
// Setting Acess Point's security parameters
SecurityParams.Key = (signed char *)SECURITY_KEY;
SecurityParams.KeyLen = strlen(SECURITY_KEY);
SecurityParams.Type = SECURITY_TYPE;
lRetVal = Network_IF_ConnectAP(SSID_NAME,SecurityParams);
if(lRetVal < 0)
{
UART_PRINT("Error: %d Connecting to an AP.", lRetVal);
return lRetVal;
}
}
//
// 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);
DispatcherUartSendPacket((char*)pucUARTOKString,
sizeof(pucUARTOKString));
break;
//**********************************************
// Case 02: Configure sender (source) email
//**********************************************
// TODO Phase 2: Include
/*
case UART_COMMAND_EMAIL_SOURCE:
memset(serveruser,0,sizeof(serveruser));
memset(pcServerpass,0,sizeof(pcServerpass));
pcOfserveruser = &serveruser[0];
ofpcServerpass = &pcServerpass[0];
// '<' To maintain RFC 2821 format
*pcOfserveruser++= '<';
iIndex = 2;
while ((int)usBuffer[iIndex] != 0x0D)
{
//look for comma ',' for separation of params
if((int)usBuffer[iIndex] == 44)
{
iParamcount++;
}
else
{
if(iParamcount==1)
{
//Enter smtp server username (email address)
*pcOfserveruser++ = usBuffer[iIndex];
}
if(iParamcount==2)
{
//Enter username's password
*ofpcServerpass++ = usBuffer[iIndex];
}
}
iIndex++;
}
// '>' To maintain RFC 2821 format
*pcOfserveruser++= '>';
*pcOfserveruser++= '\0';
*ofpcServerpass++= '\0';
//Set variables in smtp.c
cStatus1 = smtpSetVariable(serveruser, USERNAME_VAR);
cStatus2 = smtpSetVariable(pcServerpass, PASSWORD_VAR);
//If error in return
if(cStatus1 == 0 && cStatus2 == 0)
{
DispatcherUartSendPacket((char*)pucUARTOKString, sizeof(pucUARTOKString));
}
else
{
DispatcherUartSendPacket((char*)putUARTErrorInputString, \
sizeof(putUARTErrorInputString));
}
break;
*/
//**********************************************
// Case 03: Configure sender (source) email
//**********************************************
case UART_COMMAND_EMAIL_HEADER:
memset(pcEmailto,0,sizeof(pcEmailto));
pcOfemailto = &pcEmailto[0];
pcOfemailsubject = &pcEmailsubject[0];
// '<' To maintain RFC 2821 format
*pcOfemailto++= '<';
iIndex = 2;
while ((int)usBuffer[iIndex] != 0x0D && usBuffer[iIndex] != '\0')
{
//look for comma ',' for separation of params
if((int)usBuffer[iIndex] == 44)
{
iParamcount++;
}
else
{
if(iParamcount==1)
{
//Enter destination email address
*pcOfemailto++ = usBuffer[iIndex];
}
if(iParamcount==2)
{
//Enter email subject
*pcOfemailsubject++ = usBuffer[iIndex];
}
}
iIndex++;
}
// '>' To maintain RFC 2821 format
*pcOfemailto++= '>';
*pcOfemailto++= '\0';
*pcOfemailsubject= '\0';
SlNetAppDestination_t destEmailAdd;
memcpy(destEmailAdd.Email,pcEmailto,strlen(pcEmailto)+1);
cStatus1 = sl_NetAppEmailSet(SL_NET_APP_EMAIL_ID,NETAPP_DEST_EMAIL, \
strlen(pcEmailto)+1, \
(unsigned char *)&destEmailAdd);
SlNetAppEmailSubject_t emailSubject;
memcpy(emailSubject.Value,pcEmailsubject,strlen(pcEmailsubject)+1);
cStatus2 = sl_NetAppEmailSet(SL_NET_APP_EMAIL_ID,NETAPP_SUBJECT, \
strlen(pcEmailsubject)+1, \
(unsigned char *)&emailSubject);
// Check for Error in setting the variables
if(cStatus1 == 0 && cStatus2 == 0)
{
DispatcherUartSendPacket((char*)pucUARTOKString, \
sizeof(pucUARTOKString));
}
else
{
DispatcherUartSendPacket((char*)putUARTErrorInputString, \
sizeof(putUARTErrorInputString));
}
break;
//**********************************************
// Case 04: Record email message
//**********************************************
case UART_COMMAND_EMAIL_MESSAGE:
pcOfemailmessage = &pcEmailmessage[0];
//Enter "Message"
iIndex =3;
while ((int)usBuffer[iIndex] != 0x0D && usBuffer[iIndex] != '\0')
{
if((int)usBuffer[iIndex] == 62)
{
iParamcount++;
}
else
{
if(iParamcount==0)
{
*pcOfemailmessage++ = usBuffer[iIndex];
}
}
iIndex++;
}
*pcOfemailmessage= '\0';
/* TODO here unsigned char is converting to char */
DispatcherUartSendPacket((char*)pucUARTOKString, \
sizeof(pucUARTOKString));
break;
//**********************************************
// Case 05: Send email message using configurations
//**********************************************
case UART_COMMAND_EMAIL_SEND:
{
// reset Orange LED state
GPIO_IF_LedOff(MCU_SENDING_DATA_IND);
// TODO: If no destination email given, default to hardcoded value
SlNetAppEmailOpt_t eMailServerSetting;
lRetVal = Network_IF_GetHostIP(GMAIL_HOST_NAME, &eMailServerSetting.Ip);
if(lRetVal >= 0)
{
eMailServerSetting.Family = AF_INET;
eMailServerSetting.Port = GMAIL_HOST_PORT;
eMailServerSetting.SecurityMethod = SL_SO_SEC_METHOD_SSLV3;
eMailServerSetting.SecurityCypher = SL_SEC_MASK_SSL_RSA_WITH_RC4_128_MD5;
lRetVal = sl_NetAppEmailSet(SL_NET_APP_EMAIL_ID, \
NETAPP_ADVANCED_OPT, \
sizeof(SlNetAppEmailOpt_t), \
(unsigned char*)&eMailServerSetting);
ASSERT_ON_ERROR(lRetVal);
}
else
{
UART_PRINT("Error:%d GetHostIP.", lRetVal);
return -1;
}
g_cConnectStatus = sl_NetAppEmailConnect();
// If return -1, throw connect error
if(g_cConnectStatus == -1)
{
DispatcherUartSendPacket((char*)pucUARTErrorSocketCreateString, \
sizeof(pucUARTErrorSocketCreateString));
}
// If return -2, throw socket option error
if(g_cConnectStatus == -2)
{
DispatcherUartSendPacket((char*)pucUARTErrorSocketOptionString, \
sizeof(pucUARTErrorSocketOptionString));
}
if(g_cConnectStatus == 0)
{
SlNetAppServerError_t sEmailErrorInfo;
long lRetCode = SL_EMAIL_ERROR_FAILED;
if((lRetCode = sl_NetAppEmailSend(pcEmailto,pcEmailsubject, \
pcEmailmessage, \
&sEmailErrorInfo)) == SL_EMAIL_ERROR_NONE)
{
// Blink LED7 to indicate email has been sent
for(iIndex=0 ;iIndex<5 ;iIndex++)
{
MAP_UtilsDelay(6000000);
GPIO_IF_LedOff(MCU_SENDING_DATA_IND);
MAP_UtilsDelay(6000000);
GPIO_IF_LedOn(MCU_SENDING_DATA_IND);
}
DispatcherUartSendPacket((char*)putUARTFinishString, \
sizeof(putUARTFinishString));
}
else
{
lRetVal = EmailHandleERROR(lRetCode,(char*)sEmailErrorInfo.Value);
ASSERT_ON_ERROR(lRetVal);
}
}
}
break;
case UART_COMMAND_SMART_CONFIG:
GPIO_IF_LedOff(MCU_IP_ALLOC_IND);
DispatcherUartSendPacket((char*)pucUARTSmartConfigString, \
sizeof(pucUARTSmartConfigString));
// Start LED blinking Timer
LedTimerConfigNStart();
//Reset the Network Status before Entering Smart Config
Network_IF_UnsetMCUMachineState(STATUS_BIT_CONNECTION);
Network_IF_UnsetMCUMachineState(STATUS_BIT_IP_AQUIRED);
// start smart config process
lRetVal = SmartConfigConnect();
ASSERT_ON_ERROR(lRetVal);
while (!(IS_CONNECTED(Network_IF_CurrentMCUState())) || \
!(IS_IP_ACQUIRED(Network_IF_CurrentMCUState())))
{
MAP_UtilsDelay(100);
}
LedTimerDeinitStop();
GPIO_IF_LedOn(MCU_IP_ALLOC_IND);
break;
default:
DispatcherUartSendPacket((char*)pucUARTErrorString, \
sizeof(pucUARTErrorString));
break;
}
return SUCCESS;
}
main(void)
{
ulCC3000DHCP = 0;
ulCC3000Connected = 0;
ulSocket = 0;
ulSmartConfigFinished=0;
WDTCTL = WDTPW + WDTHOLD;
// Board Initialization start
initDriver();
// Initialize the UART RX Buffer
memset(g_ucUARTBuffer, 0xFF, UART_IF_BUFFER);
uart_have_cmd =0;
// Loop forever waiting for commands from PC...
while (1)
{
__bis_SR_register(LPM2_bits + GIE);
__no_operation();
if (uart_have_cmd)
{
wakeup_timer_disable();
//Process the cmd in RX buffer
DemoHandleUartCommand(g_ucUARTBuffer);
uart_have_cmd = 0;
memset(g_ucUARTBuffer, 0xFF, UART_IF_BUFFER);
wakeup_timer_init();
}
// complete smart config process:
// 1. if smart config is done
// 2. CC3000 established AP connection
// 3. DHCP IP is configured
// then send mDNS packet to stop external SmartConfig application
if ((ucStopSmartConfig == 1) && (ulCC3000DHCP == 1) && (ulCC3000Connected == 1))
{
unsigned char loop_index = 0;
while (loop_index < 3)
{
mdnsAdvertiser(1,device_name,strlen(device_name));
loop_index++;
}
ucStopSmartConfig = 0;
}
if( (ulCC3000DHCP == 1) && (ulCC3000Connected == 1) && (printOnce == 1) )
{
printOnce = 0;
DispatcherUartSendPacket((unsigned char*)pucCC3000_Rx_Buffer, strlen((char const*)pucCC3000_Rx_Buffer));
}
}
}
//*****************************************************************************
//
//! initDriver
//!
//! \param None
//!
//! \return none
//!
//! \brief The function initializes a CC3000 device and triggers it to start operation
//
//*****************************************************************************
int
initDriver(void)
{
// Init GPIO's
pio_init();
// Init SPI
init_spi();
DispatcherUARTConfigure();
// Globally enable interrupts
__enable_interrupt();
//
// WLAN On API Implementation
//
wlan_init( CC3000_UsynchCallback, sendWLFWPatch, sendDriverPatch, sendBootLoaderPatch, ReadWlanInterruptPin, WlanInterruptEnable, WlanInterruptDisable, WriteWlanPin);
//
// Trigger a WLAN device
//
wlan_start(0);
//
// Mask out all non-required events from CC3000
//
wlan_set_event_mask(HCI_EVNT_WLAN_KEEPALIVE|HCI_EVNT_WLAN_ASYNC_PING_REPORT|HCI_EVNT_WLAN_UNSOL_INIT);
// Generate event to CLI: send a version string
char cc3000IP[50];
char *ccPtr;
unsigned short ccLen;
DispatcherUartSendPacket((unsigned char*)pucUARTExampleAppString, sizeof(pucUARTExampleAppString));
ccPtr = &cc3000IP[0];
ccLen = itoa(PALTFORM_VERSION, ccPtr);
ccPtr += ccLen;
*ccPtr++ = '.';
ccLen = itoa(APPLICATION_VERSION, ccPtr);
ccPtr += ccLen;
*ccPtr++ = '.';
ccLen = itoa(SPI_VERSION_NUMBER, ccPtr);
ccPtr += ccLen;
*ccPtr++ = '.';
ccLen = itoa(DRIVER_VERSION_NUMBER, ccPtr);
ccPtr += ccLen;
*ccPtr++ = '\r';
*ccPtr++ = '\n';
*ccPtr++ = '\0';
ccLen = strlen(cc3000IP);
DispatcherUartSendPacket((unsigned char*)cc3000IP, strlen(cc3000IP));
// CC3000 has been initialized
setCC3000MachineState(CC3000_INIT);
unsigned long aucDHCP, aucARP, aucKeepalive, aucInactivity;
aucDHCP = 14400;
aucARP = 3600;
aucKeepalive = 10;
aucInactivity = 50;
if(netapp_timeout_values(&(aucDHCP), &(aucARP), &(aucKeepalive), &(aucInactivity)) != 0)
{
while(1);
}
return(0);
}
