uint8_t nvmem_write_patch(unsigned long ulFileId, unsigned long spLength,
const uint8_t *spData)
{
uint8_t status = 0;
uint16_t offset = 0;
uint8_t *spDataPtr = (uint8_t*)spData;
while ((status == 0) && (spLength >= SP_PORTION_SIZE))
{
status = nvmem_write(ulFileId, SP_PORTION_SIZE, offset, spDataPtr);
offset += SP_PORTION_SIZE;
spLength -= SP_PORTION_SIZE;
spDataPtr += SP_PORTION_SIZE;
}
if (status !=0)
{
/* NVMEM error occurred */
return status;
}
if (spLength != 0)
{
/* if reached here, a reminder is left */
status = nvmem_write(ulFileId, spLength, offset, spDataPtr);
}
return status;
}
/*****************************************************************************
* \brief Write data to nvmem.
*
* program a patch to a specific file ID.
* The SP data is assumed to be organized in 2-dimentional.
* Each line is 150 bytes long.
* Actual programming is applied in 150 bytes portions (SP_PORTION_SIZE).
*
* \param[in] ulFileId nvmem file id:\n
* NVMEM_WLAN_DRIVER_SP_FILEID,
* NVMEM_WLAN_FW_SP_FILEID,
* \param[in] spLength number of bytes to write
* \param[in] spData SP data to write
*
* \return on succes 0, error otherwise.
*
* \sa
* \note
* \warning
*
*****************************************************************************/
unsigned char nvmem_write_patch(unsigned long ulFileId, unsigned long spLength, const unsigned char *spData)
{
unsigned char status = 0;
unsigned short offset = 0;
unsigned char* spDataPtr = (unsigned char*)spData;
while ((status == 0) && (spLength >= SP_PORTION_SIZE))
{
status = nvmem_write(ulFileId, SP_PORTION_SIZE, offset, spDataPtr);
offset += SP_PORTION_SIZE;
spLength -= SP_PORTION_SIZE;
spDataPtr += SP_PORTION_SIZE;
}
if (status !=0)
{
// NVMEM error occured
return status;
}
if (spLength != 0)
{
// if reached here, a reminder is left
status = nvmem_write(ulFileId, spLength, offset, spDataPtr);
}
return status;
}
UINT8 nvmem_write_patch(UINT32 ulFileId, UINT32 spLength, const UINT8 *spData)
{
UINT8 status = 0;
UINT16 offset = 0;
UINT8* spDataPtr = (UINT8*)spData;
while ((status == 0) && (spLength >= SP_PORTION_SIZE))
{
status = nvmem_write(ulFileId, SP_PORTION_SIZE, offset, spDataPtr);
offset += SP_PORTION_SIZE;
spLength -= SP_PORTION_SIZE;
spDataPtr += SP_PORTION_SIZE;
}
if (status !=0)
{
// NVMEM error occurred
return status;
}
if (spLength != 0)
{
// if reached here, a reminder is left
status = nvmem_write(ulFileId, spLength, offset, spDataPtr);
}
return status;
}
unsigned char nvmem_write_patch(unsigned long ulFileId, unsigned long spLength, const uint8_t *spData)
{
unsigned char status = 0;
unsigned short offset = 0;
unsigned char* spDataPtr = (unsigned char*)spData;
uint8_t rambuffer[SP_PORTION_SIZE];
while ((status == 0) && (spLength >= SP_PORTION_SIZE))
{
Serial.println("#");
for (uint8_t i=0; i<SP_PORTION_SIZE; i++) {
//#ifdef TEENSY3
//rambuffer[i] = *(spData + i + offset);
//#else
//rambuffer[i] = pgm_read_byte(spData + i + offset);
//#endif
while (Serial.available() <= 0)
;
rambuffer[i] = Serial.read();
}
#if (DEBUG_MODE == 1)
PRINT_F("Writing: "); printDec16(offset); PRINT_F("\t");
for (uint8_t i=0; i<SP_PORTION_SIZE; i++) {
PRINT_F("0x");
printHex(rambuffer[i]);
PRINT_F(", ");
}
PRINT_F("\n\r");
#endif
status = nvmem_write(ulFileId, SP_PORTION_SIZE, offset, rambuffer);
//status = 0;
offset += SP_PORTION_SIZE;
spLength -= SP_PORTION_SIZE;
spDataPtr += SP_PORTION_SIZE;
}
if (status !=0)
{
// NVMEM error occurred
return status;
}
if (spLength != 0)
{
Serial.println("#");
for (int i=0; i<spLength; i++) {
while (Serial.available() <= 0)
;
rambuffer[i] = Serial.read();
}
// if reached here, a reminder is left
status = nvmem_write(ulFileId, spLength, offset, rambuffer);
//status = 0;
}
return status;
}
//*****************************************************************************
//
//! fat_write_content
//!
//! \param[in] file_address array of file address in FAT table:\n
//! this is the absolute address of the file in the EEPROM.
//! \param[in] file_length array of file length in FAT table:\n
//! this is the upper limit of the file size in the EEPROM.
//!
//! \return on succes 0, error otherwise
//!
//! \brief parse the FAT table from eeprom
//
//*****************************************************************************
static unsigned char fat_write_content(unsigned short const *file_address,
unsigned short const *file_length)
{
unsigned short index = 0;
unsigned char ucStatus;
unsigned char fatTable[48];
unsigned char* fatTablePtr = fatTable;
//
// First, write the magic number.
//
ucStatus = nvmem_write(16, 2, 0, (unsigned char*)"LS");
for (; index <= NVMEM_RM_FILEID; index++)
{
//
// Write address low char and mark as allocated.
//
*fatTablePtr++ = (unsigned char)(file_address[index] & 0xff) | BIT0;
//
// Write address high char.
//
*fatTablePtr++ = (unsigned char)((file_address[index]>>8) & 0xff);
//
// Write length low char.
//
*fatTablePtr++ = (unsigned char)(file_length[index] & 0xff);
//
// Write length high char.
//
*fatTablePtr++ = (unsigned char)((file_length[index]>>8) & 0xff);
}
//
// Second, write the FAT.
// Write in two parts to work with tiny driver.
//
ucStatus = nvmem_write(16, 24, 4, fatTable);
ucStatus = nvmem_write(16, 24, 24+4, &fatTable[24]);
//
// Third, we want to erase any user files.
//
memset(fatTable, 0, sizeof(fatTable));
ucStatus = nvmem_write(16, 16, 52, fatTable);
return ucStatus;
}
UINT8 nvmem_write_patch(UINT32 ulFileId, UINT32 spLength, const UINT8 *spData)
{
UINT8 status = 0;
UINT16 offset = 0;
UINT8* spDataPtr = (UINT8*)spData;
UINT8 rambuffer[SP_PORTION_SIZE];
while ((status == 0) && (spLength >= SP_PORTION_SIZE))
{
for (UINT8 i=0; i<SP_PORTION_SIZE; i++) {
rambuffer[i] = pgm_read_byte(spData + i + offset);
}
#if (DEBUG_MODE == 1)
PRINT_F("Writing: "); printDec16(offset); PRINT_F("\t");
for (UINT8 i=0; i<SP_PORTION_SIZE; i++) {
PRINT_F("0x");
printHex(rambuffer[i]);
PRINT_F(", ");
}
PRINT_F("\n\r");
#endif
status = nvmem_write(ulFileId, SP_PORTION_SIZE, offset, rambuffer);
offset += SP_PORTION_SIZE;
spLength -= SP_PORTION_SIZE;
spDataPtr += SP_PORTION_SIZE;
}
if (status !=0)
{
// NVMEM error occurred
return status;
}
if (spLength != 0)
{
memcpy_P(rambuffer, spDataPtr, SP_PORTION_SIZE);
// if reached here, a reminder is left
status = nvmem_write(ulFileId, spLength, offset, rambuffer);
}
return status;
}
unsigned char nvmem_write_patch(unsigned long ulFileId, unsigned long spLength, const uint8_t *spData)
{
unsigned char status = 0;
unsigned short offset = 0;
unsigned char* spDataPtr = (unsigned char*)spData;
uint8_t rambuffer[SP_PORTION_SIZE];
while ((status == 0) && (spLength >= SP_PORTION_SIZE))
{
for (uint8_t i=0; i<SP_PORTION_SIZE; i++) {
rambuffer[i] = pgm_read_byte(spData + i + offset);
}
#if (DEBUG_MODE == 1)
PRINT_F("Writing: "); printDec16(offset); PRINT_F("\t");
for (uint8_t i=0; i<SP_PORTION_SIZE; i++) {
PRINT_F("0x");
printHex(rambuffer[i]);
PRINT_F(", ");
}
PRINT_F("\n\r");
#endif
status = nvmem_write(ulFileId, SP_PORTION_SIZE, offset, rambuffer);
offset += SP_PORTION_SIZE;
spLength -= SP_PORTION_SIZE;
spDataPtr += SP_PORTION_SIZE;
}
if (status !=0)
{
// NVMEM error occurred
return status;
}
if (spLength != 0)
{
memcpy_P(rambuffer, spDataPtr, SP_PORTION_SIZE);
// if reached here, a reminder is left
status = nvmem_write(ulFileId, spLength, offset, rambuffer);
}
return status;
}
/*
* This function is used to update NV memory. The write is to a memory copy of
* NV. At the end of the current command, any changes are written to the actual
* NV memory.
*/
void _plat__NvMemoryWrite(unsigned int startOffset,
unsigned int size,
void *data)
{
assert(startOffset + size <= NV_MEMORY_SIZE);
/* Copy the data to the NV image */
#ifdef CONFIG_FLASH_NVMEM
nvmem_write(startOffset, size, data, NVMEM_TPM);
#else
memcpy(&s_NV[startOffset], data, size);
#endif
}
void SPARK_WLAN_Loop(void)
{
static int cofd_count = 0;
if(SPARK_WLAN_RESET || SPARK_WLAN_SLEEP)
{
if(SPARK_WLAN_STARTED)
{
if (LED_RGB_OVERRIDE)
{
LED_Signaling_Stop();
}
WLAN_CONNECTED = 0;
WLAN_DHCP = 0;
SPARK_WLAN_RESET = 0;
SPARK_WLAN_STARTED = 0;
SPARK_SOCKET_CONNECTED = 0;
SPARK_HANDSHAKE_COMPLETED = 0;
SPARK_FLASH_UPDATE = 0;
SPARK_LED_FADE = 0;
Spark_Error_Count = 0;
cofd_count = 0;
CC3000_Write_Enable_Pin(WLAN_DISABLE);
//wlan_stop();
Delay(100);
if(WLAN_SMART_CONFIG_START)
{
//Workaround to enter smart config when socket connect had blocked
wlan_start(0);
SPARK_WLAN_STARTED = 1;
/* Start CC3000 Smart Config Process */
Start_Smart_Config();
}
LED_SetRGBColor(RGB_COLOR_GREEN);
LED_On(LED_RGB);
}
}
else
{
if(!SPARK_WLAN_STARTED)
{
wlan_start(0);
SPARK_WLAN_STARTED = 1;
}
}
if(WLAN_SMART_CONFIG_START)
{
/* Start CC3000 Smart Config Process */
Start_Smart_Config();
}
else if (WLAN_MANUAL_CONNECT > 0 && !WLAN_DHCP)
{
wlan_ioctl_set_connection_policy(DISABLE, DISABLE, DISABLE);
/* Edit the below line before use*/
wlan_connect(WLAN_SEC_WPA2, _ssid, strlen(_ssid), NULL, (unsigned char*)_password, strlen(_password));
WLAN_MANUAL_CONNECT = -1;
}
// 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 ((WLAN_SMART_CONFIG_STOP == 1) && (WLAN_DHCP == 1) && (WLAN_CONNECTED == 1))
{
unsigned char loop_index = 0;
while (loop_index < 3)
{
mdnsAdvertiser(1,device_name,strlen(device_name));
loop_index++;
}
WLAN_SMART_CONFIG_STOP = 0;
}
if(SPARK_SOCKET_HANDSHAKE == 0)
{
if(SPARK_SOCKET_CONNECTED || SPARK_HANDSHAKE_COMPLETED)
{
Spark_Disconnect();
SPARK_FLASH_UPDATE = 0;
SPARK_LED_FADE = 0;
SPARK_HANDSHAKE_COMPLETED = 0;
SPARK_SOCKET_CONNECTED = 0;
LED_SetRGBColor(RGB_COLOR_GREEN);
LED_On(LED_RGB);
}
return;
}
if(TimingSparkConnectDelay != 0)
{
return;
}
if(WLAN_DHCP && !SPARK_WLAN_SLEEP && !SPARK_SOCKET_CONNECTED)
{
Delay(100);
netapp_ipconfig(&ip_config);
if(Spark_Error_Count)
{
LED_SetRGBColor(RGB_COLOR_RED);
while(Spark_Error_Count != 0)
{
LED_On(LED_RGB);
Delay(500);
LED_Off(LED_RGB);
Delay(500);
Spark_Error_Count--;
}
//Send the Error Count to Cloud: NVMEM_Spark_File_Data[ERROR_COUNT_FILE_OFFSET]
//To Do
//Reset Error Count
NVMEM_Spark_File_Data[ERROR_COUNT_FILE_OFFSET] = 0;
nvmem_write(NVMEM_SPARK_FILE_ID, 1, ERROR_COUNT_FILE_OFFSET, &NVMEM_Spark_File_Data[ERROR_COUNT_FILE_OFFSET]);
}
LED_SetRGBColor(RGB_COLOR_CYAN);
LED_On(LED_RGB);
if(Spark_Connect() >= 0)
{
cofd_count = 0;
SPARK_SOCKET_CONNECTED = 1;
TimingCloudHandshakeTimeout = 0;
}
else
{
if(SPARK_WLAN_RESET)
return;
if ((cofd_count += RESET_ON_CFOD) == MAX_FAILED_CONNECTS)
{
SPARK_WLAN_RESET = RESET_ON_CFOD;
ERROR("Resetting CC3000 due to %d failed connect attempts", MAX_FAILED_CONNECTS);
}
if(Internet_Test() < 0)
{
//No Internet Connection
if ((cofd_count += RESET_ON_CFOD) == MAX_FAILED_CONNECTS)
{
SPARK_WLAN_RESET = RESET_ON_CFOD;
ERROR("Resetting CC3000 due to %d failed connect attempts", MAX_FAILED_CONNECTS);
}
Spark_Error_Count = 2;
}
else
{
//Cloud not Reachable
Spark_Error_Count = 3;
}
NVMEM_Spark_File_Data[ERROR_COUNT_FILE_OFFSET] = Spark_Error_Count;
nvmem_write(NVMEM_SPARK_FILE_ID, 1, ERROR_COUNT_FILE_OFFSET, &NVMEM_Spark_File_Data[ERROR_COUNT_FILE_OFFSET]);
SPARK_SOCKET_CONNECTED = 0;
}
}
if (SPARK_SOCKET_CONNECTED)
{
if (!SPARK_HANDSHAKE_COMPLETED)
{
int err = Spark_Handshake();
if (err)
{
if (0 > err)
{
// Wrong key error, red
LED_SetRGBColor(0xff0000);
}
else if (1 == err)
{
// RSA decryption error, orange
LED_SetRGBColor(0xff6000);
}
else if (2 == err)
{
// RSA signature verification error, magenta
LED_SetRGBColor(0xff00ff);
}
LED_On(LED_RGB);
Cloud_Handshake_Error_Count++;
TimingSparkConnectDelay = Cloud_Handshake_Error_Count * TIMING_CLOUD_HANDSHAKE_TIMEOUT;
}
else
{
SPARK_HANDSHAKE_COMPLETED = 1;
Cloud_Handshake_Error_Count = 0;
TimingCloudActivityTimeout = 0;
}
}
if (!Spark_Communication_Loop())
{
if (LED_RGB_OVERRIDE)
{
LED_Signaling_Stop();
}
SPARK_FLASH_UPDATE = 0;
SPARK_LED_FADE = 0;
SPARK_HANDSHAKE_COMPLETED = 0;
SPARK_SOCKET_CONNECTED = 0;
}
}
}
void SPARK_WLAN_Setup(void (*presence_announcement_callback)(void))
{
announce_presence = presence_announcement_callback;
/* Initialize CC3000's CS, EN and INT pins to their default states */
CC3000_WIFI_Init();
/* Configure & initialize CC3000 SPI_DMA Interface */
CC3000_SPI_DMA_Init();
/* WLAN On API Implementation */
wlan_init(WLAN_Async_Callback, WLAN_Firmware_Patch, WLAN_Driver_Patch, WLAN_BootLoader_Patch,
CC3000_Read_Interrupt_Pin, CC3000_Interrupt_Enable, CC3000_Interrupt_Disable, CC3000_Write_Enable_Pin);
Delay(100);
/* Trigger a WLAN device */
wlan_start(0);
SPARK_LED_FADE = 0;
SPARK_WLAN_STARTED = 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);
if(NVMEM_SPARK_Reset_SysFlag == 0x0001 || nvmem_read(NVMEM_SPARK_FILE_ID, NVMEM_SPARK_FILE_SIZE, 0, NVMEM_Spark_File_Data) != NVMEM_SPARK_FILE_SIZE)
{
/* Delete all previously stored wlan profiles */
wlan_ioctl_del_profile(255);
/* Create new entry for Spark File in CC3000 EEPROM */
nvmem_create_entry(NVMEM_SPARK_FILE_ID, NVMEM_SPARK_FILE_SIZE);
memset(NVMEM_Spark_File_Data,0, arraySize(NVMEM_Spark_File_Data));
nvmem_write(NVMEM_SPARK_FILE_ID, NVMEM_SPARK_FILE_SIZE, 0, NVMEM_Spark_File_Data);
NVMEM_SPARK_Reset_SysFlag = 0x0000;
Save_SystemFlags();
}
if(WLAN_MANUAL_CONNECT == 0)
{
if(NVMEM_Spark_File_Data[WLAN_PROFILE_FILE_OFFSET] == 0)
{
WLAN_SMART_CONFIG_START = 1;
}
else if(NVMEM_Spark_File_Data[WLAN_POLICY_FILE_OFFSET] == 0)
{
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]);
}
}
if((WLAN_MANUAL_CONNECT > 0) || !WLAN_SMART_CONFIG_START)
{
LED_SetRGBColor(RGB_COLOR_GREEN);
LED_On(LED_RGB);
}
nvmem_read_sp_version(patchVer);
if (patchVer[1] == 24)//19 for old patch
{
/* Latest Patch Available after flashing "cc3000-patch-programmer.bin" */
}
Clear_NetApp_Dhcp();
Set_NetApp_Timeout();
}
/*******************************************************************************
* 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;
}
unsigned char nvmem_set_mac_address(unsigned char *mac)
{
return nvmem_write(NVMEM_MAC_FILEID, MAC_ADDR_LEN, 0, mac);
}
UINT8 nvmem_set_mac_address(UINT8 *mac)
{
return nvmem_write(NVMEM_MAC_FILEID, MAC_ADDR_LEN, 0, mac);
}
uint8_t nvmem_set_mac_address(uint8_t *mac)
{
return nvmem_write(NVMEM_MAC_FILEID, MAC_ADDR_LEN, 0, mac);
}
void patch_prog_start()
{
unsigned short index;
unsigned char *pRMParams;
printf("Initializing module...\n");
// Init module and request to load with no patches.
// This is in order to overwrite restrictions to
// write to specific places in EEPROM.
initDriver(1);
// Read MAC address.
mac_status = nvmem_get_mac_address(cMacFromEeprom);
return_status = 1;
printf("Reading RM parameters...\n");
while ((return_status) && (counter < 3)) {
// Read RM parameters.
// Read in 16 parts to work with tiny driver.
return_status = 0;
pRMParams = cRMParamsFromEeprom;
for (index = 0; index < 16; index++) {
return_status |= nvmem_read(NVMEM_RM_FILEID, 8, 8*index, pRMParams);
pRMParams += 8;
}
counter++;
}
// If RM file is not valid, load the default one.
if (counter == 3) {
printf("RM is not valid, loading default one...\n");
pRMParams = (unsigned char *)cRMdefaultParams;
} else {
printf("RM is valid.\n");
pRMParams = cRMParamsFromEeprom;
}
return_status = 1;
printf("Writing new FAT\n");
while (return_status) {
// Write new FAT.
return_status = fat_write_content(aFATEntries[0], aFATEntries[1]);
}
return_status = 1;
printf("Writing RM parameters...\n");
while (return_status) {
// Write RM parameters.
// Write in 4 parts to work with tiny driver.
return_status = 0;
for (index = 0; index < 4; index++) {
return_status |= nvmem_write(NVMEM_RM_FILEID,
32,
32*index,
(pRMParams + 32*index));
}
}
return_status = 1;
// Write back the MAC address, only if exists.
if (mac_status == 0) {
// Zero out MCAST bit if set.
cMacFromEeprom[0] &= 0xfe;
printf("Writing back MAC address..\n");
while (return_status) {
return_status = nvmem_set_mac_address(cMacFromEeprom);
}
}
// Update driver
ucStatus_Dr = 1;
printf("Updating driver patch...\n");
while (ucStatus_Dr) {
// Writing driver patch to EEPRROM - PROTABLE CODE
// Note that the array itself is changing between the
// different Service Packs.
ucStatus_Dr = nvmem_write_patch(NVMEM_WLAN_DRIVER_SP_FILEID,
drv_length,
wlan_drv_patch);
}
// Update firmware
ucStatus_FW = 1;
printf("Updating firmware patch...\n");
while (ucStatus_FW) {
// Writing FW patch to EEPRROM - PROTABLE CODE
// Note that the array itself is changing between the
// different Service Packs.
ucStatus_FW = nvmem_write_patch(NVMEM_WLAN_FW_SP_FILEID,
fw_length,
fw_patch);
}
printf("Update complete, resetting module\n"\
"If this doesn't work, reset manually...\n");
wlan_stop();
systick_sleep(500);
// Re-Init module and request to load with patches.
initDriver(0);
// If MAC does not exist, it is recommended
// that the user will write a valid mac address.
if (mac_status != 0) {
printf("MAC address is not valid, please write a new one\n");
}
// Patch update done
printf("All done, call wlan.patch_version()\n");
}
void SPARK_WLAN_Loop(void)
{
if(SPARK_WLAN_RESET || SPARK_WLAN_SLEEP)
{
if(SPARK_WLAN_STARTED)
{
if (LED_RGB_OVERRIDE)
{
LED_Signaling_Stop();
}
WLAN_CONNECTED = 0;
WLAN_DHCP = 0;
SPARK_WLAN_RESET = 0;
SPARK_WLAN_STARTED = 0;
SPARK_SOCKET_CONNECTED = 0;
SPARK_HANDSHAKE_COMPLETED = 0;
SPARK_FLASH_UPDATE = 0;
SPARK_LED_FADE = 0;
Spark_Error_Count = 0;
TimingSparkCommTimeout = 0;
CC3000_Write_Enable_Pin(WLAN_DISABLE);
Delay(100);
if(WLAN_SMART_CONFIG_START)
{
//Workaround to enter smart config when socket connect had blocked
wlan_start(0);
SPARK_WLAN_STARTED = 1;
/* Start CC3000 Smart Config Process */
Start_Smart_Config();
}
LED_SetRGBColor(RGB_COLOR_GREEN);
LED_On(LED_RGB);
}
}
else
{
if(!SPARK_WLAN_STARTED)
{
wlan_start(0);
SPARK_WLAN_STARTED = 1;
}
}
if(WLAN_SMART_CONFIG_START)
{
/* Start CC3000 Smart Config Process */
Start_Smart_Config();
}
else if (WLAN_MANUAL_CONNECT && !WLAN_DHCP)
{
wlan_ioctl_set_connection_policy(DISABLE, DISABLE, DISABLE);
/* Edit the below line before use*/
wlan_connect(WLAN_SEC_WPA2, _ssid, strlen(_ssid), NULL, (unsigned char*)_password, strlen(_password));
WLAN_MANUAL_CONNECT = 0;
}
// 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 ((WLAN_SMART_CONFIG_STOP == 1) && (WLAN_DHCP == 1) && (WLAN_CONNECTED == 1))
{
unsigned char loop_index = 0;
while (loop_index < 3)
{
mdnsAdvertiser(1,device_name,strlen(device_name));
loop_index++;
}
WLAN_SMART_CONFIG_STOP = 0;
}
if(WLAN_DHCP && !SPARK_WLAN_SLEEP && !SPARK_SOCKET_CONNECTED)
{
Delay(100);
netapp_ipconfig(&ip_config);
#if defined (USE_SPARK_CORE_V02)
if(Spark_Error_Count)
{
LED_SetRGBColor(RGB_COLOR_RED);
while(Spark_Error_Count != 0)
{
LED_On(LED_RGB);
Delay(500);
LED_Off(LED_RGB);
Delay(500);
Spark_Error_Count--;
}
//Send the Error Count to Cloud: NVMEM_Spark_File_Data[ERROR_COUNT_FILE_OFFSET]
//To Do
//Reset Error Count
NVMEM_Spark_File_Data[ERROR_COUNT_FILE_OFFSET] = 0;
nvmem_write(NVMEM_SPARK_FILE_ID, 1, ERROR_COUNT_FILE_OFFSET, &NVMEM_Spark_File_Data[ERROR_COUNT_FILE_OFFSET]);
}
LED_SetRGBColor(RGB_COLOR_CYAN);
LED_On(LED_RGB);
#endif
if(Spark_Connect() < 0)
{
if(SPARK_WLAN_RESET)
return;
if(Internet_Test() < 0)
{
//No Internet Connection
Spark_Error_Count = 2;
}
else
{
//Cloud not Reachable
Spark_Error_Count = 3;
}
NVMEM_Spark_File_Data[ERROR_COUNT_FILE_OFFSET] = Spark_Error_Count;
nvmem_write(NVMEM_SPARK_FILE_ID, 1, ERROR_COUNT_FILE_OFFSET, &NVMEM_Spark_File_Data[ERROR_COUNT_FILE_OFFSET]);
SPARK_SOCKET_CONNECTED = 0;
}
else
{
SPARK_SOCKET_CONNECTED = 1;
}
}
}
