/*********************************************************************
* Function: WORD IPPutHeader(NODE_INFO *remote,
* BYTE protocol,
* WORD len)
*
* PreCondition: IPIsTxReady() == TRUE
*
* Input: *remote - Destination node address
* protocol - Current packet protocol
* len - Current packet data length
*
* Output: (WORD)0
*
* Side Effects: None
*
* Note: Only one IP message can be transmitted at any
* time.
********************************************************************/
WORD IPPutHeader(NODE_INFO *remote,
BYTE protocol,
WORD len)
{
IP_HEADER header;
IPHeaderLen = sizeof(IP_HEADER);
header.VersionIHL = IP_VERSION | IP_IHL;
header.TypeOfService = IP_SERVICE;
header.TotalLength = sizeof(header) + len;
header.Identification = ++_Identifier;
header.FragmentInfo = 0;
header.TimeToLive = MY_IP_TTL;
header.Protocol = protocol;
header.HeaderChecksum = 0;
header.SourceAddress = AppConfig.MyIPAddr;
header.DestAddress.Val = remote->IPAddr.Val;
SwapIPHeader(&header);
header.HeaderChecksum = CalcIPChecksum((BYTE*)&header, sizeof(header));
MACPutHeader(&remote->MACAddr, MAC_IP, (sizeof(header)+len));
MACPutArray((BYTE*)&header, sizeof(header));
return 0x0000;
}
/*********************************************************************
* Function: void ICMPPut(NODE_INFO *remote,
* ICMP_CODE code,
* BYTE *data,
* BYTE len,
* WORD id,
* WORD seq)
*
* PreCondition: ICMPIsTxReady() == TRUE
*
* Input: remote - Remote node info
* code - ICMP_ECHO_REPLY or ICMP_ECHO_REQUEST
* data - Data bytes
* len - Number of bytes to send
* id - ICMP identifier
* seq - ICMP sequence number
*
* Output: None
*
* Side Effects: None
*
* Note: A ICMP packet is created and put on MAC.
*
********************************************************************/
void ICMPPut(NODE_INFO *remote,
ICMP_CODE code,
BYTE *data,
BYTE len,
WORD id,
WORD seq)
{
ICMP_PACKET packet;
packet.Code = 0;
packet.Type = code;
packet.Checksum = 0;
packet.Identifier = id;
packet.SequenceNumber = seq;
memcpy((void*)packet.Data, (void*)data, len);
SwapICMPPacket(&packet);
packet.Checksum = CalcIPChecksum((BYTE*)&packet,
(WORD)(ICMP_HEADER_SIZE + len));
IPPutHeader(remote,
IP_PROT_ICMP,
(WORD)(ICMP_HEADER_SIZE + len));
IPPutArray((BYTE*)&packet, (WORD)(ICMP_HEADER_SIZE + len));
MACFlush();
}
/*********************************************************************
* Function: BOOL ICMPGet(ICMP_CODE *code,
* BYTE *data,
* BYTE *len,
* WORD *id,
* WORD *seq)
*
* PreCondition: MAC buffer contains ICMP type packet.
*
* Input: code - Buffer to hold ICMP code value
* data - Buffer to hold ICMP data
* len - Buffer to hold ICMP data length
* id - Buffer to hold ICMP id
* seq - Buffer to hold ICMP seq
*
* Output: TRUE if valid ICMP packet was received
* FALSE otherwise.
*
* Side Effects: None
*
* Overview: None
*
* Note: None
********************************************************************/
BOOL ICMPGet(ICMP_CODE *code,
BYTE *data,
BYTE *len,
WORD *id,
WORD *seq)
{
ICMP_PACKET packet;
WORD checksums[2];
WORD CalcChecksum;
WORD ReceivedChecksum;
MACGetArray((BYTE*)&packet, ICMP_HEADER_SIZE);
ReceivedChecksum = packet.Checksum;
packet.Checksum = 0;
checksums[0] = ~CalcIPChecksum((BYTE*)&packet, ICMP_HEADER_SIZE);
*len -= ICMP_HEADER_SIZE;
MACGetArray(data, *len);
checksums[1] = ~CalcIPChecksum(data, *len);
CalcChecksum = CalcIPChecksum((BYTE*)checksums, 2 * sizeof(WORD));
SwapICMPPacket(&packet);
*code = packet.Type;
*id = packet.Identifier;
*seq = packet.SequenceNumber;
return ( CalcChecksum == ReceivedChecksum );
}
void SaveAppConfig(const APP_CONFIG *ptrAppConfig) {
NVM_VALIDATION_STRUCT NVMValidationStruct;
// Ensure adequate space has been reserved in non-volatile storage to
// store the entire AppConfig structure. If you get stuck in this while(1)
// trap, it means you have a design time misconfiguration in TCPIPConfig.h.
// You must increase MPFS_RESERVE_BLOCK to allocate more space.
#if defined(STACK_USE_MPFS2)
if (sizeof (NVMValidationStruct) + sizeof (AppConfig) > MPFS_RESERVE_BLOCK)
while (1);
#endif
// Get proper values for the validation structure indicating that we can use
// these EEPROM/Flash contents on future boot ups
NVMValidationStruct.wOriginalChecksum = wOriginalAppConfigChecksum;
NVMValidationStruct.wCurrentChecksum = CalcIPChecksum((BYTE*) ptrAppConfig, sizeof (APP_CONFIG));
NVMValidationStruct.wConfigurationLength = sizeof (APP_CONFIG);
// Write the validation struct and current AppConfig contents to EEPROM/Flash
#if defined(EEPROM_CS_TRIS)
XEEBeginWrite(0x0000);
XEEWriteArray((BYTE*) & NVMValidationStruct, sizeof (NVMValidationStruct));
XEEWriteArray((BYTE*) ptrAppConfig, sizeof (APP_CONFIG));
#else
SPIFlashBeginWrite(0x0000);
SPIFlashWriteArray((BYTE*) & NVMValidationStruct, sizeof (NVMValidationStruct));
SPIFlashWriteArray((BYTE*) ptrAppConfig, sizeof (APP_CONFIG));
#endif
}
/*********************************************************************
* Function: void RebootTask(void)
*
* PreCondition: Stack is initialized()
*
* Input: None
*
* Output: None
*
* Side Effects: None
*
* Overview: Checks for incomming traffic on port 69.
* Resets the PIC if a 'R' is received.
*
* Note: This module is primarily for use with the
* Ethernet bootloader. By resetting, the Ethernet
* bootloader can take control for a second and let
* a firmware upgrade take place.
********************************************************************/
void RebootTask(void)
{
static UDP_SOCKET MySocket = INVALID_UDP_SOCKET;
struct
{
BYTE vMACAddress[6];
DWORD dwIPAddress;
WORD wChecksum;
} BootloaderAddress;
if(MySocket == INVALID_UDP_SOCKET)
MySocket = UDPOpenEx(0,UDP_OPEN_SERVER,REBOOT_PORT,INVALID_UDP_PORT);
// MySocket = UDPOpen(REBOOT_PORT, NULL, INVALID_UDP_PORT);
if(MySocket == INVALID_UDP_SOCKET)
return;
// Do nothing if no data is waiting
if(!UDPIsGetReady(MySocket))
return;
#if defined(REBOOT_SAME_SUBNET_ONLY)
// Respond only to name requests sent to us from nodes on the same subnet
if((remoteNode.IPAddr.Val & AppConfig.MyMask.Val) != (AppConfig.MyIPAddr.Val & AppConfig.MyMask.Val))
{
UDPDiscard();
return;
}
#endif
// Get our MAC address, IP address, and compute a checksum of them
memcpy((void*)&BootloaderAddress.vMACAddress[0], (void*)&AppConfig.MyMACAddr.v[0], sizeof(AppConfig.MyMACAddr));
BootloaderAddress.dwIPAddress = AppConfig.MyIPAddr.Val;
BootloaderAddress.wChecksum = CalcIPChecksum((BYTE*)&BootloaderAddress, sizeof(BootloaderAddress) - sizeof(BootloaderAddress.wChecksum));
// To enter the bootloader, we need to clear the /POR bit in RCON.
// Otherwise, the bootloader will immediately hand off execution
// to us.
#if defined(USE_LCD)
strcpypgm2ram((char*)LCDText, "Bootloader Reset");
LCDUpdate();
#endif
#if !defined(__STM32F10X__)
RCONbits.POR = 0;
#if defined(__18CXX)
{
WORD_VAL wvPROD;
wvPROD.Val = ((WORD)&BootloaderAddress);
PRODH = wvPROD.v[1];
PRODL = wvPROD.v[0];
}
#endif
#endif
Reset();
}
/**
* A ICMP packet is created and put on MAC.
*
* @preCondition ICMPIsTxReady() == TRUE
*
* @param remote Remote node info
* @param code ICMP_ECHO_REPLY or ICMP_ECHO_REQUEST
* @param data Data bytes
* @param len Number of bytes to send
* @param id ICMP identifier
* @param seq ICMP sequence number
*/
void ICMPPut(NODE_INFO *remote,
ICMP_CODE code,
BYTE *data,
BYTE len,
WORD id,
WORD seq)
{
ICMP_PACKET packet;
WORD ICMPLen;
BUFFER MyTxBuffer;
MyTxBuffer = MACGetTxBuffer(TRUE);
// Abort if there is no where in the Ethernet controller to
// store this packet.
if(MyTxBuffer == INVALID_BUFFER)
return;
IPSetTxBuffer(MyTxBuffer, 0);
ICMPLen = ICMP_HEADER_SIZE + (WORD)len;
packet.Code = 0;
packet.Type = code;
packet.Checksum = 0;
packet.Identifier = id;
packet.SequenceNumber = seq;
memcpy((void*)packet.Data, (void*)data, len);
SwapICMPPacket(&packet);
#if defined(NON_MCHP_MAC) //This is NOT a Microchip MAC
packet.Checksum = CalcIPChecksum((BYTE*)&packet,
ICMPLen);
#endif
IPPutHeader(remote,
IP_PROT_ICMP,
(WORD)(ICMP_HEADER_SIZE + len));
IPPutArray((BYTE*)&packet, ICMPLen);
#if !defined(NON_MCHP_MAC) //This is a Microchip MAC
// Calculate and write the ICMP checksum using the Microchip MAC's DMA
packet.Checksum = MACCalcTxChecksum(sizeof(IP_HEADER), ICMPLen);
IPSetTxBuffer(MyTxBuffer, 2);
MACPutArray((BYTE*)&packet.Checksum, 2);
#endif
MACFlush();
}
/**
* Gets the next ICMP packet
*
* @preCondition MAC buffer contains ICMP type packet.
*
* @param code Buffer to hold ICMP code value
* @param data Buffer to hold ICMP data
* @param len Buffer to hold ICMP data length
* @param id Buffer to hold ICMP id
* @param seq Buffer to hold ICMP seq
*
* @return TRUE if valid ICMP packet was received <br>
* FALSE otherwise
*/
BOOL ICMPGet(ICMP_CODE *code,
BYTE *data,
BYTE *len,
WORD *id,
WORD *seq)
{
ICMP_PACKET packet;
WORD CalcChecksum;
WORD ReceivedChecksum;
#if defined(NON_MCHP_MAC)
WORD checksums[2];
#endif
//Read ICMP Header. The data is read from the current MAC RX Buffer
MACGetArray((BYTE*)&packet, ICMP_HEADER_SIZE);
#if !defined(NON_MCHP_MAC)
// Calculate the checksum using the Microchip MAC's DMA module
// The checksum data includes the precomputed checksum in the
// header, so a valid packet will always have a checksum of
// 0x0000 if the packet is not disturbed.
ReceivedChecksum = 0x0000;
CalcChecksum = MACCalcRxChecksum(0+sizeof(IP_HEADER), *len);
#endif
// Obtain the ICMP data payload
*len -= ICMP_HEADER_SIZE;
MACGetArray(data, *len); //Read ICMP Data. The data is read from the current MAC RX Buffer
#if defined(NON_MCHP_MAC)
// Calculte the checksum in local memory without hardware help
ReceivedChecksum = packet.Checksum;
packet.Checksum = 0;
checksums[0] = ~CalcIPChecksum((BYTE*)&packet, ICMP_HEADER_SIZE);
checksums[1] = ~CalcIPChecksum(data, *len);
CalcChecksum = CalcIPChecksum((BYTE*)checksums, 2 * sizeof(WORD));
#endif
SwapICMPPacket(&packet);
*code = packet.Type;
*id = packet.Identifier;
*seq = packet.SequenceNumber;
return ( CalcChecksum == ReceivedChecksum );
}
/*********************************************************************
* Function: void RebootTask(NET_CONFIG* pConfig)
*
* PreCondition: Stack is initialized()
*
* Input: pConfig - interface
*
* Output: None
*
* Side Effects: None
*
* Overview: Checks for incomming traffic on port 69.
* Resets the PIC if a 'R' is received.
*
* Note: This module is primarily for use with the
* Ethernet bootloader. By resetting, the Ethernet
* bootloader can take control for a second and let
* a firmware upgrade take place.
********************************************************************/
void RebootTask(NET_CONFIG* pConfig)
{
struct
{
uint8_t vMACAddress[6];
uint32_t dwIPAddress;
uint16_t wChecksum;
} BootloaderAddress;
int netIx;
netIx = _TCPIPStackNetIx(pConfig);
if(MySocket[netIx] == INVALID_UDP_SOCKET)
{
MySocket[netIx] = UDPOpen(0,UDP_OPEN_SERVER,REBOOT_PORT,INVALID_UDP_PORT);
if(MySocket[netIx] == INVALID_UDP_SOCKET)
{
return;
}
UDPSocketSetNet(MySocket[netIx], pConfig);
}
// Do nothing if no data is waiting
if(!UDPIsGetReady(MySocket[netIx]))
return;
#if defined(REBOOT_SAME_SUBNET_ONLY)
// Respond only to name requests sent to us from nodes on the same subnet
if((remoteNode.IPAddr.Val & pConfig->MyMask.Val) != (pConfig->MyIPAddr.Val & pConfig->MyMask.Val))
{
UDPDiscard(pConfig);
return;
}
#endif
// Get our MAC address, IP address, and compute a checksum of them
memcpy((void*)&BootloaderAddress.vMACAddress[0], (void*)&pConfig->MyMACAddr.v[0], sizeof(pConfig->MyMACAddr));
BootloaderAddress.dwIPAddress = pConfig->MyIPAddr.Val;
BootloaderAddress.wChecksum = CalcIPChecksum((uint8_t*)&BootloaderAddress, sizeof(BootloaderAddress) - sizeof(BootloaderAddress.wChecksum));
// To enter the bootloader, we reset the system
SYS_OUT_MESSAGE("Bootloader Reset");
SYS_Reboot();
}
void ICMPSendPing(DWORD dwRemoteIP)
{
// Figure out the MAC address to send to
ICMPRemote.IPAddr.Val = dwRemoteIP;
ARPResolve(&ICMPRemote.IPAddr);
// Set up the ping packet
ICMPHeader.vType = 0x08; // 0x08: Echo (ping) request
ICMPHeader.vCode = 0x00;
ICMPHeader.wvChecksum.Val = 0x0000;
ICMPHeader.wvIdentifier.Val = 0xEFBE;
ICMPHeader.wvSequenceNumber.Val++;
ICMPHeader.wvChecksum.Val = CalcIPChecksum((BYTE*)&ICMPHeader, sizeof(ICMPHeader));
// Kick off the ICMPGetReply() state machine
ICMPTimer = TickGet();
ICMPFlags.bReplyValid = 0;
ICMPState = SM_ARP_RESOLVE;
}
// Function: GetWiFiData()
// Summary: This function should exit the slave from pass through mode and send the 'G' command to GET the
// data from the WiFi device. This function will then calculate the checksum and return it's success.
// Return: 0 if Success, 1 if Fail to read any data, 2 is checksum is not correct
char GetWiFiData()
{
int i;
char* ptr;
char c;
volatile BYTE chksum;
// First Exit pass thru mode if necessary
if(WiFiModuleMode != CMD_READY)
{
if(ExitPassThruMode() != 0) return 1;
}
// Send the "G" command to get the WiFi Boards data.
writeByteSpi('G');
c = readByteSpi();
if( c != 'G')
{
// The WiFi board didn't respond correctly. Something is wrong.
WiFiInfo.CurrentSettings.WiFiConnectedToNetwork = 0;
WiFiModuleMode = UNKNOWN;
return 1;
}
WiFiInfo.WiFiModuleAttached = 1;
// Now try to read the data.
for (i=0; i<sizeof(wiFiSettings); i++)
{
ptr = (char*)&WiFiInfo.CurrentSettings + i;
*ptr = readByteSpi();
}
// Calculate the checksum on the data to verify good data
chksum = CalcIPChecksum((BYTE*)&WiFiInfo.CurrentSettings, sizeof(wiFiSettings) - 1);
if(chksum == WiFiInfo.CurrentSettings.CheckSum)
WiFiInfo.CurrentSettings.WiFiConnectedToNetwork = 1;
else
WiFiInfo.CurrentSettings.WiFiConnectedToNetwork = 0;
return !WiFiInfo.CurrentSettings.WiFiConnectedToNetwork;
}
/**
* Write the Ethernet Header (MAC Header) and IP Header to the current TX buffer.
* The last parameter (len) is the length of the data to follow.
* This function will do the following: <ul>
* <li> Reset the NIC Remote DMA write pointer to the first byte of the current TX Buffer </li>
* <li> Write the given header </li>
* <li> Set the NIC Remote DMA byte count to the given len. This configures the Remote DMA
* to send the given number of bytes. Only one IP message can be transmitted at any time.
* Caller may not transmit and receive a message at the same time.</li></ul>
*
* @preCondition IPIsTxReady() == TRUE
*
* @param remote Destination node address
* @param protocol Protocol of data to follow, for example IP_PROT_ICMP, IP_PROT_TCP....
* @param len Total length of IP data bytes to follow, excluding IP header. This
* is the length of the bytes to follow.
*
* @return Handle to current packet - For use by IPSendByte() function.
*
*/
WORD IPPutHeader(NODE_INFO *remote,
BYTE protocol,
WORD len)
{
IP_HEADER header;
header.VersionIHL = IP_VERSION | IP_IHL;
header.TypeOfService = IP_SERVICE;
header.TotalLength.Val = sizeof(header) + len;
header.Identification.Val = ++_Identifier;
/** Set the Don't fragment flag for all IP message we sent. We do NOT want to get fragmented data! */
header.FragmentInfo.Val = IP_FLAG_MASK_DF;
header.TimeToLive = MY_IP_TTL;
header.Protocol = protocol;
header.HeaderChecksum.Val = 0;
header.SourceAddress.v[0] = MY_IP_BYTE1;
header.SourceAddress.v[1] = MY_IP_BYTE2;
header.SourceAddress.v[2] = MY_IP_BYTE3;
header.SourceAddress.v[3] = MY_IP_BYTE4;
header.DestAddress.Val = remote->IPAddr.Val;
SwapIPHeader(&header);
header.HeaderChecksum.Val = CalcIPChecksum((BYTE*)&header,
sizeof(header));
//Write the Ethernet Header to the current TX buffer. The last parameter (dataLen) is the length
//of the data to follow. This function will do the following:
// - Reset the NIC Remote DMA write pointer to the first byte of the current TX Buffer
// - Write the given header
// - Set the NIC Remote DMA byte count to the given len. This configures the Remote DMA to
// receive the given number of bytes
MACPutHeader(&remote->MACAddr, MAC_IP, (sizeof(header)+len));
//Write the IP header to the MAC's TX buffer.
MACPutArray((BYTE*)&header, sizeof(header));
return 0x0;
}
/*********************************************************************
* Function: WORD IPPutHeader(NODE_INFO *remote,
* BYTE protocol,
* WORD len)
*
* PreCondition: IPIsTxReady() == TRUE
*
* Input: *remote - Destination node address
* protocol - Current packet protocol
* len - Current packet data length
*
* Output: (WORD)0
*
* Side Effects: None
*
* Note: Only one IP message can be transmitted at any
* time.
********************************************************************/
WORD IPPutHeader(NODE_INFO *remote,
BYTE protocol,
WORD len)
{
IP_HEADER header;
IPHeaderLen = sizeof(IP_HEADER);
header.VersionIHL = IP_VERSION | IP_IHL;
header.TypeOfService = IP_SERVICE;
header.TotalLength = sizeof(header) + len;
header.Identification = ++_Identifier;
header.FragmentInfo = 0;
header.TimeToLive = MY_IP_TTL;
header.Protocol = protocol;
header.HeaderChecksum = 0;
header.SourceAddress = AppConfig.MyIPAddr;
header.DestAddress.Val = remote->IPAddr.Val;
SwapIPHeader(&header);
#if defined(NON_MCHP_MAC)
header.HeaderChecksum = CalcIPChecksum((BYTE*)&header,
sizeof(header));
#endif
MACPutHeader(&remote->MACAddr, MAC_IP, (sizeof(header)+len));
MACPutArray((BYTE*)&header, sizeof(header));
#if !defined(NON_MCHP_MAC)
header.HeaderChecksum = MACCalcTxChecksum(0, sizeof(header));
MACSetTxBuffer(CurrentTxBuffer, 10); // 10 is the offset in header to the HeaderChecksum member
MACPutArray((BYTE*)&header.HeaderChecksum, 2);
MACSetTxBuffer(CurrentTxBuffer, sizeof(header)); // Seek back to the end of the packet
#endif
return 0x0;
}
static void InitAppConfig(void)
{
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;
// Load the default NetBIOS Host Name
memcpypgm2ram(AppConfig.NetBIOSName, (ROM void*)MY_DEFAULT_HOST_NAME, 16);
FormatNetBIOSName(AppConfig.NetBIOSName);
// Compute the checksum of the AppConfig defaults as loaded from ROM
wOriginalAppConfigChecksum = CalcIPChecksum((BYTE*)&AppConfig, sizeof(AppConfig));
break;
}
}
// Function: DoWiFiWork()
// Summary: This function maintains the connection status with the WiFi module and sets the status
// variables accordingly. Once connection is established this function updates the WiFi module with
// up to date information regarding the focusers and also reads up to date information regarding the
// WiFi configuration on the WiFi module. Finally, this method checks if there are incoming commands
// from the WiFi module and adds them to the command buffer when necessary.
void DoWiFiWork()
{
// First check if the WiFi board connection is verified. ********************************************
if(!WiFiInfo.CurrentSettings.WiFiConnectedToNetwork)
{
// Try to connect if it has been longer than 5 seconds
if((TickGet() - WiFiConnTimeout) > (TICKS_PER_SECOND * 5))
{
WiFiConnTimeout = TickGet();
if( GetWiFiData() != 0)
{
// Error proper data from the device...
// We don't need to do anything else because we can't communcicate properly.
// GetWifiData has already set ConnectedTo invalid
// The mode is already set by the enter/exit pass thru methods.
return;
}
else
{
// Received proper data from the device. Check the version info
if(WiFiInfo.CurrentSettings.FirmwareVersion[0] < MinReqVersion[0] ||
WiFiInfo.CurrentSettings.FirmwareVersion[1] < MinReqVersion[1] ||
WiFiInfo.CurrentSettings.FirmwareVersion[2] < MinReqVersion[2])
{
WiFiInfo.WiFiHasCorrectFirmware = 0;
}
else
{
WiFiInfo.WiFiHasCorrectFirmware = 1;
}
}
}
return;
}
// If the connection is established, make sure the Firmware Version is correct before doing anything else
if(WiFiInfo.WiFiHasCorrectFirmware == 0)
{
// Set the connection state false so that the device attempts to reconnect...
WiFiInfo.CurrentSettings.WiFiConnectedToNetwork = 0;
return;
}
// ***************************************************************************************************
// The connection has been verified, try to get new info from the device if the desired amount of time has
// passed.
if( (TickGet() - WiFiGetConfigTimer) > (TICKS_PER_SECOND / 2)) // Only check every 1/2 second.
{
WiFiGetConfigTimer = TickGet(); // Update the timer value.
if(GetWiFiData() != 0)return;
// if an error occurs stop now.
// Data has been read from the device. Update the device with focuser status.
// Check for a received command that the WiFi client has requested.
if(WiFiInfo.CurrentSettings.Command[0] == '<')
{
// The WiFi board wants us to process a command
focuserCommand newCmd;
int len;
// Make sure the 'F' is present
if(WiFiInfo.CurrentSettings.Command[1] != 'F') return;
// Make sure a correct target is specified.
if( (WiFiInfo.CurrentSettings.Command[2] != '1') &&
(WiFiInfo.CurrentSettings.Command[2] != '2') &&
(WiFiInfo.CurrentSettings.Command[2] != 'H')) return;
// Determine the Command Length
for(len=0; len<22; len++)
{
if(WiFiInfo.CurrentSettings.Command[len] == '>') break;
}
len-=4; // To get rid of <,F,1, and > characters
newCmd.source = WIFI_HTTP;
InterpretCommandString((char*)&WiFiInfo.CurrentSettings.Command[3], len, &newCmd);
AddCmdToBfr((char)WiFiInfo.CurrentSettings.Command[2], &newCmd );
}
}
// ***************************************************************************************************
// Try to send the device the latest focuser status to the WiFi Module
if( (TickGet() - WiFiSetStatusTimer) > (TICKS_PER_SECOND / 2)) // Only check every half second
{
WiFiSetStatusTimer = TickGet(); // Update the timer value
strcpy((char*)&DeviceStatus.F1Nickname, (char*)&MyFocuser1.configStr.DeviceNickname);
strcpy((char*)&DeviceStatus.F2Nickname, (char*)&MyFocuser2.configStr.DeviceNickname);
DeviceStatus.F1CurrentPos = MyFocuser1.statusStr.CurrentPosition;
DeviceStatus.F2CurrentPos = MyFocuser2.statusStr.CurrentPosition;
DeviceStatus.F1CurrentTemp = MyFocuser1.statusStr.CurrentTemp;
DeviceStatus.F2CurrentTemp = MyFocuser2.statusStr.CurrentTemp;
DeviceStatus.F1MaxPos = MyFocuser1.motionInfoStr.MaxPosition;
DeviceStatus.F2MaxPos = MyFocuser2.motionInfoStr.MaxPosition;
DeviceStatus.F1TempCompOn = MyFocuser1.tempCompInfoStr.TempCompOn;
DeviceStatus.F2TempCompOn = MyFocuser2.tempCompInfoStr.TempCompOn;
SetWiFiData('S', (char*)&DeviceStatus, sizeof(deviceStatus));
}
// ***************************************************************************************************
// If there are pending changes to WiFi Module settings send the changes now...
if(WiFiInfo.ChangesArePending)
{
// Calculate a new Checksum for the PendingSettings
WiFiInfo.PendingSettings.CheckSum = CalcIPChecksum((BYTE*)&WiFiInfo.PendingSettings, sizeof(wiFiSettings) - 1);
// Send the new settings to the WiFi board
SetWiFiData('C', (char*)&WiFiInfo.PendingSettings, sizeof(wiFiSettings));
WiFiInfo.ChangesArePending = 0;
}
}
/*********************************************************************
* Function: BOOL IPGetHeader( IP_ADDR *localIP,
* NODE_INFO *remote,
* BYTE *Protocol,
* WORD *len)
*
* PreCondition: MACGetHeader() == TRUE
*
* Input: localIP - Local node IP Address as received
* in current IP header.
* If this information is not required
* caller may pass NULL value.
* remote - Remote node info
* Protocol - Current packet protocol
* len - Current packet data length
*
* Output: TRUE, if valid packet was received
* FALSE otherwise
*
* Side Effects: None
*
* Note: Only one IP message can be received.
* Caller may not transmit and receive a message
* at the same time.
*
********************************************************************/
BOOL IPGetHeader(IP_ADDR *localIP,
NODE_INFO *remote,
BYTE *protocol,
WORD *len)
{
WORD_VAL CalcChecksum;
IP_HEADER header;
#if defined(NON_MCHP_MAC)
WORD_VAL ReceivedChecksum;
WORD checksums[2];
BYTE optionsLen;
#define MAX_OPTIONS_LEN (40u) // As per RFC 791.
BYTE options[MAX_OPTIONS_LEN];
#endif
// Read IP header.
MACGetArray((BYTE*)&header, sizeof(header));
// Make sure that this is an IPv4 packet.
if((header.VersionIHL & 0xf0) != IP_VERSION)
return FALSE;
// Throw this packet away if it is a fragment.
// We don't have enough RAM for IP fragment reconstruction.
if(header.FragmentInfo & 0xFF1F)
return FALSE;
IPHeaderLen = (header.VersionIHL & 0x0f) << 2;
#if !defined(NON_MCHP_MAC)
// Validate the IP header. If it is correct, the checksum
// will come out to 0x0000 (because the header contains a
// precomputed checksum). A corrupt header will have a
// nonzero checksum.
CalcChecksum.Val = MACCalcRxChecksum(0, IPHeaderLen);
// Seek to the end of the IP header
MACSetReadPtrInRx(IPHeaderLen);
if(CalcChecksum.Val)
#else
// Calculate options length in this header, if there is any.
// IHL is in terms of numbers of 32-bit DWORDs; i.e. actual
// length is 4 times IHL.
optionsLen = IPHeaderLen - sizeof(header);
// If there is any option(s), read it so that we can include them
// in checksum calculation.
if ( optionsLen > MAX_OPTIONS_LEN )
return FALSE;
if ( optionsLen > 0u )
MACGetArray(options, optionsLen);
// Save header checksum; clear it and recalculate it ourselves.
ReceivedChecksum.Val = header.HeaderChecksum;
header.HeaderChecksum = 0;
// Calculate checksum of header including options bytes.
checksums[0] = ~CalcIPChecksum((BYTE*)&header, sizeof(header));
// Calculate Options checksum too, if they are present.
if ( optionsLen > 0u )
checksums[1] = ~CalcIPChecksum((BYTE*)options, optionsLen);
else
checksums[1] = 0;
CalcChecksum.Val = CalcIPChecksum((BYTE*)checksums,
2 * sizeof(WORD));
// Make sure that checksum is correct
if ( ReceivedChecksum.Val != CalcChecksum.Val )
#endif
{
// Bad packet. The function caller will be notified by means of the FALSE
// return value and it should discard the packet.
return FALSE;
}
// Network to host conversion.
SwapIPHeader(&header);
// If caller is intrested, return destination IP address
// as seen in this IP header.
if ( localIP )
localIP->Val = header.DestAddress.Val;
remote->IPAddr.Val = header.SourceAddress.Val;
*protocol = header.Protocol;
*len = header.TotalLength - IPHeaderLen;
return TRUE;
}
/**
* Only one IP message can be received. Caller may not transmit and receive
* a message at the same time.
*
* @preCondition MACRxbufGetHdr() == TRUE
*
* @param localIP Local node IP Address (Destination IP Address) as received in current IP header.
* If this information is not required caller may pass NULL value.
* @param remote Remote node info
* @param protocol Current packet protocol
* @param len Length of IP data. For example, if TCP is contained in this IP
* packet, this will be = TCP Header length + TCP Data Length
*
* @return TRUE, if valid packet was received <br>
* FALSE otherwise
*/
BOOL IPGetHeader(IP_ADDR *localIP,
NODE_INFO *remote,
BYTE *protocol,
WORD *len)
{
WORD_VAL ReceivedChecksum;
WORD_VAL CalcChecksum;
WORD checksums[2];
IP_HEADER header;
BYTE optionsLen;
#define MAX_OPTIONS_LEN (20) // As per RFC 791.
BYTE options[MAX_OPTIONS_LEN];
//Read IP header. The data is read from the current MAC RX Buffer
MACRxbufGetArray((BYTE*)&header, sizeof(header));
//Write out ID of received IP header
#if (DEBUG_IP >= LOG_DEBUG)
debugPutMsg(1); //@mxd:1:Received IP header with ID=0x%x%x
//Write HEX WORD value of tmp
debugPutByteHex(header.Identification.v[0]);
debugPutByteHex(header.Identification.v[1]);
#endif
// Make sure that this IPv4 packet.
if ( (header.VersionIHL & 0xf0) != IP_VERSION )
{
goto IPGetHeader_Discard;
}
/*
* Calculate options length in this header, if there is any.
* IHL is in terms of numbers of 32-bit DWORDs; i.e. actual
* length is 4 times IHL.
*/
optionsLen = ((header.VersionIHL & 0x0f) << 2) - sizeof(header);
/*
* If there is any option(s), read it so that we can include them
* in checksum calculation.
*/
if ( optionsLen > MAX_OPTIONS_LEN )
{
goto IPGetHeader_Discard;
}
if ( optionsLen > 0 ) {
//Read options data. The data is read from the current MAC RX Buffer
MACRxbufGetArray(options, optionsLen);
}
// Save header checksum; clear it and recalculate it ourselves.
ReceivedChecksum.Val = header.HeaderChecksum.Val;
header.HeaderChecksum.Val = 0;
// Calculate checksum of header including options bytes.
checksums[0] = ~CalcIPChecksum((BYTE*)&header, sizeof(header));
// Calculate Options checksum too, if they are present.
if ( optionsLen > 0 )
checksums[1] = ~CalcIPChecksum((BYTE*)options, optionsLen);
else
checksums[1] = 0;
CalcChecksum.Val = CalcIPChecksum((BYTE*)checksums,
2 * sizeof(WORD));
// Network to host conversion.
SwapIPHeader(&header);
// Make sure that checksum is correct and IP version is supported.
if ( ReceivedChecksum.Val != CalcChecksum.Val ||
(header.VersionIHL & 0xf0) != IP_VERSION )
{
// Bad/Unknown packet. Discard it.
goto IPGetHeader_Discard;
}
/*
* If caller is intrested, return destination IP address
* as seen in this IP header.
*/
if ( localIP )
localIP->Val = header.DestAddress.Val;
remote->IPAddr.Val = header.SourceAddress.Val;
*protocol = header.Protocol;
*len = header.TotalLength.Val - optionsLen - sizeof(header);
return TRUE;
IPGetHeader_Discard:
MACRxbufDiscard();
return FALSE;
}
/*********************************************************************
* Function: void InitAppConfig(void)
*
* PreCondition: MPFSInit() is already called.
*
* Input: None
*
* Output: Write/Read non-volatile config variables.
*
* Side Effects: None
*
* Overview: None
*
* Note: None
********************************************************************/
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));
// }
// SoftAP on certain setups with IP 192.168.1.1 has problem with DHCP client assigning new IP address on redirection.
// 192.168.1.1 is a common IP address with most APs. This is still under investigation.
// For now, assign this as 192.168.1.3
//#if (MY_DEFAULT_NETWORK_TYPE == WF_SOFT_AP)
AppConfig.MyIPAddr.Val = 192ul | 168ul<<8ul | 1ul<<16ul | 3ul<<24ul;
AppConfig.DefaultIPAddr.Val = AppConfig.MyIPAddr.Val;
AppConfig.MyMask.Val = 255ul | 255ul<<8ul | 0ul<<16ul | 0ul<<24ul;
AppConfig.DefaultMask.Val = AppConfig.MyMask.Val;
AppConfig.MyGateway.Val = AppConfig.MyIPAddr.Val;
AppConfig.PrimaryDNSServer.Val = AppConfig.MyIPAddr.Val;
AppConfig.SecondaryDNSServer.Val = AppConfig.MyIPAddr.Val;
//#else
/*
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;
* */
//#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;
AppConfig.SecurityMode = MY_DEFAULT_WIFI_SECURITY_MODE;
if (AppConfig.SecurityMode == WF_SECURITY_WEP_40) {
AppConfig.WepKeyIndex = MY_DEFAULT_WEP_KEY_INDEX;
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;
} else if (AppConfig.SecurityMode == WF_SECURITY_WEP_104) {
AppConfig.WepKeyIndex = MY_DEFAULT_WEP_KEY_INDEX;
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;
}
AppConfig.networkType = MY_DEFAULT_NETWORK_TYPE;
AppConfig.dataValid = 0;
#endif
// Compute the checksum of the AppConfig defaults as loaded from ROM
wOriginalAppConfigChecksum = CalcIPChecksum((BYTE*) & AppConfig, sizeof (AppConfig));
/*
#if defined(EEPROM_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
XEEReadArray(0x0000, (BYTE*)&NVMValidationStruct, sizeof(NVMValidationStruct));
XEEReadArray(sizeof(NVMValidationStruct), (BYTE*)&AppConfig, sizeof(AppConfig));
// 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;
}
#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
}
/*********************************************************************
* Function: LONG ICMPGetReply(void)
*
* PreCondition: ICMPBeginUsage() returned TRUE and ICMPSendPing()
* was called
*
* Input: None
*
* Output: -3: Could not resolve hostname (DNS timeout or
* hostname invalid)
* -2: No response received yet
* -1: Operation timed out (longer than ICMP_TIMEOUT)
* has elapsed.
* >=0: Number of TICKs that elapsed between
* initial ICMP transmission and reception of
* a valid echo.
*
* Side Effects: None
*
* Overview: None
*
* Note: None
********************************************************************/
LONG ICMPGetReply(void)
{
ICMP_PACKET ICMPPacket;
switch(ICMPState)
{
#if defined(STACK_USE_DNS)
case SM_DNS_SEND_QUERY:
// Obtain DNS module ownership
if(!DNSBeginUsage())
break;
// Send DNS query
if(ICMPFlags.bRemoteHostIsROM)
DNSResolveROM(StaticVars.RemoteHost.szROM, DNS_TYPE_A);
else
DNSResolve(StaticVars.RemoteHost.szRAM, DNS_TYPE_A);
ICMPState = SM_DNS_GET_RESPONSE;
break;
case SM_DNS_GET_RESPONSE:
// See if DNS is done, and if so, get the remote IP address
if(!DNSIsResolved(&StaticVars.ICMPRemote.IPAddr))
break;
// Free the DNS module
DNSEndUsage();
// Return error code if the DNS query failed
if(StaticVars.ICMPRemote.IPAddr.Val == 0x00000000ul)
{
ICMPState = SM_IDLE;
return -3;
}
ICMPState = SM_ARP_SEND_QUERY;
// No break;
#endif
case SM_ARP_SEND_QUERY:
ARPResolve(&StaticVars.ICMPRemote.IPAddr);
ICMPState = SM_ARP_GET_RESPONSE;
break;
case SM_ARP_GET_RESPONSE:
// See if the ARP reponse was successfully received
if(!ARPIsResolved(&StaticVars.ICMPRemote.IPAddr, &StaticVars.ICMPRemote.MACAddr))
break;
ICMPState = SM_ICMP_SEND_ECHO_REQUEST;
// No break;
case SM_ICMP_SEND_ECHO_REQUEST:
if(!IPIsTxReady())
break;
// Set up the ping packet
ICMPPacket.vType = 0x08; // 0x08: Echo (ping) request
ICMPPacket.vCode = 0x00;
ICMPPacket.wChecksum = 0x0000;
ICMPPacket.wIdentifier = 0xEFBE;
wICMPSequenceNumber++;
ICMPPacket.wSequenceNumber = wICMPSequenceNumber;
ICMPPacket.wData = 0x2860;
ICMPPacket.wChecksum = CalcIPChecksum((BYTE*)&ICMPPacket, sizeof(ICMPPacket));
// Record the current time. This will be used as a basis for
// finding the echo response time, which exludes the ARP and DNS
// steps
ICMPTimer = TickGet();
// Position the write pointer for the next IPPutHeader operation
MACSetWritePtr(BASE_TX_ADDR + sizeof(ETHER_HEADER));
// Create IP header in TX memory
IPPutHeader(&StaticVars.ICMPRemote, IP_PROT_ICMP, sizeof(ICMPPacket));
MACPutArray((BYTE*)&ICMPPacket, sizeof(ICMPPacket));
MACFlush();
// Echo sent, advance state
ICMPState = SM_ICMP_GET_ECHO_RESPONSE;
break;
case SM_ICMP_GET_ECHO_RESPONSE:
// See if the echo was successfully received
if(ICMPFlags.bReplyValid)
return (LONG)ICMPTimer;
break;
// SM_IDLE or illegal/impossible state:
default:
return -1;
}
// See if the DNS/ARP/echo request timed out
if(TickGet() - ICMPTimer > ICMP_TIMEOUT)
{
// Free DNS module if we have it in use
#if defined(STACK_USE_DNS)
if(ICMPState == SM_DNS_GET_RESPONSE)
DNSEndUsage();
#endif
// Stop ICMP echo test and return error to caller
ICMPState = SM_IDLE;
return -1;
}
// Still working. No response to report yet.
return -2;
}
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)
{
#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
}
void MyWIFI_InitAppConfig(void) {
// 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));
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);
// 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
// Compute the checksum of the AppConfig defaults as loaded from ROM
wOriginalAppConfigChecksum = CalcIPChecksum((BYTE*) & AppConfig, sizeof (AppConfig));
}
