BOOL FWNewEnable_GprsPro()
{
BOOL enable_low = FALSE, enable_high = FALSE;
BYTE i,fread[1];
// Check on low word of reset vector
for (i = 0; i < 3;i++)
{
vTaskSuspendAll();
SPIFlashReadArray(FLASH_START_ADD + i, fread, 1);
xTaskResumeAll();
if (fread[0] != 0xFF)
enable_low = TRUE;
}
// Check on high word of reset vector
for (i = 3; i < 6;i++)
{
vTaskSuspendAll();
SPIFlashReadArray(FLASH_START_ADD + i, fread, 1);
xTaskResumeAll();
if (fread[0] != 0xFF)
enable_high = TRUE;
}
if ( (enable_low == TRUE) && (enable_high == TRUE) )
{
vTaskSuspendAll();
_erase_flash(0x29800);
xTaskResumeAll();
return TRUE;
}
else
return FALSE;
}
static void InitAppConfig(void)
{
AppConfig.Flags.bIsDHCPEnabled = TRUE;
AppConfig.Flags.bInConfigMode = TRUE;
memcpypgm2ram((void*)&AppConfig.MyMACAddr, (ROM void*)SerializedMACAddress, sizeof(AppConfig.MyMACAddr));
memcpypgm2ram(AppConfig.NetBIOSName, (ROM void*)MY_DEFAULT_HOST_NAME, 16);
FormatNetBIOSName(AppConfig.NetBIOSName);
AppConfig.MyIPAddr.Val = MY_DEFAULT_IP_ADDR_BYTE1 | MY_DEFAULT_IP_ADDR_BYTE2<<8ul | MY_DEFAULT_IP_ADDR_BYTE3<<16ul | MY_DEFAULT_IP_ADDR_BYTE4<<24ul;
AppConfig.DefaultIPAddr.Val = AppConfig.MyIPAddr.Val;
AppConfig.MyMask.Val = MY_DEFAULT_MASK_BYTE1 | MY_DEFAULT_MASK_BYTE2<<8ul | MY_DEFAULT_MASK_BYTE3<<16ul | MY_DEFAULT_MASK_BYTE4<<24ul;
AppConfig.DefaultMask.Val = AppConfig.MyMask.Val;
AppConfig.MyGateway.Val = MY_DEFAULT_GATE_BYTE1 | MY_DEFAULT_GATE_BYTE2<<8ul | MY_DEFAULT_GATE_BYTE3<<16ul | MY_DEFAULT_GATE_BYTE4<<24ul;
AppConfig.PrimaryDNSServer.Val = MY_DEFAULT_PRIMARY_DNS_BYTE1 | MY_DEFAULT_PRIMARY_DNS_BYTE2<<8ul | MY_DEFAULT_PRIMARY_DNS_BYTE3<<16ul | MY_DEFAULT_PRIMARY_DNS_BYTE4<<24ul;
AppConfig.SecondaryDNSServer.Val = MY_DEFAULT_SECONDARY_DNS_BYTE1 | MY_DEFAULT_SECONDARY_DNS_BYTE2<<8ul | MY_DEFAULT_SECONDARY_DNS_BYTE3<<16ul | MY_DEFAULT_SECONDARY_DNS_BYTE4<<24ul;
#if defined(EEPROM_CS_TRIS)
{
BYTE c;
// When a record is saved, first byte is written as 0x60 to indicate
// that a valid record was saved. Note that older stack versions
// used 0x57. This change has been made to so old EEPROM contents
// will get overwritten. The AppConfig() structure has been changed,
// resulting in parameter misalignment if still using old EEPROM
// contents.
XEEReadArray(0x0000, &c, 1);
if(c == 0x42u)
{
XEEReadArray(0x0001, (BYTE*)&AppConfig, sizeof(AppConfig));
}
else
SaveAppConfig();
}
#elif defined(SPIFLASH_CS_TRIS)
{
BYTE c;
SPIFlashReadArray(0x0000, &c, 1);
if(c == 0x42u)
{
SPIFlashReadArray(0x0001, (BYTE*)&AppConfig, sizeof(AppConfig));
}
else
SaveAppConfig();
}
#endif
}
unsigned long int LoadVariableFromFlash(unsigned long int loadAddress, BYTE *variableAddress, int variableSize)
{
int i;
for (i = 0; i < variableSize; i++)
{
SPIFlashReadArray(loadAddress + i, (BYTE *) (variableAddress + i), 1);
}
return loadAddress + variableSize;
}
BOOL FlashConfigExists(unsigned long int flashAddress)
{
BYTE val[2];
SPIFlashReadArray(flashAddress, val, 2);
if (val[0] == 0x0A && val[1] == 0x0B)
{
return 1;
}
return 0;
}
BYTE MD5IntegrityCheck(BYTE* buffer, BYTE fileCount)
{
BYTE operationRep = 0;
// MD5 INTEGRITY CHECK ON MEMORY
BYTE resmd[16];
HASH_SUM Hash;
_dbgline("Calculating md5 from memory...");
MD5Initialize(&Hash);
long unsigned int f_ind = 0;
BYTE b_read[2];
unsigned long int md5_ind = FLASH_START_ADD;
md5_ind += FW_SIZE*(unsigned long int)(fileCnt);
unsigned long int stopSize = FW_SIZE;
if(fileCount == 8) // Last file...
{
stopSize = (unsigned long int)FW_LAST_SIZE;
}
for (f_ind = 0; f_ind < stopSize; f_ind++)
{
vTaskSuspendAll();
SPIFlashReadArray(md5_ind+f_ind, b_read, 1);
xTaskResumeAll();
HashAddData(&Hash, b_read, 1);
}
MD5Calculate(&Hash, resmd);
BYTE i;
char rr[3];
_dbgline("MD5:");
for (i=0; i<16; i++)
{
sprintf(rr,"%X ",resmd[i]);
_dbgwrite(rr);
if (resmd[i] != (BYTE) buffer[i])
{
operationRep = 1;
}
}
return operationRep;
}
/*****************************************************************************
Function:
WORD MPFSGetArray(MPFS_HANDLE hMPFS, BYTE* cData, WORD wLen)
Description:
Reads a series of bytes from a file.
Precondition:
The file handle referenced by hMPFS is already open.
Parameters:
hMPFS - the file handle from which to read
cData - where to store the bytes that were read
wLen - how many bytes to read
Returns:
The number of bytes successfully read. If this is less than wLen,
an EOF occurred while attempting to read.
***************************************************************************/
WORD MPFSGetArray(MPFS_HANDLE hMPFS, BYTE* cData, WORD wLen)
{
// Make sure we're reading a valid address
if(hMPFS > MAX_MPFS_HANDLES)
return 0;
// Determine how many we can actually read
if(wLen > MPFSStubs[hMPFS].bytesRem)
wLen = MPFSStubs[hMPFS].bytesRem;
// Make sure we're reading a valid address
if(MPFSStubs[hMPFS].addr == MPFS_INVALID || wLen == 0u)
return 0;
if(cData == NULL)
{
MPFSStubs[hMPFS].addr += wLen;
MPFSStubs[hMPFS].bytesRem -= wLen;
return wLen;
}
// Read the data
#if defined(MPFS_USE_EEPROM)
XEEReadArray(MPFSStubs[hMPFS].addr+MPFS_HEAD, cData, wLen);
MPFSStubs[hMPFS].addr += wLen;
MPFSStubs[hMPFS].bytesRem -= wLen;
lastRead = MPFS_INVALID;
#elif defined(MPFS_USE_SPI_FLASH)
SPIFlashReadArray(MPFSStubs[hMPFS].addr+MPFS_HEAD, cData, wLen);
MPFSStubs[hMPFS].addr += wLen;
MPFSStubs[hMPFS].bytesRem -= wLen;
#else
#if defined(__C30__)
{
DWORD addr;
DWORD_VAL read;
WORD count;
BYTE i;
// MPFS Images are addressed by the byte; Program memory by the word.
//
// Flash program memory is 24 bits wide and only even words are
// implemented. The upper byte of the upper word is read as 0x00.
// Address in program memory of any given byte is (MPFSAddr * 2) / 3
//
// We will read 24 bits at a time, but need to support using only
// fractions of the first and last byte.
// Find the beginning address in program memory.
addr = (MPFSStubs[hMPFS].addr / 3) << 1;
// Find where to start in that first 3 bytes
read.Val = (addr * 3) >> 1;
if(read.Val == MPFSStubs[hMPFS].addr)
i = 0;
else if(read.Val+1 == MPFSStubs[hMPFS].addr)
i = 1;
else
i = 2;
// Add in the MPFS starting address offset
addr += MPFS_HEAD;
// Update the MPFS Handle
MPFSStubs[hMPFS].addr += wLen;
MPFSStubs[hMPFS].bytesRem -= wLen;
// Read the first DWORD
read.Val = ReadProgramMemory(addr & 0x00FFFFFF);
addr += 2;
// Copy values as needed
for(count = wLen; count > 0; cData++, count--)
{
// Copy the next value in
*cData = read.v[i++];
// Check if a new DWORD is needed
if(i == 3 && count != 1)
{// Read in a new DWORD
read.Val = ReadProgramMemory(addr & 0x00FFFFFF);
addr += 2;
i = 0;
}
}
}
#else
{
DWORD dwHITECHWorkaround = MPFS_HEAD;
memcpypgm2ram(cData, (ROM void*)(MPFSStubs[hMPFS].addr + dwHITECHWorkaround), wLen);
MPFSStubs[hMPFS].addr += wLen;
MPFSStubs[hMPFS].bytesRem -= wLen;
}
#endif
#endif
return wLen;
}
/*****************************************************************************
Function:
BOOL MPFSGet(MPFS_HANDLE hMPFS, BYTE* c)
Description:
Reads a byte from a file.
Precondition:
The file handle referenced by hMPFS is already open.
Parameters:
hMPFS - the file handle from which to read
c - Where to store the byte that was read
Return Values:
TRUE - The byte was successfully read
FALSE - No byte was read because either the handle was invalid or
the end of the file has been reached.
***************************************************************************/
BOOL MPFSGet(MPFS_HANDLE hMPFS, BYTE* c)
{
// Make sure we're reading a valid address
if(hMPFS > MAX_MPFS_HANDLES)
return FALSE;
if( MPFSStubs[hMPFS].addr == MPFS_INVALID ||
MPFSStubs[hMPFS].bytesRem == 0u)
return FALSE;
if(c == NULL)
{
MPFSStubs[hMPFS].addr++;
MPFSStubs[hMPFS].bytesRem--;
return TRUE;
}
// Read function for EEPROM
#if defined(MPFS_USE_EEPROM)
// For performance, cache the last read address
if(MPFSStubs[hMPFS].addr != lastRead+1)
XEEBeginRead(MPFSStubs[hMPFS].addr + MPFS_HEAD);
*c = XEERead();
lastRead = MPFSStubs[hMPFS].addr;
MPFSStubs[hMPFS].addr++;
#elif defined(MPFS_USE_SPI_FLASH)
SPIFlashReadArray(MPFSStubs[hMPFS].addr + MPFS_HEAD, c, 1);
MPFSStubs[hMPFS].addr++;
#else
#if defined(__C30__)
{
DWORD addr;
DWORD_VAL read;
BYTE i;
// MPFS Images are addressed by the byte; Program memory by the word.
//
// Flash program memory is 24 bits wide and only even words are
// implemented. The upper byte of the upper word is read as 0x00.
// Address in program memory of any given byte is (MPFSAddr * 2) / 3
//
// We will read 24 bits at a time, but need to support using only
// fractions of the first and last byte.
// Find the beginning address in program memory.
addr = (MPFSStubs[hMPFS].addr / 3) << 1;
// Find where to start in that first 3 bytes
read.Val = (addr * 3) >> 1;
if(read.Val == MPFSStubs[hMPFS].addr)
i = 0;
else if(read.Val+1 == MPFSStubs[hMPFS].addr)
i = 1;
else
i = 2;
// Add in the MPFS starting address offset
addr += MPFS_HEAD;
// Update the MPFS Handle
MPFSStubs[hMPFS].addr++;
// Read the DWORD
read.Val = ReadProgramMemory(addr & 0x00FFFFFF);
*c = read.v[i];
}
#else
{
DWORD dwHITECHWorkaround = MPFS_HEAD;
*c = *((ROM BYTE*)(MPFSStubs[hMPFS].addr+dwHITECHWorkaround));
MPFSStubs[hMPFS].addr++;
}
#endif
#endif
MPFSStubs[hMPFS].bytesRem--;
return TRUE;
}
/*********************************************************************
* Function: BYTE MPFSGet(void)
*
* PreCondition: MPFSOpen() != MPFS_INVALID &&
* MPFSGetBegin() == TRUE
*
* Input: None
*
* Output: Data byte from current address.
*
* Side Effects: None
*
* Overview: Reads a byte from current address.
*
* Note: Caller must call MPFSIsEOF() to check for end of
* file condition
********************************************************************/
BYTE MPFSGet(void)
{
BYTE t;
#if defined(MPFS_USE_EEPROM)
t = XEERead();
_currentHandle++;
#elif defined(MPFS_USE_SPI_FLASH)
//SPIFlashReadArray(_currentHandle++, (BYTE*)&t, 1); //orig
SPIFlashReadArray(_currentHandle, (BYTE*)&t, 1); //ccs workaround
_currentHandle++; //ccs workaround
#else
#if defined(__C30__) && !defined(__PCD__) //__CCS__ change
{
DWORD_VAL i;
// The uppermost byte, ((DWORD_VAL*)&_currentHandle)->v[3]), is the byte lane to read from.
// 16 bit PICs have a 24 bit wide Flash program word. Bytes 0-2 are the actual address, but
// odd addresses aren't implemented.
i.Val = ReadProgramMemory(_currentHandle & 0x00FFFFFF);
t = i.v[((DWORD_VAL*)&_currentHandle)->v[3]++];
if(((DWORD_VAL*)&_currentHandle)->v[3] >= 3)
{
_currentHandle = (_currentHandle + 2) & 0x00FFFFFF;
}
}
#else
//t = (BYTE)*_currentHandle; //__ccs__ change because MPFS isn't rom pointer
memcpypgm2ram(&t, _currentHandle, 1); //__ccs__ change because MPFS isn't rom pointer
_currentHandle++;
#endif
#endif
if(t == MPFS_DLE)
{
#if defined(MPFS_USE_EEPROM)
t = XEERead();
_currentHandle++;
#elif defined(MPFS_USE_SPI_FLASH)
//SPIFlashReadArray(_currentHandle++, (BYTE*)&t, 1); //orig
SPIFlashReadArray(_currentHandle, (BYTE*)&t, 1); //ccs workaround
_currentHandle++; //ccs workaround
#else
#if defined(__C30__) && !defined(__PCD__) //__CCS__ change
{
DWORD_VAL i;
// The uppermost byte, ((DWORD_VAL*)&_currentHandle)->v[3]), is the byte lane to read from.
// 16 bit PICs have a 24 bit wide Flash program word. Bytes 0-2 are the actual address, but
// odd addresses aren't implemented.
i.Val = ReadProgramMemory(_currentHandle & 0x00FFFFFF);
t = i.v[((DWORD_VAL*)&_currentHandle)->v[3]++];
if(((DWORD_VAL*)&_currentHandle)->v[3] >= 3)
{
_currentHandle = (_currentHandle + 2) & 0x00FFFFFF;
}
}
#else
//t = (BYTE)*_currentHandle; //__ccs__ change because MPFS isn't rom pointer
memcpypgm2ram(&t, _currentHandle, 1); //__ccs__ change because MPFS isn't rom pointer
_currentHandle++;
#endif
#endif
}
else if(t == MPFS_ETX)
{
_currentHandle = MPFS_INVALID;
}
//printf(UserPutc, " ret=%X\r\n", t);
return t;
}
/*********************************************************************
* Function: MPFS MPFSOpen(BYTE* file)
*
* PreCondition: None
*
* Input: file - NULL terminated file name.
*
* Output: A handle if file is found
* MPFS_INVALID if file is not found.
*
* Side Effects: None
*
* Overview: None
*
* Note: None
********************************************************************/
MPFS MPFSOpen(BYTE* file)
{
MPFS_ENTRY entry;
MPFS FAT;
BYTE fileNameLen;
debug_mpfs(debug_mpfs_putc, "\r\nMPFSOpen() '%s' ", file);
if( mpfsFlags.bits.bNotAvailable )
{
debug_mpfs(debug_mpfs_putc, "NOT AVAILABLE");
return MPFS_NOT_AVAILABLE;
}
#if defined(MPFS_USE_EEPROM) || defined(MPFS_USE_SPI_FLASH)
FAT = MPFS_Start;
#else
FAT = (MPFS)MPFS_Start;
#endif
// If string is empty, do not attempt to find it in FAT.
if ( *file == '\0' )
return MPFS_INVALID;
//debug_mpfs("p1='%s'0x%LX ", file, file);
file = (BYTE*)strupr((char*)file);
//debug_mpfs("p2='%s'0x%LX ", file, file);
debug_mpfs(debug_mpfs_putc, "START=0x%LX ", FAT);
for(;;)
{
// Bring current FAT entry into RAM.
#if defined(MPFS_USE_EEPROM)
XEEReadArray(FAT, (unsigned char*)&entry, sizeof(entry));
#elif defined(MPFS_USE_SPI_FLASH)
SPIFlashReadArray(FAT, (BYTE*)&entry, sizeof(entry));
#else
#if defined(__C30__)
memcpypgm2ram(&entry, (ROM void*)(WORD)FAT, sizeof(entry));
#else
memcpypgm2ram(&entry, (ROM void*)FAT, sizeof(entry));
#endif
#endif
debug_mpfs(debug_mpfs_putc, "FLAG=0x%X ", entry.Flag);
// Make sure that it is a valid entry.
if (entry.Flag == MPFS_DATA)
{
// Does the file name match ?
fileNameLen = strlen((char*)file);
if ( fileNameLen > MAX_FILE_NAME_LEN )
fileNameLen = MAX_FILE_NAME_LEN;
//debug_mpfs("f='%s' (%u) vs '%s' ", entry.Name, fileNameLen, file);
if( memcmp((void*)file, (void*)entry.Name, fileNameLen) == 0 )
{
#if defined(__PCD__)
#warning 4.121 temporary bug fix
memcpy(&_currentFile, &entry.Address, 4);
#if defined(MPFS_RETURN_OFFSET)
_currentFile += MPFS_Start;
#endif
mpfsOpenCount++;
debug_mpfs(debug_mpfs_putc, "found_0x%LX ", _currentFile);
return _currentFile;
#else
#if defined(MPFS_RETURN_OFFSET)
entry.Address += MPFS_Start;
#endif
_currentFile = (MPFS)entry.Address;
mpfsOpenCount++;
debug_mpfs(debug_mpfs_putc, "found_0x%LX ", _currentFile);
return entry.Address;
#endif
}
// File does not match. Try next entry...
FAT += sizeof(entry);
}
else if ( entry.Flag == MPFS_ETX )
{
#warning 4.121 temporary bug fix
unsigned int32 entry_Address;
memcpy(&entry_Address, &entry.Address, 4);
if ( entry_Address != (MPFS)MPFS_INVALID )
{
FAT = (MPFS)entry_Address; //original, doesn't work 4.121 pcd
debug_mpfs(debug_mpfs_putc, "(etx 0x%LX) ", FAT);
}
else
{
debug_mpfs(debug_mpfs_putc, "invalid_etx ");
break;
}
}
else
{
debug_mpfs(debug_mpfs_putc, "invalid_flag ");
return (MPFS)MPFS_INVALID;
}
}
debug_mpfs(debug_mpfs_putc, "not_found ");
return (MPFS)MPFS_INVALID;
}
/*********************************************************************
* Function: BYTE MPFSGet(void)
*
* PreCondition: MPFSOpen() != MPFS_INVALID &&
* MPFSGetBegin() == TRUE
*
* Input: None
*
* Output: Data byte from current address.
*
* Side Effects: None
*
* Overview: Reads a byte from current address.
*
* Note: Caller must call MPFSIsEOF() to check for end of
* file condition
********************************************************************/
BYTE MPFSGet(void)
{
BYTE t;
#if defined(MPFS_USE_EEPROM)
t = XEERead();
_currentHandle++;
#elif defined(MPFS_USE_SPI_FLASH)
SPIFlashReadArray(_currentHandle++, (BYTE*)&t, 1);
#else
#if defined(__C30__)
{
DWORD_VAL i;
// The uppermost byte, ((DWORD_VAL*)&_currentHandle)->v[3]), is the byte lane to read from.
// 16 bit PICs have a 24 bit wide Flash program word. Bytes 0-2 are the actual address, but
// odd addresses aren't implemented.
i.Val = ReadProgramMemory(_currentHandle & 0x00FFFFFF);
t = i.v[((DWORD_VAL*)&_currentHandle)->v[3]++];
if(((DWORD_VAL*)&_currentHandle)->v[3] >= 3)
{
_currentHandle = (_currentHandle + 2) & 0x00FFFFFF;
}
}
#else
t = (BYTE)*_currentHandle;
_currentHandle++;
#endif
#endif
if(t == MPFS_DLE)
{
#if defined(MPFS_USE_EEPROM)
t = XEERead();
_currentHandle++;
#elif defined(MPFS_USE_SPI_FLASH)
SPIFlashReadArray(_currentHandle++, (BYTE*)&t, 1);
#else
#if defined(__C30__)
{
DWORD_VAL i;
// The uppermost byte, ((DWORD_VAL*)&_currentHandle)->v[3]), is the byte lane to read from.
// 16 bit PICs have a 24 bit wide Flash program word. Bytes 0-2 are the actual address, but
// odd addresses aren't implemented.
i.Val = ReadProgramMemory(_currentHandle & 0x00FFFFFF);
t = i.v[((DWORD_VAL*)&_currentHandle)->v[3]++];
if(((DWORD_VAL*)&_currentHandle)->v[3] >= 3)
{
_currentHandle = (_currentHandle + 2) & 0x00FFFFFF;
}
}
#else
t = (BYTE)*_currentHandle;
_currentHandle++;
#endif
#endif
}
else if(t == MPFS_ETX)
{
_currentHandle = MPFS_INVALID;
}
return t;
}
/*********************************************************************
* Function: MPFS MPFSOpen(BYTE* file)
*
* PreCondition: None
*
* Input: file - NULL terminated file name.
*
* Output: A handle if file is found
* MPFS_INVALID if file is not found.
*
* Side Effects: None
*
* Overview: None
*
* Note: None
********************************************************************/
MPFS MPFSOpen(BYTE* file)
{
MPFS_ENTRY entry;
MPFS FAT;
BYTE fileNameLen;
if( mpfsFlags.bits.bNotAvailable )
return MPFS_NOT_AVAILABLE;
#if defined(MPFS_USE_EEPROM) || defined(MPFS_USE_SPI_FLASH)
FAT = MPFS_Start;
#else
FAT = (MPFS)MPFS_Start;
#endif
// If string is empty, do not attempt to find it in FAT.
if ( *file == '\0' )
return MPFS_INVALID;
file = (BYTE*)strupr((char*)file);
while(1)
{
// Bring current FAT entry into RAM.
#if defined(MPFS_USE_EEPROM)
XEEReadArray(FAT, (unsigned char*)&entry, sizeof(entry));
#elif defined(MPFS_USE_SPI_FLASH)
SPIFlashReadArray(FAT, (BYTE*)&entry, sizeof(entry));
#else
#if defined(__C30__)
memcpypgm2ram(&entry, (ROM void*)(WORD)FAT, sizeof(entry));
#else
memcpypgm2ram(&entry, (ROM void*)FAT, sizeof(entry));
#endif
#endif
// Make sure that it is a valid entry.
if (entry.Flag == MPFS_DATA)
{
// Does the file name match ?
fileNameLen = strlen((char*)file);
if ( fileNameLen > MAX_FILE_NAME_LEN )
fileNameLen = MAX_FILE_NAME_LEN;
if( memcmp((void*)file, (void*)entry.Name, fileNameLen) == 0 )
{
_currentFile = (MPFS)entry.Address;
mpfsOpenCount++;
return entry.Address;
}
// File does not match. Try next entry...
FAT += sizeof(entry);
}
else if ( entry.Flag == MPFS_ETX )
{
if ( entry.Address != (MPFS)MPFS_INVALID )
FAT = (MPFS)entry.Address;
else
break;
}
else
return (MPFS)MPFS_INVALID;
}
return (MPFS)MPFS_INVALID;
}
static void InitAppConfig(void)
{
#if defined(EEPROM_CS_TRIS) || defined(SPIFLASH_CS_TRIS)
unsigned char vNeedToSaveDefaults = 0;
#endif
while(1)
{
// Start out zeroing all AppConfig bytes to ensure all fields are
// deterministic for checksum generation
memset((void*)&AppConfig, 0x00, sizeof(AppConfig));
AppConfig.Flags.bIsDHCPEnabled = TRUE;
AppConfig.Flags.bInConfigMode = TRUE;
memcpypgm2ram((void*)&AppConfig.MyMACAddr, (ROM void*)SerializedMACAddress, sizeof(AppConfig.MyMACAddr));
// {
// _prog_addressT MACAddressAddress;
// MACAddressAddress.next = 0x157F8;
// _memcpy_p2d24((char*)&AppConfig.MyMACAddr, MACAddressAddress, sizeof(AppConfig.MyMACAddr));
// }
AppConfig.MyIPAddr.Val = MY_DEFAULT_IP_ADDR_BYTE1 | MY_DEFAULT_IP_ADDR_BYTE2<<8ul | MY_DEFAULT_IP_ADDR_BYTE3<<16ul | MY_DEFAULT_IP_ADDR_BYTE4<<24ul;
AppConfig.DefaultIPAddr.Val = AppConfig.MyIPAddr.Val;
AppConfig.MyMask.Val = MY_DEFAULT_MASK_BYTE1 | MY_DEFAULT_MASK_BYTE2<<8ul | MY_DEFAULT_MASK_BYTE3<<16ul | MY_DEFAULT_MASK_BYTE4<<24ul;
AppConfig.DefaultMask.Val = AppConfig.MyMask.Val;
AppConfig.MyGateway.Val = MY_DEFAULT_GATE_BYTE1 | MY_DEFAULT_GATE_BYTE2<<8ul | MY_DEFAULT_GATE_BYTE3<<16ul | MY_DEFAULT_GATE_BYTE4<<24ul;
AppConfig.PrimaryDNSServer.Val = MY_DEFAULT_PRIMARY_DNS_BYTE1 | MY_DEFAULT_PRIMARY_DNS_BYTE2<<8ul | MY_DEFAULT_PRIMARY_DNS_BYTE3<<16ul | MY_DEFAULT_PRIMARY_DNS_BYTE4<<24ul;
AppConfig.SecondaryDNSServer.Val = MY_DEFAULT_SECONDARY_DNS_BYTE1 | MY_DEFAULT_SECONDARY_DNS_BYTE2<<8ul | MY_DEFAULT_SECONDARY_DNS_BYTE3<<16ul | MY_DEFAULT_SECONDARY_DNS_BYTE4<<24ul;
// SNMP Community String configuration
#if defined(STACK_USE_SNMP_SERVER)
{
BYTE i;
static ROM char * ROM cReadCommunities[] = SNMP_READ_COMMUNITIES;
static ROM char * ROM cWriteCommunities[] = SNMP_WRITE_COMMUNITIES;
ROM char * strCommunity;
for(i = 0; i < SNMP_MAX_COMMUNITY_SUPPORT; i++)
{
// Get a pointer to the next community string
strCommunity = cReadCommunities[i];
if(i >= sizeof(cReadCommunities)/sizeof(cReadCommunities[0]))
strCommunity = "";
// Ensure we don't buffer overflow. If your code gets stuck here,
// it means your SNMP_COMMUNITY_MAX_LEN definition in TCPIPConfig.h
// is either too small or one of your community string lengths
// (SNMP_READ_COMMUNITIES) are too large. Fix either.
if(strlenpgm(strCommunity) >= sizeof(AppConfig.readCommunity[0]))
while(1);
// Copy string into AppConfig
strcpypgm2ram((char*)AppConfig.readCommunity[i], strCommunity);
// Get a pointer to the next community string
strCommunity = cWriteCommunities[i];
if(i >= sizeof(cWriteCommunities)/sizeof(cWriteCommunities[0]))
strCommunity = "";
// Ensure we don't buffer overflow. If your code gets stuck here,
// it means your SNMP_COMMUNITY_MAX_LEN definition in TCPIPConfig.h
// is either too small or one of your community string lengths
// (SNMP_WRITE_COMMUNITIES) are too large. Fix either.
if(strlenpgm(strCommunity) >= sizeof(AppConfig.writeCommunity[0]))
while(1);
// Copy string into AppConfig
strcpypgm2ram((char*)AppConfig.writeCommunity[i], strCommunity);
}
}
#endif
// Load the default NetBIOS Host Name
memcpypgm2ram(AppConfig.NetBIOSName, (ROM void*)MY_DEFAULT_HOST_NAME, 16);
FormatNetBIOSName(AppConfig.NetBIOSName);
#if defined(WF_CS_TRIS)
// Load the default SSID Name
WF_ASSERT(sizeof(MY_DEFAULT_SSID_NAME) <= sizeof(AppConfig.MySSID));
memcpypgm2ram(AppConfig.MySSID, (ROM void*)MY_DEFAULT_SSID_NAME, sizeof(MY_DEFAULT_SSID_NAME));
AppConfig.SsidLength = sizeof(MY_DEFAULT_SSID_NAME) - 1;
#if defined (EZ_CONFIG_STORE)
AppConfig.SecurityMode = MY_DEFAULT_WIFI_SECURITY_MODE;
AppConfig.networkType = MY_DEFAULT_NETWORK_TYPE;
AppConfig.dataValid = 0;
#endif // EZ_CONFIG_STORE
#endif
// Compute the checksum of the AppConfig defaults as loaded from ROM
wOriginalAppConfigChecksum = CalcIPChecksum((BYTE*)&AppConfig, sizeof(AppConfig));
#if defined(EEPROM_CS_TRIS) || defined(SPIFLASH_CS_TRIS)
{
NVM_VALIDATION_STRUCT NVMValidationStruct;
// Check to see if we have a flag set indicating that we need to
// save the ROM default AppConfig values.
if(vNeedToSaveDefaults)
SaveAppConfig(&AppConfig);
// Read the NVMValidation record and AppConfig struct out of EEPROM/Flash
#if defined(EEPROM_CS_TRIS)
{
XEEReadArray(0x0000, (BYTE*)&NVMValidationStruct, sizeof(NVMValidationStruct));
XEEReadArray(sizeof(NVMValidationStruct), (BYTE*)&AppConfig, sizeof(AppConfig));
}
#elif defined(SPIFLASH_CS_TRIS)
{
SPIFlashReadArray(0x0000, (BYTE*)&NVMValidationStruct, sizeof(NVMValidationStruct));
SPIFlashReadArray(sizeof(NVMValidationStruct), (BYTE*)&AppConfig, sizeof(AppConfig));
}
#endif
// Check EEPROM/Flash validitity. If it isn't valid, set a flag so
// that we will save the ROM default values on the next loop
// iteration.
if((NVMValidationStruct.wConfigurationLength != sizeof(AppConfig)) ||
(NVMValidationStruct.wOriginalChecksum != wOriginalAppConfigChecksum) ||
(NVMValidationStruct.wCurrentChecksum != CalcIPChecksum((BYTE*)&AppConfig, sizeof(AppConfig))))
{
// Check to ensure that the vNeedToSaveDefaults flag is zero,
// indicating that this is the first iteration through the do
// loop. If we have already saved the defaults once and the
// EEPROM/Flash still doesn't pass the validity check, then it
// means we aren't successfully reading or writing to the
// EEPROM/Flash. This means you have a hardware error and/or
// SPI configuration error.
if(vNeedToSaveDefaults)
{
while(1);
}
// Set flag and restart loop to load ROM defaults and save them
vNeedToSaveDefaults = 1;
continue;
}
// If we get down here, it means the EEPROM/Flash has valid contents
// and either matches the ROM defaults or previously matched and
// was run-time reconfigured by the user. In this case, we shall
// use the contents loaded from EEPROM/Flash.
break;
}
#endif
break;
}
WiFiInfo.CurrentConfigHasChanged = 1;
#if defined (EZ_CONFIG_STORE)
// Set configuration for ZG from NVM
/* Set security type and key if necessary, convert from app storage to ZG driver */
if (AppConfig.dataValid)
CFGCXT.isWifiDoneConfigure = 1;
AppConfig.saveSecurityInfo = FALSE;
#endif // EZ_CONFIG_STORE
}
static void InitAppConfig(void)
{
#if defined(EEPROM_CS_TRIS) || defined(SPIFLASH_CS_TRIS)
unsigned char vNeedToSaveDefaults = 0;
#endif
while(1)
{
// Start out zeroing all AppConfig bytes to ensure all fields are
// deterministic for checksum generation
memset((void*)&AppConfig, 0x00, sizeof(AppConfig));
AppConfig.Flags.bIsDHCPEnabled = TRUE;
AppConfig.Flags.bInConfigMode = TRUE;
memcpypgm2ram((void*)&AppConfig.MyMACAddr, (ROM void*)SerializedMACAddress, sizeof(AppConfig.MyMACAddr));
// {
// _prog_addressT MACAddressAddress;
// MACAddressAddress.next = 0x157F8;
// _memcpy_p2d24((char*)&AppConfig.MyMACAddr, MACAddressAddress, sizeof(AppConfig.MyMACAddr));
// }
AppConfig.MyIPAddr.Val = MY_DEFAULT_IP_ADDR_BYTE1 | MY_DEFAULT_IP_ADDR_BYTE2<<8ul | MY_DEFAULT_IP_ADDR_BYTE3<<16ul | MY_DEFAULT_IP_ADDR_BYTE4<<24ul;
AppConfig.DefaultIPAddr.Val = AppConfig.MyIPAddr.Val;
AppConfig.MyMask.Val = MY_DEFAULT_MASK_BYTE1 | MY_DEFAULT_MASK_BYTE2<<8ul | MY_DEFAULT_MASK_BYTE3<<16ul | MY_DEFAULT_MASK_BYTE4<<24ul;
AppConfig.DefaultMask.Val = AppConfig.MyMask.Val;
AppConfig.MyGateway.Val = MY_DEFAULT_GATE_BYTE1 | MY_DEFAULT_GATE_BYTE2<<8ul | MY_DEFAULT_GATE_BYTE3<<16ul | MY_DEFAULT_GATE_BYTE4<<24ul;
AppConfig.PrimaryDNSServer.Val = MY_DEFAULT_PRIMARY_DNS_BYTE1 | MY_DEFAULT_PRIMARY_DNS_BYTE2<<8ul | MY_DEFAULT_PRIMARY_DNS_BYTE3<<16ul | MY_DEFAULT_PRIMARY_DNS_BYTE4<<24ul;
AppConfig.SecondaryDNSServer.Val = MY_DEFAULT_SECONDARY_DNS_BYTE1 | MY_DEFAULT_SECONDARY_DNS_BYTE2<<8ul | MY_DEFAULT_SECONDARY_DNS_BYTE3<<16ul | MY_DEFAULT_SECONDARY_DNS_BYTE4<<24ul;
// SNMP Community String configuration
#if defined(STACK_USE_SNMP_SERVER)
{
BYTE i;
static ROM char * ROM cReadCommunities[] = SNMP_READ_COMMUNITIES;
static ROM char * ROM cWriteCommunities[] = SNMP_WRITE_COMMUNITIES;
ROM char * strCommunity;
for(i = 0; i < SNMP_MAX_COMMUNITY_SUPPORT; i++)
{
// Get a pointer to the next community string
strCommunity = cReadCommunities[i];
if(i >= sizeof(cReadCommunities)/sizeof(cReadCommunities[0]))
strCommunity = "";
// Ensure we don't buffer overflow. If your code gets stuck here,
// it means your SNMP_COMMUNITY_MAX_LEN definition in TCPIPConfig.h
// is either too small or one of your community string lengths
// (SNMP_READ_COMMUNITIES) are too large. Fix either.
if(strlenpgm(strCommunity) >= sizeof(AppConfig.readCommunity[0]))
while(1);
// Copy string into AppConfig
strcpypgm2ram((char*)AppConfig.readCommunity[i], strCommunity);
// Get a pointer to the next community string
strCommunity = cWriteCommunities[i];
if(i >= sizeof(cWriteCommunities)/sizeof(cWriteCommunities[0]))
strCommunity = "";
// Ensure we don't buffer overflow. If your code gets stuck here,
// it means your SNMP_COMMUNITY_MAX_LEN definition in TCPIPConfig.h
// is either too small or one of your community string lengths
// (SNMP_WRITE_COMMUNITIES) are too large. Fix either.
if(strlenpgm(strCommunity) >= sizeof(AppConfig.writeCommunity[0]))
while(1);
// Copy string into AppConfig
strcpypgm2ram((char*)AppConfig.writeCommunity[i], strCommunity);
}
}
#endif
// Vending machine specific defaults
strcpypgm2ram((char*)Products[0].name, (ROM char*)"Cola");
strcpypgm2ram((char*)Products[1].name, (ROM char*)"Diet Cola");
strcpypgm2ram((char*)Products[2].name, (ROM char*)"Root Beer");
strcpypgm2ram((char*)Products[3].name, (ROM char*)"Orange");
strcpypgm2ram((char*)Products[4].name, (ROM char*)"Lemonade");
strcpypgm2ram((char*)Products[5].name, (ROM char*)"Iced Tea");
strcpypgm2ram((char*)Products[6].name, (ROM char*)"Water");
Products[0].price = 4;
Products[1].price = 4;
Products[2].price = 4;
Products[3].price = 4;
Products[4].price = 5;
Products[5].price = 7;
Products[6].price = 8;
strcpypgm2ram((char*)machineDesc, (ROM char*)"Building C4 - 2nd Floor NW");
machineDesc[32] = '\0';
curItem = 0;
curCredit = 0;
// Load the default NetBIOS Host Name
memcpypgm2ram(AppConfig.NetBIOSName, (ROM void*)MY_DEFAULT_HOST_NAME, 16);
FormatNetBIOSName(AppConfig.NetBIOSName);
#if defined(WF_CS_TRIS)
// Load the default SSID Name
WF_ASSERT(sizeof(MY_DEFAULT_SSID_NAME) <= sizeof(AppConfig.MySSID));
memcpypgm2ram(AppConfig.MySSID, (ROM void*)MY_DEFAULT_SSID_NAME, sizeof(MY_DEFAULT_SSID_NAME));
AppConfig.SsidLength = sizeof(MY_DEFAULT_SSID_NAME) - 1;
AppConfig.SecurityMode = MY_DEFAULT_WIFI_SECURITY_MODE;
AppConfig.WepKeyIndex = MY_DEFAULT_WEP_KEY_INDEX;
#if (MY_DEFAULT_WIFI_SECURITY_MODE == WF_SECURITY_OPEN)
memset(AppConfig.SecurityKey, 0x00, sizeof(AppConfig.SecurityKey));
AppConfig.SecurityKeyLength = 0;
#elif MY_DEFAULT_WIFI_SECURITY_MODE == WF_SECURITY_WEP_40
memcpypgm2ram(AppConfig.SecurityKey, (ROM void*)MY_DEFAULT_WEP_KEYS_40, sizeof(MY_DEFAULT_WEP_KEYS_40) - 1);
AppConfig.SecurityKeyLength = sizeof(MY_DEFAULT_WEP_KEYS_40) - 1;
#elif MY_DEFAULT_WIFI_SECURITY_MODE == WF_SECURITY_WEP_104
memcpypgm2ram(AppConfig.SecurityKey, (ROM void*)MY_DEFAULT_WEP_KEYS_104, sizeof(MY_DEFAULT_WEP_KEYS_104) - 1);
AppConfig.SecurityKeyLength = sizeof(MY_DEFAULT_WEP_KEYS_104) - 1;
#elif (MY_DEFAULT_WIFI_SECURITY_MODE == WF_SECURITY_WPA_WITH_KEY) || \
(MY_DEFAULT_WIFI_SECURITY_MODE == WF_SECURITY_WPA2_WITH_KEY) || \
(MY_DEFAULT_WIFI_SECURITY_MODE == WF_SECURITY_WPA_AUTO_WITH_KEY)
memcpypgm2ram(AppConfig.SecurityKey, (ROM void*)MY_DEFAULT_PSK, sizeof(MY_DEFAULT_PSK) - 1);
AppConfig.SecurityKeyLength = sizeof(MY_DEFAULT_PSK) - 1;
#elif (MY_DEFAULT_WIFI_SECURITY_MODE == WF_SECURITY_WPA_WITH_PASS_PHRASE) || \
(MY_DEFAULT_WIFI_SECURITY_MODE == WF_SECURITY_WPA2_WITH_PASS_PHRASE) || \
(MY_DEFAULT_WIFI_SECURITY_MODE == WF_SECURITY_WPA_AUTO_WITH_PASS_PHRASE)
memcpypgm2ram(AppConfig.SecurityKey, (ROM void*)MY_DEFAULT_PSK_PHRASE, sizeof(MY_DEFAULT_PSK_PHRASE) - 1);
AppConfig.SecurityKeyLength = sizeof(MY_DEFAULT_PSK_PHRASE) - 1;
#else
#error "No security defined"
#endif /* MY_DEFAULT_WIFI_SECURITY_MODE */
#endif
// Compute the checksum of the AppConfig defaults as loaded from ROM
wOriginalAppConfigChecksum = CalcIPChecksum((BYTE*)&AppConfig, sizeof(AppConfig));
#if defined(EEPROM_CS_TRIS) || defined(SPIFLASH_CS_TRIS)
{
NVM_VALIDATION_STRUCT NVMValidationStruct;
// Check to see if we have a flag set indicating that we need to
// save the ROM default AppConfig values.
if(vNeedToSaveDefaults)
SaveAppConfig(&AppConfig);
// Read the NVMValidation record and AppConfig struct out of EEPROM/Flash
#if defined(EEPROM_CS_TRIS)
{
XEEReadArray(0x0000, (BYTE*)&NVMValidationStruct, sizeof(NVMValidationStruct));
XEEReadArray(sizeof(NVMValidationStruct), (BYTE*)&AppConfig, sizeof(AppConfig));
XEEReadArray(sizeof(NVMValidationStruct) + sizeof(AppConfig), (BYTE*)&Products, sizeof(Products));
XEEReadArray(sizeof(NVMValidationStruct) + sizeof(AppConfig) + sizeof(Products), (BYTE*)&machineDesc, sizeof(machineDesc));
}
#elif defined(SPIFLASH_CS_TRIS)
{
SPIFlashReadArray(0x0000, (BYTE*)&NVMValidationStruct, sizeof(NVMValidationStruct));
SPIFlashReadArray(sizeof(NVMValidationStruct), (BYTE*)&AppConfig, sizeof(AppConfig));
SPIFlashReadArray(sizeof(NVMValidationStruct) + sizeof(AppConfig), (BYTE*)&Products, sizeof(Products));
SPIFlashReadArray(sizeof(NVMValidationStruct) + sizeof(AppConfig) + sizeof(Products), (BYTE*)&machineDesc, sizeof(machineDesc));
}
#endif
// Check EEPROM/Flash validitity. If it isn't valid, set a flag so
// that we will save the ROM default values on the next loop
// iteration.
if((NVMValidationStruct.wConfigurationLength != sizeof(AppConfig)) ||
(NVMValidationStruct.wOriginalChecksum != wOriginalAppConfigChecksum) ||
(NVMValidationStruct.wCurrentChecksum != CalcIPChecksum((BYTE*)&AppConfig, sizeof(AppConfig))))
{
// Check to ensure that the vNeedToSaveDefaults flag is zero,
// indicating that this is the first iteration through the do
// loop. If we have already saved the defaults once and the
// EEPROM/Flash still doesn't pass the validity check, then it
// means we aren't successfully reading or writing to the
// EEPROM/Flash. This means you have a hardware error and/or
// SPI configuration error.
if(vNeedToSaveDefaults)
{
while(1);
}
// Set flag and restart loop to load ROM defaults and save them
vNeedToSaveDefaults = 1;
continue;
}
// If we get down here, it means the EEPROM/Flash has valid contents
// and either matches the ROM defaults or previously matched and
// was run-time reconfigured by the user. In this case, we shall
// use the contents loaded from EEPROM/Flash.
break;
}
#endif
break;
}
// Update with default stock values on every reboot
Products[0].stock = 15;
Products[1].stock = 9;
Products[2].stock = 22;
Products[3].stock = 18;
Products[4].stock = 4;
Products[5].stock = 29;
Products[6].stock = 14;
}
static void InitAppConfig(void)
{
AppConfig.Flags.bIsDHCPEnabled = TRUE;
AppConfig.Flags.bInConfigMode = TRUE;
memcpypgm2ram((void*)&AppConfig.MyMACAddr, (ROM void*)SerializedMACAddress, sizeof(AppConfig.MyMACAddr));
// {
// _prog_addressT MACAddressAddress;
// MACAddressAddress.next = 0x157F8;
// _memcpy_p2d24((char*)&AppConfig.MyMACAddr, MACAddressAddress, sizeof(AppConfig.MyMACAddr));
// }
AppConfig.MyIPAddr.Val = MY_DEFAULT_IP_ADDR_BYTE1 | MY_DEFAULT_IP_ADDR_BYTE2<<8ul | MY_DEFAULT_IP_ADDR_BYTE3<<16ul | MY_DEFAULT_IP_ADDR_BYTE4<<24ul;
AppConfig.DefaultIPAddr.Val = AppConfig.MyIPAddr.Val;
AppConfig.MyMask.Val = MY_DEFAULT_MASK_BYTE1 | MY_DEFAULT_MASK_BYTE2<<8ul | MY_DEFAULT_MASK_BYTE3<<16ul | MY_DEFAULT_MASK_BYTE4<<24ul;
AppConfig.DefaultMask.Val = AppConfig.MyMask.Val;
AppConfig.MyGateway.Val = MY_DEFAULT_GATE_BYTE1 | MY_DEFAULT_GATE_BYTE2<<8ul | MY_DEFAULT_GATE_BYTE3<<16ul | MY_DEFAULT_GATE_BYTE4<<24ul;
AppConfig.PrimaryDNSServer.Val = MY_DEFAULT_PRIMARY_DNS_BYTE1 | MY_DEFAULT_PRIMARY_DNS_BYTE2<<8ul | MY_DEFAULT_PRIMARY_DNS_BYTE3<<16ul | MY_DEFAULT_PRIMARY_DNS_BYTE4<<24ul;
AppConfig.SecondaryDNSServer.Val = MY_DEFAULT_SECONDARY_DNS_BYTE1 | MY_DEFAULT_SECONDARY_DNS_BYTE2<<8ul | MY_DEFAULT_SECONDARY_DNS_BYTE3<<16ul | MY_DEFAULT_SECONDARY_DNS_BYTE4<<24ul;
// SNMP Community String configuration
#if defined(STACK_USE_SNMP_SERVER)
{
BYTE i;
static ROM char * ROM cReadCommunities[] = SNMP_READ_COMMUNITIES;
static ROM char * ROM cWriteCommunities[] = SNMP_WRITE_COMMUNITIES;
ROM char * strCommunity;
for(i = 0; i < SNMP_MAX_COMMUNITY_SUPPORT; i++)
{
// Get a pointer to the next community string
strCommunity = cReadCommunities[i];
if(i >= sizeof(cReadCommunities)/sizeof(cReadCommunities[0]))
strCommunity = "";
// Ensure we don't buffer overflow. If your code gets stuck here,
// it means your SNMP_COMMUNITY_MAX_LEN definition in TCPIPConfig.h
// is either too small or one of your community string lengths
// (SNMP_READ_COMMUNITIES) are too large. Fix either.
if(strlenpgm(strCommunity) >= sizeof(AppConfig.readCommunity[0]))
while(1);
// Copy string into AppConfig
strcpypgm2ram((char*)AppConfig.readCommunity[i], strCommunity);
// Get a pointer to the next community string
strCommunity = cWriteCommunities[i];
if(i >= sizeof(cWriteCommunities)/sizeof(cWriteCommunities[0]))
strCommunity = "";
// Ensure we don't buffer overflow. If your code gets stuck here,
// it means your SNMP_COMMUNITY_MAX_LEN definition in TCPIPConfig.h
// is either too small or one of your community string lengths
// (SNMP_WRITE_COMMUNITIES) are too large. Fix either.
if(strlenpgm(strCommunity) >= sizeof(AppConfig.writeCommunity[0]))
while(1);
// Copy string into AppConfig
strcpypgm2ram((char*)AppConfig.writeCommunity[i], strCommunity);
}
}
#endif
// Load the default NetBIOS Host Name
memcpypgm2ram(AppConfig.NetBIOSName, (ROM void*)MY_DEFAULT_HOST_NAME, 16);
FormatNetBIOSName(AppConfig.NetBIOSName);
#if defined(ZG_CS_TRIS)
// Load the default SSID Name
if (sizeof(MY_DEFAULT_SSID_NAME) > sizeof(AppConfig.MySSID))
{
ZGErrorHandler((ROM char *)"AppConfig.MySSID[] too small");
}
memcpypgm2ram(AppConfig.MySSID, (ROM void*)MY_DEFAULT_SSID_NAME, sizeof(MY_DEFAULT_SSID_NAME));
#endif
#if defined(EEPROM_CS_TRIS)
{
BYTE c;
// When a record is saved, first byte is written as 0x60 to indicate
// that a valid record was saved. Note that older stack versions
// used 0x57. This change has been made to so old EEPROM contents
// will get overwritten. The AppConfig() structure has been changed,
// resulting in parameter misalignment if still using old EEPROM
// contents.
// TCPIP configuration settings will be moved to start from 0x0050.
// The first 80 bytes will be used for application settings.
XEEReadArray(0x0000, &c, 1);
if(c == 0x60u)
XEEReadArray(0x0001, (BYTE*)&AppConfig, sizeof(AppConfig));
else
SaveAppConfig();
}
#elif defined(SPIFLASH_CS_TRIS)
{
BYTE c;
SPIFlashReadArray(0x0000, &c, 1);
if(c == 0x60u)
SPIFlashReadArray(0x0001, (BYTE*)&AppConfig, sizeof(AppConfig));
else
SaveAppConfig();
}
#endif
}
