//*****************************************************************************
//
//! \brief This function handles network events such as IP acquisition, IP
//! leased, IP released etc.
//!
//! \param[in] pNetAppEvent - Pointer to NetApp Event Info
//!
//! \return None
//!
//*****************************************************************************
void SimpleLinkNetAppEventHandler(SlNetAppEvent_t *pNetAppEvent)
{
switch(pNetAppEvent->Event)
{
case SL_NETAPP_IPV4_ACQUIRED:
case SL_NETAPP_IPV6_ACQUIRED:
{
SET_STATUS_BIT(g_ulStatus, STATUS_BIT_IP_AQUIRED);
}
break;
case SL_NETAPP_IP_LEASED:
{
SET_STATUS_BIT(g_ulStatus, STATUS_BIT_IP_LEASED);
g_ulStaIp = (pNetAppEvent)->EventData.ipLeased.ip_address;
UART_PRINT("[NETAPP EVENT] IP Leased to Client: IP=%d.%d.%d.%d , ",
SL_IPV4_BYTE(g_ulStaIp,3), SL_IPV4_BYTE(g_ulStaIp,2),
SL_IPV4_BYTE(g_ulStaIp,1), SL_IPV4_BYTE(g_ulStaIp,0));
}
break;
default:
{
UART_PRINT("[NETAPP EVENT] Unexpected event [0x%x] \n\r",
pNetAppEvent->Event);
}
break;
}
}
//****************************************************************************
//
//! Confgiures the mode in which the device will work
//!
//! \param iMode is the current mode of the device
//!
//! This function
//! 1. prompt user for desired configuration and accordingly configure the
//! networking mode(STA or AP).
//! 2. also give the user the option to configure the ssid name in case of
//! AP mode.
//!
//! \return sl_start return value(int).
//
//****************************************************************************
static int ConfigureMode(int iMode)
{
char pcSsidName[33];
long retVal = -1;
UART_PRINT("Enter the AP SSID name: ");
GetSsidName(pcSsidName,33);
retVal = sl_WlanSetMode(ROLE_AP);
ASSERT_ON_ERROR(__LINE__, retVal);
retVal = sl_WlanSet(SL_WLAN_CFG_AP_ID, WLAN_AP_OPT_SSID, strlen(pcSsidName),
(unsigned char*)pcSsidName);
ASSERT_ON_ERROR(__LINE__, retVal);
UART_PRINT("Device is configured in AP mode\n\r");
/* Restart Network processor */
retVal = sl_Stop(SL_STOP_TIMEOUT);
ASSERT_ON_ERROR(__LINE__, retVal);
// reset status bits
CLR_STATUS_BIT_ALL(g_ulStatus);
return sl_Start(NULL,NULL,NULL);
}
//*****************************************************************************
//
//! Check the device mode and switch to P2P mode
//! restart the NWP to activate P2P mode
//!
//! \param None
//!
//! \return status code - Success:0, Failure:-ve
//
//*****************************************************************************
long StartDeviceInP2P()
{
long lRetVal = -1;
// Reset CC3200 Network State Machine
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 application
//
// 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");
//
// Assumption is that the device is configured in station mode already
// and it is in its default state
//
lRetVal = sl_Start(NULL,NULL,NULL);
ASSERT_ON_ERROR(lRetVal);
if(lRetVal != ROLE_P2P)
{
lRetVal = sl_WlanSetMode(ROLE_P2P);
ASSERT_ON_ERROR(lRetVal);
lRetVal = sl_Stop(0xFF);
// reset the Status bits
CLR_STATUS_BIT_ALL(g_ulStatus);
lRetVal = sl_Start(NULL,NULL,NULL);
if(lRetVal < 0 || lRetVal != ROLE_P2P)
{
ASSERT_ON_ERROR(P2P_MODE_START_FAILED);
}
else
{
UART_PRINT("Started SimpleLink Device: P2P Mode\n\r");
return SUCCESS;
}
}
return SUCCESS;
}
//****************************************************************************
//
//! \brief This function handles events for IP address acquisition via DHCP
//! indication
//!
//! \param[in] pNetAppEvent is the event passed to the handler
//!
//! \return None
//
//****************************************************************************
void sl_NetAppEvtHdlr(SlNetAppEvent_t *pNetAppEvent)
{
unsigned char ucQueueMsg = 0;
switch(pNetAppEvent->Event)
{
case SL_NETAPP_IPV4_IPACQUIRED_EVENT:
case SL_NETAPP_IPV6_IPACQUIRED_EVENT:
g_ulIpAddr = pNetAppEvent->EventData.ipAcquiredV4.ip;
ucQueueMsg = (unsigned char)EVENT_IP_ACQUIRED;
if(g_tConnection != 0)
{
osi_MsgQWrite(&g_tConnection, &ucQueueMsg, OSI_WAIT_FOREVER);
}
else
{
UART_PRINT("Error: sl_NetAppEvtHdlr: Queue does not exist\n\r");
while(FOREVER);
}
UART_PRINT("IP: ");
PrintIPAddr(g_ulIpAddr);
UART_PRINT("\n\r");
break;
default:
break;
}
}
//****************************************************************************
//
//! \brief This function handles WLAN events
//!
//! \param[in] pSlWlanEvent is the event passed to the handler
//!
//! \return None
//
//****************************************************************************
void sl_WlanEvtHdlr(SlWlanEvent_t *pSlWlanEvent)
{
unsigned char ucQueueMsg = 0;
switch(pSlWlanEvent->Event)
{
case SL_WLAN_CONNECT_EVENT:
ucQueueMsg = (unsigned char)EVENT_CONNECTION;
if(g_tConnection != 0)
{
osi_MsgQWrite(&g_tConnection, &ucQueueMsg, OSI_WAIT_FOREVER);
}
else
{
UART_PRINT("Error: sl_WlanEvtHdlr: Queue does not exist\n\r");
while(FOREVER);
}
UART_PRINT("C\n\r");
break;
case SL_WLAN_DISCONNECT_EVENT:
ucQueueMsg = (unsigned char)EVENT_DISCONNECTION;
if(g_tConnection != 0)
{
osi_MsgQWrite(&g_tConnection, &ucQueueMsg, OSI_WAIT_FOREVER);
}
else
{
UART_PRINT("Error: sl_WlanEvtHdlr: Queue does not exist\n\r");
while(FOREVER);
}
UART_PRINT("D\n\r");
break;
default:
break;
}
}
//****************************************************************************
//
//! \brief device will try to ping the machine that has just connected to the
//! device.
//!
//! \param ulIpAddr is the ip address of the station which has connected to
//! device
//!
//! \return 0 if ping is successful, -1 for error
//
//****************************************************************************
static int PingTest(unsigned long ulIpAddr)
{
signed long retVal = -1;
SlPingStartCommand_t PingParams;
SlPingReport_t PingReport;
PingParams.PingIntervalTime = PING_INTERVAL;
PingParams.PingSize = PING_PKT_SIZE;
PingParams.PingRequestTimeout = PING_TIMEOUT;
PingParams.TotalNumberOfAttempts = NO_OF_ATTEMPTS;
PingParams.Flags = PING_FLAG;
PingParams.Ip = ulIpAddr; /* Cleint's ip address */
UART_PRINT("Running Ping Test...\n\r");
/* Check for LAN connection */
retVal = sl_NetAppPingStart((SlPingStartCommand_t*)&PingParams, SL_AF_INET,
(SlPingReport_t*)&PingReport, SimpleLinkPingReport);
ASSERT_ON_ERROR(__LINE__, retVal);
while(!IS_PING_DONE(g_ulStatus))
{
// Wait for Ping Event
}
if (g_ulPingPacketsRecv)
{
// LAN connection is successful
UART_PRINT("Ping Test successful\n\r");
return SUCCESS;
}
else
{
// Problem with LAN connection
return LAN_CONNECTION_FAILED;
}
}
static void Init()
{
long lRetVal = -1;
BoardInit();
UDMAInit();
PinMuxConfig();
InitTerm();
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()
;
}
//
// Asumption 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) {
UART_PRINT("Failed to start the device \n\r");
LOOP_FOREVER()
;
}
UART_PRINT("Connecting to AP: '%s'...\r\n", SSID_NAME);
// Connecting to WLAN AP - Set with static parameters defined at common.h
// After this call we will be connected and have IP address
lRetVal = WlanConnect();
if (lRetVal < 0) {
UART_PRINT("Connection to AP failed \n\r");
LOOP_FOREVER()
;
}
UART_PRINT("Connected to AP: '%s' \n\r", SSID_NAME);
#ifdef NEW_ID
iobeam_Reset();
#endif
}
int main()
{
/*
* Preparation
*/
// Board Initialization
BoardInit();
// Configuring UART
InitTerm();
// Connect to AP
// Put your SSID and password in common.h
long lRetVal = ConnectToAP();
if(lRetVal < 0)
{
UART_PRINT("Connection to AP failed\n\r");
LOOP_FOREVER();
}
UART_PRINT("Connected to AP\n\r");
if(lRetVal < 0)
{
LOOP_FOREVER();
}
// Declare thing
Thing_Struct thing;
// Connect to thethingsiO server
lRetVal = ConnectTo_thethingsiO(&thing.thing_client);
if(lRetVal < 0)
{
LOOP_FOREVER();
}
UART_PRINT("Thing client connected\n\r");
// In order to initialize the thing correctly you have to use one of
// following two methods:
// 1. If you have already activated your thing you should set the token
thing.token = "YOUR TOKEN HERE";
// 2. Or if not copy the provided activation code here
// and uncomment the following line
// char *act_code = "YOUR ACTIVATION CODE HERE";
// and activate the thing (uncomment the following line)
// char *token = thing_activate(&thing, act_code);
/* Intializes random number generator */
// time_t t;
// srand((unsigned) time(&t));
while(1)
{
char *sub = thing_subscribe(&thing);
if (strlen(sub) > 0)
{
UART_PRINT(sub);
UART_PRINT("\n\r");
}
// Free memory
free(sub);
}
}
void net_ping(const char *host)
{
SlPingStartCommand_t pingParams = {0};
SlPingReport_t pingReport = {0};
unsigned long ulIpAddr = 0;
CLR_STATUS_BIT(g_ulStatus, STATUS_BIT_PING_DONE);
// Set the ping parameters
pingParams.PingIntervalTime = 1000;
pingParams.PingSize = 20;
pingParams.PingRequestTimeout = 3000;
pingParams.TotalNumberOfAttempts = 3;
pingParams.Flags = 0;
pingParams.Ip = g_ulGatewayIP;
UART_PRINT("ping host: %s\r\n", host);
sl_NetAppDnsGetHostByName((signed char*)host, strlen(host), &ulIpAddr, SL_AF_INET);
UART_PRINT("host ip: 0x%08X\r\n", host);
pingParams.Ip = ulIpAddr;
sl_NetAppPingStart((SlPingStartCommand_t*)&pingParams, SL_AF_INET, (SlPingReport_t*)&pingReport, SimpleLinkPingReport);
while(!IS_PING_DONE(g_ulStatus))
_SlNonOsMainLoopTask();
}
tDSPInstance* DSPCeateInstance(uint32_t signalSize, uint32_t Fs) {
tDSPInstance* tempInstance;
tempInstance = (tDSPInstance*)malloc(sizeof(tDSPInstance));
if (tempInstance == NULL){
UART_PRINT("DSPCreate malloc error!");
LOOP_FOREVER(); //malloc error. heap too small?
return NULL;
}
tempInstance->signalSize = signalSize;
tempInstance->Fs = Fs;
tempInstance->ucpSignal = (unsigned char*)malloc(sizeof(unsigned char)*signalSize);
tempInstance->fpSignal = (float32_t*)malloc(sizeof(float32_t)*signalSize/2);
tempInstance->fftSize = signalSize / 4;
tempInstance->FFTResults = (float32_t*)malloc(sizeof(float32_t)*tempInstance->fftSize);
if (tempInstance->ucpSignal==NULL || \
tempInstance->fpSignal==NULL || \
tempInstance->FFTResults==NULL) {
UART_PRINT("DSPCreate malloc error!");
LOOP_FOREVER(); //malloc error. heap too small?
return NULL;
}
tempInstance->maxEnergyBinIndex = 0;
tempInstance->maxEnergyBinValue = 0;
return tempInstance;
}
//*****************************************************************************
//
//! This function handles socket events indication
//!
//! \param[in] pSock - Pointer to Socket Event Info
//!
//! \return None
//!
//*****************************************************************************
void SimpleLinkSockEventHandler(SlSockEvent_t *pSock)
{
//
// This application doesn't work w/ socket - Events are not expected
//
switch( pSock->Event )
{
case SL_SOCKET_TX_FAILED_EVENT:
switch( pSock->EventData.status )
{
case SL_ECLOSE:
UART_PRINT("[SOCK ERROR] - close socket (%d) operation "
"failed to transmit all queued packets\n\n",
pSock->EventData.sd);
break;
default:
UART_PRINT("[SOCK ERROR] - TX FAILED : socket %d , reason"
"(%d) \n\n",
pSock->EventData.sd, pSock->EventData.status);
}
break;
default:
UART_PRINT("[SOCK EVENT] - Unexpected Event [%x0x]\n\n",pSock->Event);
}
}
//*****************************************************************************
//
//! Function - Read Predefined Values. Populate Key,PlainText,Mode etc from
//! pre-defined Vectors
//!
//! \param ui32Config - Configuration Value (Direction | Mode |KeySize)
//! \out uiConfig - Configuration value
//! \out uiKeySize - Key Size used
//! \out uiIV - Initialization Vector
//! \out puiKey1 - Key Used
//! \out uiDataLength - DataLength Used
//! \out puiResult - Result
//!
//! \return Returns /\e true on success or \e false on failure.
//
//*****************************************************************************
unsigned int *
LoadDefaultValues(unsigned int ui32Config,unsigned int *uiConfig,
unsigned int *uiKeySize,
unsigned int **uiIV,unsigned int **puiKey1,
unsigned int *uiDataLength,unsigned int **puiResult)
{
unsigned int *uiData;
//
// Populate all the out parameters from pre-defined vector
//
*uiConfig=ui32Config;
//
// Read Key and Key size
//
*puiKey1=psAESCBCTestVectors.pui32Key1;
*uiKeySize=psAESCBCTestVectors.ui32KeySize;
//
// Read Initialization Vector
//
*uiIV=&psAESCBCTestVectors.pui32IV[0];
//
// Read Data Length and allocate Result and Data variables accordingly
//
*uiDataLength=psAESCBCTestVectors.ui32DataLength;
*puiResult=(unsigned int*)malloc(*uiDataLength);
if(*puiResult != NULL)
{
memset(*puiResult,0,*uiDataLength);
}
else
{
//Failed to allocate memory
UART_PRINT("Failed to allocate memory");
return 0;
}
uiData=(unsigned int*)malloc(*uiDataLength);
if(uiData != NULL)
{
memset(uiData,0,*uiDataLength);
}
else
{
//Failed to allocate memory
UART_PRINT("Failed to allocate memory");
return 0;
}
//
// Copy Plain Text or Cipher Text into the variable Data
//
if(ui32Config & AES_CFG_DIR_ENCRYPT)
memcpy(uiData,psAESCBCTestVectors.pui32PlainText,*uiDataLength);
else
memcpy(uiData,psAESCBCTestVectors.pui32CipherText,*uiDataLength);
return uiData;
}
void startApplication(void *pvParameters) {
// TODO: Change to your SSID and password
signed char ssid[] = "<wifi ssid>";
signed char key[] = "<wifi password>";
SlSecParams_t keyParams;
keyParams.Type = SL_SEC_TYPE_WPA;
keyParams.Key = key;
keyParams.KeyLen = strlen((char *)key);
initNetwork(ssid, &keyParams);
// TODO: Set to current date/time (within an hour precision)
SlDateTime_t dateTime;
memset(&dateTime, 0, sizeof(dateTime));
dateTime.sl_tm_year = 2015;
dateTime.sl_tm_mon = 3;
dateTime.sl_tm_day = 20;
dateTime.sl_tm_hour = 12;
sl_DevSet(SL_DEVICE_GENERAL_CONFIGURATION, SL_DEVICE_GENERAL_CONFIGURATION_DATE_TIME, sizeof(SlDateTime_t), (unsigned char *)&dateTime);
UART_PRINT("\r\n");
UART_PRINT("[QuickStart] Start application\r\n");
UART_PRINT("\r\n");
// TODO: Add Parse code here
}
void SimpleLinkNetAppEventHandler(SlNetAppEvent_t *pNetAppEvent) {
switch (pNetAppEvent->Event) {
case SL_NETAPP_IPV4_IPACQUIRED_EVENT:
{
UART_PRINT("[QuickStart] IP address : %d.%d.%d.%d\r\n",
SL_IPV4_BYTE(pNetAppEvent->EventData.ipAcquiredV4.ip, 3),
SL_IPV4_BYTE(pNetAppEvent->EventData.ipAcquiredV4.ip, 2),
SL_IPV4_BYTE(pNetAppEvent->EventData.ipAcquiredV4.ip, 1),
SL_IPV4_BYTE(pNetAppEvent->EventData.ipAcquiredV4.ip, 0));
UART_PRINT("[QuickStart] Gateway : %d.%d.%d.%d\r\n",
SL_IPV4_BYTE(pNetAppEvent->EventData.ipAcquiredV4.gateway, 3),
SL_IPV4_BYTE(pNetAppEvent->EventData.ipAcquiredV4.gateway, 2),
SL_IPV4_BYTE(pNetAppEvent->EventData.ipAcquiredV4.gateway, 1),
SL_IPV4_BYTE(pNetAppEvent->EventData.ipAcquiredV4.gateway, 0));
UART_PRINT("[QuickStart] DNS server : %d.%d.%d.%d\r\n",
SL_IPV4_BYTE(pNetAppEvent->EventData.ipAcquiredV4.dns, 3),
SL_IPV4_BYTE(pNetAppEvent->EventData.ipAcquiredV4.dns, 2),
SL_IPV4_BYTE(pNetAppEvent->EventData.ipAcquiredV4.dns, 1),
SL_IPV4_BYTE(pNetAppEvent->EventData.ipAcquiredV4.dns, 0));
SET_STATUS_BIT(g_Status, STATUS_BIT_IP_AQUIRED);
}
break;
default:
break;
}
}
int main(void) {
// init the hardware
initBoard();
UART_PRINT("[Blink] Start application\r\n");
// create the main application message queue
// this call properly enables the OSI scheduler to function
short status = osi_MsgQCreate(&g_ApplicationMessageQueue, "ApplicationMessageQueue", sizeof(ApplicationMessage), 1);
if (status < 0) {
UART_PRINT("[Blink] Create application message queue error\r\n");
ERR_PRINT(status);
LOOP_FOREVER();
}
// start the main application task
// this is necessary because SimpleLink host driver is started by sl_Start(),
// which cannot be called on before the OSI scheduler is started
status = osi_TaskCreate(startApplication, (signed char *)"Blink", OSI_STACK_SIZE, NULL, OOB_TASK_PRIORITY, NULL);
if (status < 0) {
UART_PRINT("[Blink] Start application error\r\n");
ERR_PRINT(status);
LOOP_FOREVER();
}
// start the OSI scheduler
osi_start();
return 0;
}
//*****************************************************************************
//
//! This function handles socket events indication
//!
//! \param[in] pSock - Pointer to Socket Event Info
//!
//! \return None
//!
//*****************************************************************************
void SimpleLinkSockEventHandler(SlSockEvent_t *pSock)
{
if(!pSock)
{
return;
}
switch( pSock->Event )
{
case SL_SOCKET_TX_FAILED_EVENT:
switch( pSock->socketAsyncEvent.SockTxFailData.status)
{
case SL_ECLOSE:
UART_PRINT("[SOCK ERROR] - close socket (%d) operation "
"failed to transmit all queued packets\n\n",
pSock->socketAsyncEvent.SockTxFailData.sd);
break;
default:
UART_PRINT("[SOCK ERROR] - TX FAILED : socket %d , reason "
"(%d) \n\n",
pSock->socketAsyncEvent.SockTxFailData.sd, pSock->socketAsyncEvent.SockTxFailData.status);
break;
}
break;
default:
UART_PRINT("[SOCK EVENT] - Unexpected Event [%x0x]\n\n",pSock->Event);
break;
}
}
//*****************************************************************************
//
//! \brief Function display the application banner
//!
//! \param[in] p_app_name - Application name
//!
//! \return None
//
//*****************************************************************************
static void DisplayBanner(char *p_app_name)
{
UART_PRINT("\n\n\n\r");
UART_PRINT("\t\t *************************************************\n\r");
UART_PRINT("\t\t\t Application Name: %s \n\r", p_app_name);
UART_PRINT("\t\t *************************************************\n\r");
UART_PRINT("\n\n\n\r");
}
//*****************************************************************************
//
//! Application startup display on UART
//!
//! \param none
//!
//! \return none
//!
//*****************************************************************************
static void DisplayBanner(char * AppName) {
UART_PRINT("\n\n\n\r");
UART_PRINT("\t\t *************************************************\n\r");
UART_PRINT("\t\t CC3200 %s Application \n\r", AppName);
UART_PRINT("\t\t *************************************************\n\r");
UART_PRINT("\n\n\n\r");
}
//****************************************************************************
//
//! \brief Handles HTTP Server Task
//!
//! \param[in] pvParameters is the data passed to the Task
//!
//! \return None
//
//****************************************************************************
static void HTTPServerTask(void *pvParameters)
{
long lRetVal = -1;
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");
memset(g_ucSSID,'\0',AP_SSID_LEN_MAX);
//Read Device Mode Configuration
ReadDeviceConfiguration();
//Connect to Network
lRetVal = ConnectToNetwork();
//Stop Internal HTTP Server
lRetVal = sl_NetAppStop(SL_NET_APP_HTTP_SERVER_ID);
if(lRetVal < 0)
{
ERR_PRINT(lRetVal);
LOOP_FOREVER();
}
//Start Internal HTTP Server
lRetVal = sl_NetAppStart(SL_NET_APP_HTTP_SERVER_ID);
if(lRetVal < 0)
{
ERR_PRINT(lRetVal);
LOOP_FOREVER();
}
//Handle Async Events
while(1)
{
}
}
//****************************************************************************
//
//! Parses the write command parameters and invokes the I2C APIs
//!
//! \param pcInpString pointer to the write command parameters
//!
//! This function
//! 1. Parses the write command parameters.
//! 2. Invokes the corresponding I2C APIs
//!
//! \return 0: Success, < 0: Failure.
//
//****************************************************************************
int
ProcessWriteCommand(char *pcInpString)
{
unsigned char ucDevAddr, ucStopBit, ucLen;
unsigned char aucDataBuf[256];
char *pcErrPtr;
int iRetVal, iLoopCnt;
//
// Get the device address
//
pcInpString = strtok(NULL, " ");
RETERR_IF_TRUE(pcInpString == NULL);
ucDevAddr = (unsigned char)strtoul(pcInpString+2, &pcErrPtr, 16);
//
// Get the length of data to be written
//
pcInpString = strtok(NULL, " ");
RETERR_IF_TRUE(pcInpString == NULL);
ucLen = (unsigned char)strtoul(pcInpString, &pcErrPtr, 10);
//RETERR_IF_TRUE(ucLen > sizeof(aucDataBuf));
for(iLoopCnt = 0; iLoopCnt < ucLen; iLoopCnt++)
{
//
// Store the data to be written
//
pcInpString = strtok(NULL, " ");
RETERR_IF_TRUE(pcInpString == NULL);
aucDataBuf[iLoopCnt] =
(unsigned char)strtoul(pcInpString+2, &pcErrPtr, 16);
}
//
// Get the stop bit
//
pcInpString = strtok(NULL, " ");
RETERR_IF_TRUE(pcInpString == NULL);
ucStopBit = (unsigned char)strtoul(pcInpString, &pcErrPtr, 10);
//
// Write the data to the specified address
//
iRetVal = I2C_IF_Write(ucDevAddr, aucDataBuf, ucLen, ucStopBit);
if(iRetVal == SUCCESS)
{
UART_PRINT("I2C Write complete\n\r");
}
else
{
UART_PRINT("I2C Write failed\n\r");
return FAILURE;
}
return SUCCESS;
}
//*****************************************************************************
//
//! DisplayBanner
//!
//! \param none
//!
//! \return none
//!
//*****************************************************************************
static void
DisplayBanner()
{
UART_PRINT("\n\n\n\r");
UART_PRINT("\t\t *********************************************\n\r");
UART_PRINT("\t\t CC3200 Idle Profile Application \n\r");
UART_PRINT("\t\t *********************************************\n\r");
UART_PRINT("\n\n\n\r");
}
//*****************************************************************************
//
//! Application startup display on UART
//!
//! \param none
//!
//! \return none
//!
//*****************************************************************************
void
DisplayBanner()
{
UART_PRINT("\n\n\n\r");
UART_PRINT("\t\t *******************************************\n\r");
UART_PRINT("\t\t CC3200 %s Application \n\r", APP_NAME);
UART_PRINT("\t\t *******************************************\n\r");
UART_PRINT("\n\n\n\r");
}
void SimpleLinkWlanEventHandler(SlWlanEvent_t *pWlanEvent)
{
UART_PRINT("SimpleLinkWlanEventHandler\r\n");
switch(pWlanEvent->Event)
{
case SL_WLAN_CONNECT_EVENT:
{
SET_STATUS_BIT(g_ulStatus, STATUS_BIT_CONNECTION);
//
// Information about the connected AP (like name, MAC etc) will be
// available in 'slWlanConnectAsyncResponse_t'-Applications
// can use it if required
//
// slWlanConnectAsyncResponse_t *pEventData = NULL;
// pEventData = &pWlanEvent->EventData.STAandP2PModeWlanConnected;
//
UART_PRINT("[WLAN EVENT] STA Connected to the AP: %s\n\r",
pWlanEvent->EventData.STAandP2PModeWlanConnected.ssid_name);
}
break;
case SL_WLAN_DISCONNECT_EVENT:
{
slWlanConnectAsyncResponse_t* pEventData = NULL;
CLR_STATUS_BIT(g_ulStatus, STATUS_BIT_CONNECTION);
CLR_STATUS_BIT(g_ulStatus, STATUS_BIT_IP_AQUIRED);
pEventData = &pWlanEvent->EventData.STAandP2PModeDisconnected;
// If the user has initiated 'Disconnect' request,
//'reason_code' is SL_USER_INITIATED_DISCONNECTION
if(SL_USER_INITIATED_DISCONNECTION == pEventData->reason_code)
{
UART_PRINT("[WLAN EVENT]Device disconnected from the AP: %s\r\n",
pWlanEvent->EventData.STAandP2PModeWlanConnected.ssid_name);
}
else
{
UART_PRINT("[WLAN ERROR]Device disconnected from the AP AP: %s\r\n",
pWlanEvent->EventData.STAandP2PModeWlanConnected.ssid_name);
}
}
break;
default:
{
UART_PRINT("[WLAN EVENT] Unexpected event [0x%x]\n\r",
pWlanEvent->Event);
}
break;
}
}
int VerifyFile(const char *fileToVerify, const char *fileWithSHAHash) {
unsigned long sToken = 0;
long sfileHandle = -1;
uint8_t firstHash[20];
uint8_t secoundHash[21];
long retVal;
memset(firstHash, 0, sizeof(firstHash));
memset(secoundHash, 0, sizeof(secoundHash));
// get hash of file to verify
if (ComputeSHA(fileToVerify, firstHash) < 0) {
UART_PRINT("Error computing SHA1SUM of %s\r\n", fileToVerify);
return -1;
}
// open the source file for reading
retVal = sl_FsOpen((unsigned char *) fileWithSHAHash, FS_MODE_OPEN_READ, &sToken, &sfileHandle);
if (retVal < 0) {
UART_PRINT("Error during opening the source file %s\r\n", fileWithSHAHash);
return -1;
}
// transform the hash from file with sha hash to byte values. The Sha1Sum is decoded in ascii chars
unsigned int i;
for (i = 0; i < sizeof(firstHash); i++) {
retVal = sl_FsRead(sfileHandle, i * 2, (unsigned char *) &secoundHash[i], 2);
if (retVal < 0) {
// Error close the file and delete the temporary file
retVal = sl_FsClose(sfileHandle, 0, 0, 0);
UART_PRINT("Error during reading the file\r\n");
return -1;
}
uint8_t tempValue;
if (secoundHash[i] > '9') tempValue = (secoundHash[i] - 'a' + 10) << 4;
else tempValue = (secoundHash[i] - '0') << 4;
if (secoundHash[i + 1] > '9') tempValue += (secoundHash[i + 1] - 'a' + 10);
else tempValue += (secoundHash[i + 1] - '0');
secoundHash[i] = tempValue;
}
// Close the opened files
retVal = sl_FsClose(sfileHandle, 0, 0, 0);
if (retVal < 0) {
// Error close the file and delete the temporary file
UART_PRINT("Error during close the file\r\n");
return -1;
}
if (memcmp(secoundHash, firstHash, sizeof(firstHash)) != 0) {
UART_PRINT("\r\nHash-Sums are different\r\n");
return -1;
}
return 0;
}
//*****************************************************************************
//
//! Initiates HIRCP connection sequence.
//!
//! \param None.
//!
//! \return Returns \b true if the connection was successful and \b false
//! otherwise.
//
//*****************************************************************************
tBoolean HIRCP_InitiateConnectionSequence(void)
{
long lRetVal = 0;
unsigned char recv_data[HIRCP_MAX_PACKET_LEN];
unsigned char send_data[HIRCP_MAX_PACKET_LEN];
unsigned char recv_payload[HIRCP_MAX_PAYLOAD_LEN];
unsigned char send_payload[HIRCP_MAX_PAYLOAD_LEN];
HIRCP_Packet *sendPacket = HIRCP_CreatePacket();
HIRCP_Packet *recvPacket = HIRCP_CreatePacket();
//
// Receive CRQ packet
//
lRetVal = BsdTcpServerReceive(recv_data, HIRCP_MAX_PACKET_LEN);
if (lRetVal < 0)
{
return false;
}
HIRCP_Populate(recvPacket, recv_data, HIRCP_MAX_PACKET_LEN);
if (!HIRCP_IsValid(recvPacket) || !(HIRCP_GetType(recvPacket) == HIRCP_CRQ))
{
return false;
}
//
// Check for mode
//
HIRCP_GetPayload(recvPacket, recv_payload, HIRCP_MAX_PAYLOAD_LEN);
if (recv_payload[0] != HIRCP_NORMAL && recv_payload[0] != HIRCP_CLOSED_LOOP)
{
UART_PRINT("Invalid mode.\n\r");
return false;
}
g_hircp_mode = recv_payload[0];
UART_PRINT("Received CRQ packet.\n\r");
//
// Send ACK packet
//
HIRCP_ClearPacket(sendPacket);
HIRCP_SetType(sendPacket, HIRCP_ACK);
HIRCP_GetData(sendPacket, send_data, HIRCP_MAX_PACKET_LEN);
lRetVal = BsdTcpServerSend(send_data, HIRCP_MAX_PACKET_LEN);
if (lRetVal < 0)
{
return false;
}
UART_PRINT("Sent ACK packet.\n\r");
HIRCP_DestroyPacket(sendPacket);
HIRCP_DestroyPacket(recvPacket);
return true;
}
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
}
//*****************************************************************************
//!
//! Initialize Scatter Gather DMA Transfer
//!
//! \param None
//!
//! \return None
//!
//*****************************************************************************
void
InitSGTransfer()
{
int i;
char * pvSrcBuf,*pvDstBuf;
//
// Source Buffer
//
pvSrcBuf=malloc(BUFF_SIZE);
if(pvSrcBuf == NULL)
{
UART_PRINT("Failed to allocate Src buffer\n\r");
return ;
}
for(i=0;i<BUFF_SIZE;i++)
*(pvSrcBuf+i)=i;
MAP_uDMAChannelAssign(UDMA_CH0_SW);
MAP_uDMAChannelAttributeDisable(UDMA_CH0_SW,UDMA_ATTR_ALTSELECT);
iDone=0;
pvDstBuf=malloc(BUFF_SIZE);
if(pvDstBuf == NULL)
{
UART_PRINT("Failed to allocate Dst buffer\n\r");
return ;
}
//
// Call to Set Up Scatter Gather Mode Transfer
//
SetupSGMemTransfer(UDMA_CH0_SW,pvSrcBuf,pvSrcBuf+BUFF_SIZE/2,
pvDstBuf,BUFF_SIZE/2);
MAP_uDMAChannelRequest(UDMA_CH0_SW);
//
// Checking for the Completion
//
while(!iDone);
//
// Checking Correctness of SG Transfer
//
if(memcmp(pvSrcBuf,pvDstBuf,BUFF_SIZE)==0)
UART_PRINT("SG Mode Memory to Memory Transfer Completed \n\r\n\r");
else
UART_PRINT("SG Mode Memory to Memory Transfer Failed! \n\r\n\r");
free(pvDstBuf);
}
//*****************************************************************************
//
//! ReadFromUser - Populates the parameters from User
//!
//! \param uiConfig Configuration Value
//! \param uiHashLength is the Length of Hash Value
//! \param uiKey is the Key Used
//! \param uiDataLength is the Length of Data
//! \param puiResult is the Result
//!
//! \return pointer to plain text
//!
//*****************************************************************************
unsigned char *
ReadFromUser(unsigned int *uiConfig,unsigned int *uiHashLength,unsigned
char **uiKey,unsigned int *uiDataLength,unsigned char **puiResult)
{
char ucCmdBuffer[520],*pucKeyBuff,*pucMsgBuff;
unsigned char *uiData;
//
// POinting KeyBuffer into appropriate Keys.
//
pucKeyBuff=(char*)&uiHMACKey[0];
*uiKey=(unsigned char*)&uiHMACKey[0];
pucMsgBuff=( char*)&puiPlainMsg[0];
//
// Set Default Values
//
SetKeys();
//
// Usage Display
//
UsageDisplay();
//
// Get the Command
//
UART_PRINT("cmd# ");
GetCmd(ucCmdBuffer,520);
if(SHAMD5Parser(ucCmdBuffer,uiConfig,uiHashLength))
{
if(GetKey(pucKeyBuff))
{
uiData=GetMsg(pucMsgBuff,uiDataLength);
*puiResult=(unsigned char *)malloc(64);
memset(*puiResult,0,64);
}
else
{
UART_PRINT("\n\r Invalid Key \n\r");
return NULL;
}
}
else
{
UART_PRINT("\n\r Wrong Input \n\r");
return NULL;
}
return uiData;
}
//*****************************************************************************
//!
//! Initializes the uDMA software channel to perform a memory to memory uDMA
//! transfer.
//!
//! \param None
//!
//! \return None
//*****************************************************************************
void
InitSWTransfer(void)
{
unsigned int uIdx;
//
// Fill the source memory buffer with a simple incrementing pattern.
//
for(uIdx = 0; uIdx < MEM_BUFFER_SIZE; uIdx++)
{
g_ulSrcBuf[uIdx] = uIdx;
}
//
// Configure the control parameters for the SW channel. The SW channel
// will be used to transfer between two memory buffers, 32 bits at a time.
// Therefore the data size is 32 bits, and the address increment is 32 bits
// for both source and destination. The arbitration size will be set to 8,
// which causes the uDMA controller to rearbitrate after 8 items are
// transferred. This keeps this channel from hogging the uDMA controller
// once the transfer is started, and allows other channels cycles if they
// are higher priority.
//
UDMASetupTransfer(UDMA_CH0_SW, UDMA_MODE_AUTO, MEM_BUFFER_SIZE,
UDMA_SIZE_32, UDMA_ARB_8,g_ulSrcBuf, UDMA_SRC_INC_32,
g_ulDstBuf, UDMA_DST_INC_32);
if(StartAndCompleteSWTransfer(UDMA_CH0_SW))
{
UART_PRINT("Memory to Memory Transfer Error \n\r");
}
//
// Verifying the transfered Data
//
for(uIdx = 0; uIdx < MEM_BUFFER_SIZE; uIdx++)
{
if(uIdx!=g_ulDstBuf[uIdx])
{
UART_PRINT("Data transfered in Auto mode is Incorrect at %d th "
"location \n\r\n\r",uIdx);
Done=1;
return;
}
}
UART_PRINT("Data transfered in Auto mode is verified \n\r\n\r");
Done=1;
}
//****************************************************************************
//
//! \brief This function handles WLAN events
//!
//! \param[in] pSlWlanEvent is the event passed to the handler
//!
//! \return None
//
//****************************************************************************
void sl_WlanEvtHdlr(SlWlanEvent_t *pSlWlanEvent)
{
switch(pSlWlanEvent->Event)
{
case SL_WLAN_CONNECT_EVENT:
UART_PRINT("C\n\r");
break;
case SL_WLAN_DISCONNECT_EVENT:
UART_PRINT("D\n\r");
break;
default:
break;
}
}
