int Setting::Compare(const SettingData & x, const SettingData & y) const
{
in_addr_t ipX, ipY;
bool bValidX, bValidY;
switch (m_eType & 0xF)
{
case SettingTypeText:
case SettingTypeFile:
return x.strValue.compare(y.strValue);
case SettingTypeColor:
return strcasecmp((const char *)x.strValue, (const char *)y.strValue);
case SettingTypeIP:
bValidX = StringToIPAddress(x.strValue, ipX);
bValidY = StringToIPAddress(y.strValue, ipY);
if (bValidX && bValidY)
{
ipX = htonl(ipX);
ipY = htonl(ipY);
return ipX - ipY;
}
else if (bValidX)
return 1;
else if (bValidY)
return -1;
else
return 0;
case SettingTypeBool:
if (x.bValue)
return y.bValue ? 0 : 1;
else
return y.bValue ? -1 : 0;
case SettingTypeInt:
return x.iValue - y.iValue;
case SettingTypeFloat:
if (x.fValue < y.fValue)
return -1;
else if (x.fValue == y.fValue)
return 0;
else
return 1;
default:
return 0;
}
}
/**
* UDPClientOpen - Create a UDP client on specified port, try more time for arp request.
* \param udpaddr IP address of server
* \param udpport Remote Port of UDP server
* \return The number of current socket or 0 if an error occured during the opening of the socket.
*/
BYTE UDPClientOpen (char *udpaddr, char udpport[])
{
static NODE_INFO Server;
StringToIPAddress((BYTE*) udpaddr, &Server.IPAddr);
ARPResolveMAC((char*) &(Server.IPAddr));
if(ARPIsResolved(&Server.IPAddr, &Server.MACAddr))
return UDPGenericOpen(0, &Server, udpport);
else
return 0;
}
void *
domainInit(void *arg)
{
ORTEDomainProp dp;
ORTEDomainPropDefaultGet(&dp);
ORTEVerbositySetOptions(verbosity);
dp.appLocalManager = StringToIPAddress(manager);
d = ORTEDomainAppCreate(ORTE_DEFAULT_DOMAIN, &dp, NULL, ORTE_TRUE);
return arg;
}
/*****************************************************************************
Function:
void DNSResolve(BYTE* Hostname, BYTE Type)
Summary:
Begins resolution of an address.
Description:
This function attempts to resolve a host name to an IP address. When
called, it starts the DNS state machine. Call DNSIsResolved repeatedly
to determine if the resolution is complete.
Only one DNS resoultion may be executed at a time. The Hostname must
not be modified in memory until the resolution is complete.
Precondition:
DNSBeginUsage returned TRUE on a previous call.
Parameters:
Hostname - A pointer to the null terminated string specifiying the
host for which to resolve an IP.
RecordType - DNS_TYPE_A or DNS_TYPE_MX depending on what type of
record resolution is desired.
Returns:
None
Remarks:
This function requires access to one UDP socket. If none are available,
MAX_UDP_SOCKETS may need to be increased.
***************************************************************************/
void DNSResolve(BYTE* Hostname, BYTE Type)
{
if(StringToIPAddress(Hostname, &ResolvedInfo.IPAddr))
{
Flags.bits.AddressValid = TRUE;
smDNS = DNS_DONE;
}
else
{
DNSHostName = Hostname;
DNSHostNameROM = NULL;
smDNS = DNS_START;
RecordType = Type;
Flags.bits.AddressValid = FALSE;
}
}
/**
* UDPClientOpen - Create a UDP client on specified port, try more time for arp request.
* \param udpaddr IP address of server
* \param udpport Remote Port of UDP server
* \return The number of current socket or 0 if an error occured during the opening of the socket.
*/
BYTE UDPClientOpen (char *udpaddr, char udpport[])
{
#if defined (FLYPORT)
if (WFStatus != TURNED_OFF)
#endif
{
static NODE_INFO Server;
StringToIPAddress((BYTE*) udpaddr, &Server.IPAddr);
ARPResolveMAC((char*) &(Server.IPAddr));
vTaskDelay(30);
if(ARPIsResolved(&Server.IPAddr, &Server.MACAddr))
return UDPGenericOpen(0, &Server, udpport);
else
return 0;
}
return 0;
}
bool Setting::IsValid(const SettingData & sValue) const
{
bool bValid;
unsigned int i;
if ((m_eType & SettingTypeList) == SettingTypeList)
{
bValid = false;
for (i = 0; i < m_iEnum; i++)
{
if (Compare(m_vecEnum[i], sValue) == 0) {
bValid = true;
break;
}
}
}
else if ((m_eType & SettingTypeRange) == SettingTypeRange)
{
bValid = (m_pMin == NULL || Compare(*m_pMin, sValue) <= 0) && (m_pMax == NULL || Compare(*m_pMax, sValue) >= 0);
}
else
bValid = true;
if (bValid)
{
in_addr_t ipAddress;
switch (m_eType & 0xF)
{
case SettingTypeText:
case SettingTypeFile:
return true;
case SettingTypeColor:
return QColor(sValue.strValue).isValid();
case SettingTypeIP:
return StringToIPAddress(sValue.strValue, ipAddress);
case SettingTypeBool:
case SettingTypeInt:
case SettingTypeFloat:
return true;
default:
return false;
}
} else
return false;
}
bool Setting::SetValue(const SettingData & sValue)
{
bool bValid;
in_addr_t ipValue;
if (bValid = IsValid(sValue))
{
switch (m_eType & 0xF)
{
case SettingTypeText:
case SettingTypeFile:
m_sValue.strValue = sValue.strValue;
break;
case SettingTypeColor:
{
QColor clr(sValue.strValue);
m_sValue.strValue = clr.isValid() ? clr.name() : "";
break;
}
case SettingTypeIP:
StringToIPAddress(sValue.strValue, ipValue);
m_sValue.strValue = IPAddressToString(ipValue);
break;
case SettingTypeBool:
m_sValue.bValue = sValue.bValue;
break;
case SettingTypeInt:
m_sValue.iValue = sValue.iValue;
break;
case SettingTypeFloat:
m_sValue.fValue = sValue.fValue;
break;
default:
return false;
}
}
return bValid;
}
int CarModel::Init(const std::map<QString, QString> & mapParams)
{
QString strValue;
MapCarObject * pObject;
Model * pModel;
if (Model::Init(mapParams))
return 1;
strValue = GetParam(mapParams, CARMODEL_PARAM_DELAY, CARMODEL_PARAM_DELAY_DEFAULT);
m_tDelay = MakeTime(ValidateNumber(StringToNumber(strValue), 0., HUGE_VAL));
strValue = GetParam(mapParams, CARMODEL_PARAM_CARIP, CARMODEL_PARAM_CARIP_DEFAULT);
if (!StringToIPAddress(strValue, m_ipCar))
return 2;
strValue = GetParam(mapParams, CARMODEL_PARAM_LOGCAR, CARMODEL_PARAM_LOGCAR_DEFAULT);
m_bLogThisCar = StringToBoolean(strValue);
strValue = GetParam(mapParams, CARMODEL_LINK_PARAM, CARMODEL_LINK_PARAM_DEFAULT);
if (!g_pSimulator->m_ModelMgr.GetModel(strValue, pModel))
return 5;
m_pLinkModel = (CarLinkModel *)pModel;
if (m_pLinkModel != NULL)
m_pLinkModel->SetCar(m_ipCar);
strValue = GetParam(mapParams, CARMODEL_PHYS_PARAM, CARMODEL_PHYS_PARAM_DEFAULT);
if (!g_pSimulator->m_ModelMgr.GetModel(strValue, pModel))
return 6;
m_pPhysModel = (CarPhysModel *)pModel;
if (m_pPhysModel != NULL)
m_pPhysModel->SetCar(m_ipCar);
strValue = GetParam(mapParams, CARMODEL_COMM_PARAM, CARMODEL_COMM_PARAM_DEFAULT);
if (!g_pSimulator->m_ModelMgr.GetModel(strValue, pModel))
return 4;
m_pCommModel = (CarCommModel *)pModel;
if (m_pCommModel != NULL)
m_pCommModel->SetCar(m_ipCar);
strValue = GetParam(mapParams, CARMODEL_TRACKSPEED_PARAM, CARMODEL_TRACKSPEED_PARAM_DEFAULT);
m_bTrackSpeed = StringToBoolean(strValue);
pObject = new MapCarObject(this);
//HACK: set color based on ip group
in_addr_t temp = pObject->m_pCar->GetIPAddress();
temp = temp>>8 & 0xFF;
if(temp == 100) //red ones
{
QColor * redColor = new QColor(0xFF, 0x00, 0x00);
pObject->SetColor(redColor->rgb());
}
else if(temp == 200) //black ones
{
QColor * redColor = new QColor(0x00, 0x00, 0x00);
pObject->SetColor(redColor->rgb());
}
else //the others
{
pObject->SetColor(g_pMapObjects->GetColor());
}
//end HACK
m_iMapObjectID = g_pMapObjects->add(pObject);
if (m_iMapObjectID == -1)
delete pObject;
g_pCarRegistry->addCar(this);
m_iNextSeqNumber = 0;
m_iNextRXSeqNumber = 0;
return 0;
}
int
main(int argc, char *argv[])
{
#if defined HAVE_GETOPT_LONG || defined HAVE_GETOPT_LONG_ORTE
static struct option long_opts[] = {
{ "domain", 1, 0, 'd' },
{ "verbosity", 1, 0, 'v' },
{ "refresh", 1, 0, 'R' },
{ "purge", 1, 0, 'P' },
{ "expiration", 1, 0, 'E' },
{ "metaMulticast", 1, 0, 'I' },
{ "logfile", 1, 0, 'l' },
{ "version", 0, 0, 'V' },
{ "help", 0, 0, 'h' },
{ 0, 0, 0, 0}
};
#endif
ORTEDomainProp dp;
int opt, domain = ORTE_DEFAULT_DOMAIN;
ORTEInit();
ORTEDomainPropDefaultGet(&dp);
NTPTIME_BUILD(deadline, 3);
NTPTIME_BUILD(minimumSeparation, 0);
#if defined HAVE_GETOPT_LONG || defined HAVE_GETOPT_LONG_ORTE
while ((opt = getopt_long(argc, argv, "d:v:R:E:I:P:l:Vh", &long_opts[0], NULL)) != EOF) {
#else
while ((opt = getopt(argc, argv, "d:v:R:E:I:P:l:Vh")) != EOF) {
#endif
switch (opt) {
case 'd':
domain = strtol(optarg, NULL, 0);
break;
case 'v':
ORTEVerbositySetOptions(optarg);
break;
case 'R':
NtpTimeAssembFromMs(dp.baseProp.refreshPeriod, strtol(optarg, NULL, 0), 0);
break;
case 'P':
NtpTimeAssembFromMs(dp.baseProp.purgeTime, strtol(optarg, NULL, 0), 0);
break;
case 'E':
NtpTimeAssembFromMs(dp.baseProp.expirationTime, strtol(optarg, NULL, 0), 0);
break;
case 'I':
dp.multicast.enabled = ORTE_TRUE;
dp.multicast.ipAddress = StringToIPAddress(optarg);
break;
case 'l':
ORTEVerbositySetLogFile(optarg);
case 'V':
printf("Open Real-Time Ethernet (%s).\n", dp.version);
exit(0);
break;
case 'h':
default:
usage();
exit(opt == 'h' ? 0 : 1);
}
}
//Create application
printf("|------------------------------------------------------------------------------|\n");
printf("| %-10s | %-9s | %-9s | %-18s | %-18s |\n",
"status", "type", "topic", "time received", "time sent");
printf("|------------------------------------------------------------------------------|\n");
d = ORTEDomainAppCreate(domain, &dp, NULL, ORTE_TRUE);
ORTEDomainAppSubscriptionPatternAdd(d, "*", "*", subscriptionCallBack, NULL);
ORTEDomainStart(d, ORTE_TRUE, ORTE_FALSE, ORTE_TRUE, ORTE_FALSE, ORTE_TRUE);
while (1)
ORTESleepMs(1000);
exit(0);
}
/****************************************************************************
Function:
void DDNSTask(void)
Summary:
Dynamic DNS client task/state machine.
Description:
This function performs the background tasks of the Dynamic DNS Client.
Once the DDNSPointers structure is configured, this task attempt to
update the Dynamic DNS hostname on a periodic schedule.
The task first accesses the CheckIP server to determine the device's
current external IP address. If the IP address has changed, it
issues an update command to the dynamic DNS service to propagate the
change. This sequence executes whenever dwUpdateAt elapses, which by
default is every 10 minutes, or when an update is forced.
Precondition:
DDNSInit() has been called.
Parameters:
None
Returns:
None
Remarks:
This function acts as a task (similar to one in an RTOS). It
performs its task in a co-operative manner, and the main application
must call this function periodically to ensure that its tasks get
executed in a timely fashion.
***************************************************************************/
void DDNSTask(void)
{
BYTE i;
static TICK Timer;
static TCP_SOCKET MySocket = INVALID_SOCKET;
static char ROM * ROMStrPtr;
static char * RAMStrPtr;
static BYTE vBuffer[16];
WORD wPos;
static IP_ADDR ipParsed;
static enum
{
SM_IDLE = 0u,
SM_BEGIN_CHECKIP, //0x1
SM_CHECKIP_SKT_OBTAINED, //0x2
SM_CHECKIP_FIND_DELIMITER, //0x3
SM_CHECKIP_FIND_ADDRESS, //0x4
SM_CHECKIP_DISCONNECT, //0x5
SM_IP_UPDATE_HOME, //0x6
SM_IP_UPDATE_SKT_OBTAINED, //0x7
/*
HTTP request msg is divided into 6 parts
SM_IP_UPDATE_REQ_A,B,C,D,E,F as the tcp ip tx
buffer is only able to carry 200 bytes at a time.
*/
SM_IP_UPDATE_REQ_A, //0x8
SM_IP_UPDATE_REQ_B, //0x9
SM_IP_UPDATE_REQ_C, //0xa
SM_IP_UPDATE_REQ_D, //0xb
SM_IP_UPDATE_REQ_E, //0xc
SM_IP_UPDATE_REQ_F, //0xd
SM_IPUPDATE_FIND_RESPONSE, //0xe
SM_IPUPDATE_PARSE_RESPONSE, //0xf
SM_IPUDATE_DISCONNECT, //0x10
SM_DONE, // Done, try again in 10 minutes
SM_SOFT_ERROR, // Soft error, try again in 30 seconds
SM_SYSTEM_ERROR // System error, try again in 30 minutes
} smDDNS = SM_IDLE;
switch(smDDNS)
{
case SM_IDLE:
// Wait for timeout to begin IP check
if((LONG)(TickGet() - dwUpdateAt) < 0)
break;
// Otherwise, continue to next state
smDDNS = SM_BEGIN_CHECKIP;
case SM_BEGIN_CHECKIP:
// If a fatal error has occurred, abort to the SM_DONE state and keep
// the error message.
if(lastStatus >= DDNS_STATUS_ABUSE && lastStatus <= DDNS_STATUS_911)
{
smDDNS = SM_DONE;
break;
}
// If DDNSClient is not properly configured, abort
if(
// Verify that each pointer is not null, and is not empty
(DDNSClient.ROMPointers.Host && (!DDNSClient.Host.szROM || *DDNSClient.Host.szROM == '\0') ) ||
(!DDNSClient.ROMPointers.Host && (!DDNSClient.Host.szRAM || *DDNSClient.Host.szRAM == '\0') ) ||
(DDNSClient.ROMPointers.Username && (!DDNSClient.Username.szROM || *DDNSClient.Username.szROM == '\0') ) ||
(!DDNSClient.ROMPointers.Username && (!DDNSClient.Username.szRAM || *DDNSClient.Username.szRAM == '\0') ) ||
(DDNSClient.ROMPointers.Password && (!DDNSClient.Password.szROM || *DDNSClient.Password.szROM == '\0') ) ||
(!DDNSClient.ROMPointers.Password && (!DDNSClient.Password.szRAM || *DDNSClient.Password.szRAM == '\0') ) ||
(DDNSClient.ROMPointers.CheckIPServer && (!DDNSClient.CheckIPServer.szROM || *DDNSClient.CheckIPServer.szROM == '\0') ) ||
(!DDNSClient.ROMPointers.CheckIPServer && (!DDNSClient.CheckIPServer.szRAM || *DDNSClient.CheckIPServer.szRAM == '\0') ) ||
(DDNSClient.ROMPointers.UpdateServer && (!DDNSClient.UpdateServer.szROM || *DDNSClient.UpdateServer.szROM == '\0') ) ||
(!DDNSClient.ROMPointers.UpdateServer && (!DDNSClient.UpdateServer.szRAM || *DDNSClient.UpdateServer.szRAM == '\0') )
)
{
smDDNS = SM_SOFT_ERROR;
lastStatus = DDNS_STATUS_INVALID;
break;
}
// Start with an invalidated IP String
vBuffer[0] = '\0';
// Connect a socket to the remote server
if(DDNSClient.ROMPointers.CheckIPServer)
{
MySocket = TCPOpen((DWORD)(ROM_PTR_BASE)DDNSClient.CheckIPServer.szROM, TCP_OPEN_ROM_HOST,
DDNSClient.CheckIPPort, TCP_PURPOSE_DEFAULT);
}
else
{
MySocket = TCPOpen((DWORD)(PTR_BASE)DDNSClient.CheckIPServer.szRAM, TCP_OPEN_RAM_HOST,
DDNSClient.CheckIPPort, TCP_PURPOSE_DEFAULT);
}
// If no socket available, try again on next loop
if(MySocket == INVALID_SOCKET)
break;
smDDNS++;
Timer = TickGet();
break;
case SM_CHECKIP_SKT_OBTAINED:
// Wait for the remote server to accept our connection request
if(!TCPIsConnected(MySocket))
{
// Time out if too much time is spent in this state
if(TickGet()-Timer > 6*TICK_SECOND)
{
// Close the socket so it can be used by other modules
// We will retry soon
TCPDisconnect(MySocket);
MySocket = INVALID_SOCKET;
lastStatus = DDNS_STATUS_CHECKIP_ERROR;
smDDNS = SM_SOFT_ERROR;
}
break;
}
Timer = TickGet();
// Make certain the socket can be written to
if(TCPIsPutReady(MySocket) < 125)//125 = size of TCP Tx buffer
break;
// Transmit the request to the server
TCPPutROMString(MySocket, (ROM BYTE*)"GET / HTTP/1.0\r\nHost: ");
if(DDNSClient.ROMPointers.CheckIPServer)
{
TCPPutROMString(MySocket, DDNSClient.CheckIPServer.szROM);
}
else
{
TCPPutString(MySocket, DDNSClient.CheckIPServer.szRAM);
}
TCPPutROMString(MySocket, (ROM BYTE*)"\r\nConnection: close\r\n\r\n");
// Send the packet
TCPFlush(MySocket);
smDDNS++;
break;
case SM_CHECKIP_FIND_DELIMITER:
// Check if remote node is still connected. If not, force to the disconnect state,
// but don't break because data may still be waiting.
if(!TCPIsConnected(MySocket) || TickGet() - Timer > 6*TICK_SECOND)
smDDNS = SM_CHECKIP_DISCONNECT;
// Search out the "Address: " delimiter in the response
wPos = TCPFindROMArray(MySocket, (ROM BYTE*)"Address: ", 9, 0, FALSE);
// If not yet found, clear as much as possible and break
if(wPos == 0xffff)
{
wPos = TCPIsGetReady(MySocket);
if(wPos > 9)
TCPGetArray(MySocket, NULL, wPos - 9);
break;
}
// Clear up to and past that string
TCPGetArray(MySocket, NULL, wPos + 9);
// Continue on to read the IP
Timer = TickGet();
smDDNS++;
case SM_CHECKIP_FIND_ADDRESS:
// Check if remote node is still connected. If not, force to the disconnect state,
// but don't break because data may still be waiting.
if(!TCPIsConnected(MySocket) || TickGet() - Timer > 6*TICK_SECOND)
smDDNS = SM_CHECKIP_DISCONNECT;
// Search out the "</body>" delimiter in the response
wPos = TCPFindROMArray(MySocket, (ROM BYTE*)"</body>", 7, 0, FALSE);
// If not yet found, break
if(wPos == 0xffff)
break;
// Read and terminate that string as the IP address (preventing buffer overflows)
if(wPos > 15)
wPos = 15;
TCPGetArray(MySocket, vBuffer, wPos);
vBuffer[wPos] = '\0';
// Parse the IP address that was read, invalidating on failure
if(!StringToIPAddress(vBuffer, &ipParsed))
vBuffer[0] = '\0';
// Continue on to close the socket
case SM_CHECKIP_DISCONNECT:
// Close the socket
TCPDisconnect(MySocket);
MySocket = INVALID_SOCKET;
// Determine if an update is necessary
if(vBuffer[0] == '\0')
{// CheckIP Failed
lastStatus = DDNS_STATUS_CHECKIP_ERROR;
smDDNS = SM_SOFT_ERROR;
break;
}
if( (ipParsed.Val ==lastKnownIP.Val) && (!bForceUpdate))
{
// IP address has not changed and no update is forced
lastStatus = DDNS_STATUS_UNCHANGED;
smDDNS = SM_DONE;
break;
}
// Need to perform an update
lastKnownIP = ipParsed;
bForceUpdate = FALSE;
smDDNS++;
break;
case SM_IP_UPDATE_HOME:
// Connect a socket to the remote server
if(DDNSClient.ROMPointers.UpdateServer)
{
MySocket = TCPOpen((DWORD)(ROM_PTR_BASE)DDNSClient.UpdateServer.szROM, TCP_OPEN_ROM_HOST,
DDNSClient.UpdatePort, TCP_PURPOSE_DEFAULT);
}
else
{
MySocket = TCPOpen((DWORD)(PTR_BASE)DDNSClient.UpdateServer.szRAM, TCP_OPEN_RAM_HOST,
DDNSClient.UpdatePort, TCP_PURPOSE_DEFAULT);
}
// If no socket is available, try again on the next loop
if(MySocket == INVALID_SOCKET)
break;
// Move on to the next state
smDDNS++;
Timer = TickGet();
break;
case SM_IP_UPDATE_SKT_OBTAINED:
// Wait for the remote server to accept our connection request
if(!TCPIsConnected(MySocket))
{
// Time out if too much time is spent in this state
if(TickGet() - Timer > 6*TICK_SECOND)
{
// Close the socket so it can be used by other modules
// We will try again immediately
TCPDisconnect(MySocket);
MySocket = INVALID_SOCKET;
lastStatus = DDNS_STATUS_UPDATE_ERROR;
smDDNS--;
}
break;
}
// Reset timer and begin sending the request
Timer = TickGet();
smDDNS++;
// No break needed...try to send first bit immediately.
case SM_IP_UPDATE_REQ_A:
// Check for lost connections or timeouts
if(!TCPIsConnected(MySocket) || (TickGet() - Timer > 10*TICK_SECOND))
{
lastStatus = DDNS_STATUS_UPDATE_ERROR;
smDDNS = SM_IPUDATE_DISCONNECT;
break;
}
if(TCPIsPutReady(MySocket) < 25u) // 25 =~ 16+9
break;
TCPPutROMString(MySocket, (ROM BYTE*)"GET /nic/update?hostname=");
smDDNS++;
// No break needed...try to send next bit immediately.
case SM_IP_UPDATE_REQ_B:
// Check for lost connections or timeouts
if(!TCPIsConnected(MySocket) || (TickGet() - Timer > 10*TICK_SECOND))
{
lastStatus = DDNS_STATUS_UPDATE_ERROR;
smDDNS = SM_IPUDATE_DISCONNECT;
break;
}
// Try to write, verifying that space is available first
if(DDNSClient.ROMPointers.Host)
{
if(TCPIsPutReady(MySocket) < strlenpgm((ROM char*)DDNSClient.Host.szROM))
break;
TCPPutROMString(MySocket,DDNSClient.Host.szROM);
}
else
{
if(TCPIsPutReady(MySocket) < strlen((char*)DDNSClient.Host.szRAM))
break;
TCPPutString(MySocket,DDNSClient.Host.szRAM);
}
smDDNS++;
// No break needed...try to send next bit immediately.
case SM_IP_UPDATE_REQ_C:
// Check for lost connections or timeouts
if(!TCPIsConnected(MySocket) || TickGet() - Timer > 10*TICK_SECOND)
{
lastStatus = DDNS_STATUS_UPDATE_ERROR;
smDDNS = SM_IPUDATE_DISCONNECT;
break;
}
if(TCPIsPutReady(MySocket) < 70u)
break;
TCPPutROMString(MySocket, (ROM BYTE*)"&myip=");
TCPPutString(MySocket, vBuffer);
TCPPutROMString(MySocket, (ROM BYTE*)"&wildcard=NOCHG&mx=NOCHG&backmx=NOCHG HTTP/1.0");
TCPFlush(MySocket);
smDDNS++;
// No break needed...try to send next bit immediately.
case SM_IP_UPDATE_REQ_D:
// Check for lost connections or timeouts
if(!TCPIsConnected(MySocket) || TickGet() - Timer > 10*TICK_SECOND)
{
lastStatus = DDNS_STATUS_UPDATE_ERROR;
smDDNS = SM_IPUDATE_DISCONNECT;
break;
}
if(TCPIsPutReady(MySocket) < 131u) // 131 =~ 8+23 + dynamic dns server hostname
break;
TCPPutROMString(MySocket, (ROM BYTE*)"\r\nHost: ");//8
if(DDNSClient.ROMPointers.UpdateServer)
TCPPutROMString(MySocket,DDNSClient.UpdateServer.szROM);
else
TCPPutString(MySocket,DDNSClient.UpdateServer.szRAM);
TCPPutROMString(MySocket, (ROM BYTE*)"\r\nAuthorization: Basic ");//23
TCPFlush(MySocket);
smDDNS++;
// No break needed...try to send the next bit immediately.
case SM_IP_UPDATE_REQ_E:
// Check for lost connections or timeouts
if(!TCPIsConnected(MySocket) || TickGet() - Timer > 6*TICK_SECOND)
{
lastStatus = DDNS_STATUS_UPDATE_ERROR;
smDDNS = SM_IPUDATE_DISCONNECT;
break;
}
// User name and passwords for DynDNS.org can each be up to 24 characters
// Base64 encoded data is always at least 25% bigger than the original
if(TCPIsPutReady(MySocket) < 100u)
break;
if(DDNSClient.ROMPointers.Username)
{
ROMStrPtr = (ROM char*)DDNSClient.Username.szROM;
wPos = strlenpgm(ROMStrPtr);
}
else
{
RAMStrPtr = (char*)DDNSClient.Username.szRAM;
wPos = strlen((char*)RAMStrPtr);
}
i = 0;
while(wPos)
{
while(i < wPos && i < 3u)
{
if(DDNSClient.ROMPointers.Username)
vBuffer[i] = *ROMStrPtr++;
else
vBuffer[i] = *RAMStrPtr++;
i++;
}
wPos -= i;
if(i == 3u)
{
Base64Encode(vBuffer, i, vBuffer, 4);
TCPPutArray(MySocket, vBuffer, 4);
i = 0;
}
}
if(DDNSClient.ROMPointers.Password)
{
ROMStrPtr = (ROM char*)DDNSClient.Password.szROM;
wPos = strlenpgm(ROMStrPtr);
}
else
{
RAMStrPtr = (char*)DDNSClient.Password.szRAM;
wPos = strlen((char*)RAMStrPtr);
}
// Increment for the ':' separator and i for bytes left in username
wPos += i + 1;
vBuffer[i++] = ':';
while(wPos)
{
while(i < wPos && i < 3u)
{
if(DDNSClient.ROMPointers.Password)
vBuffer[i] = *ROMStrPtr++;
else
vBuffer[i] = *RAMStrPtr++;
i++;
}
wPos -= i;
Base64Encode(vBuffer, i, vBuffer, 4);
TCPPutArray(MySocket, vBuffer, 4);
i = 0;
}
TCPFlush(MySocket);
smDDNS++;
break;
case SM_IP_UPDATE_REQ_F:
// Check for lost connections or timeouts
if(!TCPIsConnected(MySocket) || TickGet() - Timer > 10*TICK_SECOND)
{
lastStatus = DDNS_STATUS_UPDATE_ERROR;
smDDNS = SM_IPUDATE_DISCONNECT;
break;
}
if(TCPIsPutReady(MySocket) < 50)
break;
TCPPutROMString(MySocket, (ROM BYTE*)"\r\nUser-Agent: Microchip - TCPIPSTACK - "VERSION"\r\n\r\n");
TCPFlush(MySocket);
smDDNS++;
// Reset the timer to wait for a response
Timer = TickGet();
break;
case SM_IPUPDATE_FIND_RESPONSE:
// Locate the response string
// Wait up to 10 seconds for a response
if(TickGet() - Timer > 10*TICK_SECOND)
{
lastStatus = DDNS_STATUS_UPDATE_ERROR;
smDDNS = SM_IPUDATE_DISCONNECT;
break;
}
// According to HTTP, the response will start after the two CRLFs
wPos = TCPFindROMArray(MySocket, (ROM BYTE*)"\r\n\r\n", 4, 0, FALSE);
// If not yet found, eliminate everything up to
if(wPos == 0xffff)
{
wPos = TCPIsGetReady(MySocket);
if(wPos > 4)
TCPGetArray(MySocket, NULL, wPos - 4);
break;
}
TCPGetArray(MySocket, NULL, wPos+4);
smDDNS++;
// No break...continue to next state immediately
case SM_IPUPDATE_PARSE_RESPONSE:
// Try to parse the response text
// Wait up to 10 seconds for the remote server to disconnect
// so we know all data has been received
if(TCPIsConnected(MySocket) && TickGet() - Timer < 10*TICK_SECOND)
break;
// Read the response code
wPos = TCPIsGetReady(MySocket);
if(wPos > sizeof(vBuffer) - 1)
wPos = sizeof(vBuffer) - 1;
wPos = TCPGetArray(MySocket, vBuffer, wPos);
vBuffer[wPos] = '\0';
for(i = 0; i < sizeof(vBuffer); i++)
if(vBuffer[i] == ' ')
vBuffer[i] = '\0';
for(lastStatus = 0; lastStatus <= DDNS_STATUS_UPDATE_ERROR; lastStatus++)
if(!strcmppgm2ram((char*)vBuffer, (ROM char*)_updateIpSrvrResponse[lastStatus]))
break;
smDDNS++;
// No break...continue to finalization
case SM_IPUDATE_DISCONNECT:
// Close the socket so it can be used by other modules.
if(MySocket != INVALID_SOCKET)
{
TCPDisconnect(MySocket);
MySocket = INVALID_SOCKET;
}
// Determine what to do based on status
if(lastStatus <= DDNS_STATUS_NUMHOST || lastStatus == DDNS_STATUS_UNCHANGED)
smDDNS = SM_DONE;
else if(lastStatus == DDNS_STATUS_911 || lastStatus == DDNS_STATUS_DNSERR)
smDDNS = SM_SYSTEM_ERROR;
else
smDDNS = SM_SOFT_ERROR;
smDDNS++;
break;
case SM_DONE:
dwUpdateAt = TickGet() + 10*60*TICK_SECOND; // 10 minutes
smDDNS = SM_IDLE;
break;
case SM_SOFT_ERROR:
dwUpdateAt = TickGet() + 30*TICK_SECOND; // 30 seconds
smDDNS = SM_IDLE;
break;
case SM_SYSTEM_ERROR:
dwUpdateAt = TickGet() + 30*60*TICK_SECOND; // 30 minutes
smDDNS = SM_IDLE;
break;
}
}
void DoUARTConfig(void)
{
BYTE response[MAX_USER_RESPONSE_LEN];
IP_ADDR tempIPValue;
IP_ADDR *destIPValue;
WORD_VAL wvTemp;
BOOL bQuit = FALSE;
while(!bQuit)
{
// Display the menu
putrsUART("\r\n\r\n\rMicrochip TCP/IP Config Application ("TCPIP_STACK_VERSION", " __DATE__ ")\r\n\r\n");
putrsUART("\t1: Change serial number:\t\t");
wvTemp.v[1] = AppConfig.MyMACAddr.v[4];
wvTemp.v[0] = AppConfig.MyMACAddr.v[5];
uitoa(wvTemp.Val, response);
putsUART((char *)response);
putrsUART("\r\n\t2: Change host name:\t\t\t");
putsUART((char *)AppConfig.NetBIOSName);
putrsUART("\r\n\t3: Change static IP address:\t\t");
DisplayIPValue(AppConfig.MyIPAddr);
putrsUART("\r\n\t4: Change static gateway address:\t");
DisplayIPValue(AppConfig.MyGateway);
putrsUART("\r\n\t5: Change static subnet mask:\t\t");
DisplayIPValue(AppConfig.MyMask);
putrsUART("\r\n\t6: Change static primary DNS server:\t");
DisplayIPValue(AppConfig.PrimaryDNSServer);
putrsUART("\r\n\t7: Change static secondary DNS server:\t");
DisplayIPValue(AppConfig.SecondaryDNSServer);
putrsUART("\r\n\t8: ");
putrsUART((ROM char*)(AppConfig.Flags.bIsDHCPEnabled ? "Dis" : "En"));
putrsUART("able DHCP & IP Gleaning:\t\tDHCP is currently ");
putrsUART((ROM char*)(AppConfig.Flags.bIsDHCPEnabled ? "enabled" : "disabled"));
putrsUART("\r\n\t9: Download MPFS image.");
putrsUART("\r\n\t0: Save & Quit.");
putrsUART("\r\nEnter a menu choice: ");
// Wait for the user to press a key
while(!DataRdyUART());
putrsUART((ROM char*)"\r\n");
// Execute the user selection
switch(ReadUART())
{
case '1':
putrsUART("New setting: ");
if(ReadStringUART(response, sizeof(response)))
{
wvTemp.Val = atoi((char*)response);
AppConfig.MyMACAddr.v[4] = wvTemp.v[1];
AppConfig.MyMACAddr.v[5] = wvTemp.v[0];
}
break;
case '2':
putrsUART("New setting: ");
ReadStringUART(response, sizeof(response) > sizeof(AppConfig.NetBIOSName) ? sizeof(AppConfig.NetBIOSName) : sizeof(response));
if(response[0] != '\0')
{
memcpy(AppConfig.NetBIOSName, (void*)response, sizeof(AppConfig.NetBIOSName));
FormatNetBIOSName(AppConfig.NetBIOSName);
}
break;
case '3':
destIPValue = &AppConfig.MyIPAddr;
goto ReadIPConfig;
case '4':
destIPValue = &AppConfig.MyGateway;
goto ReadIPConfig;
case '5':
destIPValue = &AppConfig.MyMask;
goto ReadIPConfig;
case '6':
destIPValue = &AppConfig.PrimaryDNSServer;
goto ReadIPConfig;
case '7':
destIPValue = &AppConfig.SecondaryDNSServer;
goto ReadIPConfig;
ReadIPConfig:
putrsUART("New setting: ");
ReadStringUART(response, sizeof(response));
if(StringToIPAddress(response, &tempIPValue))
destIPValue->Val = tempIPValue.Val;
else
putrsUART("Invalid input.\r\n");
break;
case '8':
AppConfig.Flags.bIsDHCPEnabled = !AppConfig.Flags.bIsDHCPEnabled;
break;
case '9':
#if (defined(MPFS_USE_EEPROM)|| defined(MPFS_USE_SPI_FLASH)) && defined(STACK_USE_MPFS2)
DownloadMPFS();
#endif
break;
case '0':
bQuit = TRUE;
#if defined(EEPROM_CS_TRIS) || defined(SPIFLASH_CS_TRIS)
SaveAppConfig(&AppConfig);
putrsUART("Settings saved.\r\n");
#else
putrsUART("External EEPROM/Flash not present -- settings will be lost at reset.\r\n");
#endif
break;
}
}
}
void QAutoGenDialog::accept()
{
unsigned int i, iVehicles = m_txtVehicles->value(), iCar;
QString strParam, strValue, strName, strType = m_comboVehicleType->currentText();
std::map<QString, QString> mapParams;
std::map<QString, std::map<QString, AutoGenParameter> >::iterator iterParams = m_mapModels.find(strType), iterAssocParams;
std::map<QString, AutoGenParameter>::iterator iterParam;
QStringList listDepends;
QStringList::iterator iterDepend;
in_addr_t ipAddress, ipTemp;
std::map<QString, QString> mapAssocModels;
std::map<QString, QString>::iterator iterAssocModel;
std::map<QString, QString> mapAssocModelTypes;
std::map<QString, QString>::iterator iterAssocModelType;
std::vector<std::pair<QString, QString> > vecAssocModelTypes;
std::map<QString, std::map<QString, AutoGenParameter> > mapAssocModelParams;
std::map<QString, std::map<QString, ModelParameter> >::iterator iterModelType = m_pMapParams->find(strType), iterModelParams;
std::map<QString, ModelParameter>::iterator iterModelParam;
std::set<QString> setDepends;
std::set<QString>::iterator iterSetDepend;
QAutoGenModelDialog * pDialog;
int nResult;
bool bAddressSet = false;
std::map<QString, Rect>::iterator iterAddressParams;
// get record list for different parameters
for (iterAddressParams = m_mapMapSelections.begin(); iterAddressParams != m_mapMapSelections.end(); ++iterAddressParams)
{
switch (m_comboRegionType->currentItem())
{
case 0:
g_pMapDB->GetRecordsInRegion(m_mapRandomRecords[iterAddressParams->first], iterAddressParams->second);
break;
default:
break;
}
}
// make list of associated models
for (iterParam = iterParams->second.begin(); iterParam != iterParams->second.end(); ++iterParam)
{
strParam = iterParam->first, strValue = iterParam->second.strValue;
iterModelParam = iterModelType->second.find(strParam);
if (iterParam->second.eType == AutoGenParamTypeNewModel)
{
vecAssocModelTypes.push_back(std::pair<QString, QString>(strParam, strValue));
mapAssocModelTypes.insert(vecAssocModelTypes.back());
}
}
for (i = 0; i < vecAssocModelTypes.size(); i++)
{
if (vecAssocModelTypes[i].second.compare(NULLMODEL_NAME) != 0)
{
pDialog = new QAutoGenModelDialog(vecAssocModelTypes[i].first, vecAssocModelTypes[i].second, this);
m_mapModelIndexes[vecAssocModelTypes[i].second] = 0;
iterModelParams = m_pMapParams->find(vecAssocModelTypes[i].second);
iterAssocParams = m_mapModels.find(vecAssocModelTypes[i].second);
iterAssocParams = mapAssocModelParams.insert(std::pair<QString, std::map<QString, AutoGenParameter> >(vecAssocModelTypes[i].first, iterAssocParams->second)).first;
pDialog->m_pVecModelTypes = m_pVecModelTypes;
pDialog->m_pAssocModelTypeMap = &mapAssocModelTypes;
pDialog->m_pAssocModelTypes = &vecAssocModelTypes;
pDialog->m_pModelParams = &iterModelParams->second;
// generate auto-generator parameters
pDialog->m_pParams = &iterAssocParams->second;
pDialog->InitializeModelParams();
nResult = pDialog->exec();
delete pDialog;
if (nResult == QDialog::Rejected)
return;
}
}
iCar = 0;
qApp->setOverrideCursor(QCursor(Qt::WaitCursor));
ipAddress = GetIPAddress();
for (i = 0; i < iVehicles; i++)
{
// create this vehicle
while (m_pModelNames->find(strName = QString("%1%2").arg(strType).arg(iCar)) != m_pModelNames->end())
iCar++;
for (iterParam = iterParams->second.begin(); iterParam != iterParams->second.end(); ++iterParam)
{
strParam = iterParam->first, strValue = iterParam->second.strValue;
iterModelParam = iterModelType->second.find(strParam);
switch (iterParam->second.eType & (~AutoGenParamTypeNoRandom))
{
case AutoGenParamTypeNewModel:
iterAssocModelType = mapAssocModelTypes.find(strParam);
setDepends.insert(mapParams[iterAssocModelType->first] = GetAssocModel(iterAssocModelType->first, iterAssocModelType->second, mapAssocModels, mapAssocModelTypes, mapAssocModelParams, i));
break;
case AutoGenParamTypeDepends:
listDepends = QStringList::split(';', strValue);
for (iterDepend = listDepends.begin(); iterDepend != listDepends.end(); ++iterDepend)
setDepends.insert(*iterDepend);
break;
case AutoGenParamTypeIP:
if (!bAddressSet && StringToIPAddress(strValue, ipTemp))
ipAddress = ipTemp;
break;
case AutoGenParamTypeRandom:
mapParams[strParam] = GetRandomParameter(strParam, strValue, iterModelParam->second);
break;
case AutoGenParamTypeFile:
mapParams[strParam] = GetFileParameter(strParam, strValue, i);
break;
default:
mapParams[strParam] = strValue;
break;
}
}
while (m_pVehicleIPs->find(ipAddress) != m_pVehicleIPs->end())
ipAddress++;
bAddressSet = true;
mapParams[m_strIPAddressParam] = IPAddressToString(ipAddress);
setDepends.erase("NULL");
mapParams[PARAM_DEPENDS] = QString::null;
for (iterSetDepend = setDepends.begin(); iterSetDepend != setDepends.end(); ++iterSetDepend)
{
if (mapParams[PARAM_DEPENDS].isEmpty())
mapParams[PARAM_DEPENDS] = *iterSetDepend;
else
mapParams[PARAM_DEPENDS] += (';' + *iterSetDepend);
}
setDepends.clear();
m_pVehicleIPs->insert(ipAddress);
m_pModels->insert(std::pair<QString, std::map<QString, QString> >(strName, mapParams));
m_pVehicleList->push_back(std::pair<QString, QString>(strName, strType));
m_pModelNames->insert(strName);
mapAssocModels.clear();
iCar++;
ipAddress++;
}
m_mapFileData.clear();
qApp->restoreOverrideCursor();
QDialog::accept();
}
bool InitNetwork()
{
QString strNetInitFile, strNetInitArgs, strValue;
bool bContinue = true;
int iErrorCode;
// make sure network isn't running
CloseNetwork();
if (g_bNetworkEnabled)
return false;
g_pLogger->LogInfo("Opening Network Interface...");
g_strDeviceName = g_pSettings->GetParam(PARAMKEY_NETWORK_DEVNAME, g_pSettings->m_sSettings[SETTINGS_NETWORK_DEVICENAME_NUM].GetValue().strValue, true);
g_strDeviceType = g_pSettings->m_sSettings[SETTINGS_NETWORK_DEVICETYPE_NUM].GetValue().strValue;
if (g_pSettings->GetParam(PARAMKEY_NETWORK_IP, "", false).isEmpty() || !StringToIPAddress(g_pSettings->GetParam(PARAMKEY_NETWORK_IP, "", false), g_ipAddress))
{
if (!StringToIPAddress(g_pSettings->m_sSettings[SETTINGS_NETWORK_IPADDRESS_NUM].GetValue().strValue, g_ipAddress))
g_ipAddress = 0;
}
if (g_pSettings->GetParam(PARAMKEY_NETWORK_SUBNET, "", false).isEmpty() || !StringToIPAddress(g_pSettings->GetParam(PARAMKEY_NETWORK_SUBNET, "", false), g_ipSubnet))
StringToIPAddress(g_pSettings->m_sSettings[SETTINGS_NETWORK_IPSUBNET_NUM].GetValue().strValue, g_ipSubnet);
g_iTXPower = g_pSettings->m_sSettings[SETTINGS_NETWORK_TXPOWER_NUM].GetValue().iValue;
g_iTXRate = g_pSettings->m_sSettings[SETTINGS_NETWORK_TXRATE_NUM].GetValue().iValue;
strNetInitFile = g_pSettings->m_sSettings[SETTINGS_NETWORK_INITFILE_NUM].GetValue().strValue;
if (!strNetInitFile.isEmpty())
{
strNetInitArgs = g_pSettings->m_sSettings[SETTINGS_NETWORK_INITARGS_NUM].GetValue().strValue;
strNetInitArgs.replace("%dn", g_strDeviceName);
strNetInitArgs.replace("%dt", g_strDeviceType);
strNetInitArgs.replace("%ip", IPAddressToString(g_ipAddress));
strNetInitArgs.replace("%sub", IPAddressToString(g_ipSubnet));
strNetInitArgs.replace("%txp", QString::number(g_iTXPower));
strNetInitArgs.replace("%txr", QString::number(g_iTXRate));
if (!strNetInitArgs.isEmpty())
strNetInitFile += " " + strNetInitArgs;
while (bContinue)
{
iErrorCode = system(strNetInitFile);
if (iErrorCode == 0) {
g_bNetworkEnabled = true;
bContinue = false;
} else
bContinue = g_pLogger->PromptLogError(PACKAGE_TITLE, QString("Could not open network interface (code %1)").arg(iErrorCode), false);
}
}
else
g_bNetworkEnabled = true;
if (g_bNetworkEnabled)
{
/*if (g_strDeviceType.compare("denso") == 0)
g_bNetworkEnabled = InitializeDensoUnit(g_ipAddress, g_ipSubnet, g_strDeviceName, g_iTXPower, g_iTXRate);
*/
}
if (g_bNetworkEnabled)
g_pLogger->LogInfo("Successful\n");
else {
g_pLogger->LogInfo("Failed\n");
return false;
}
if (g_pMainWindow != NULL)
{
g_pMainWindow->m_pNetInit->setMenuText("Re&initialize");
g_pMainWindow->m_pNetInit->setToolTip("Reinitialize network devices and connections");
g_pMainWindow->m_pNetClose->setEnabled(true);
g_pMainWindow->m_pNetMenu->setItemEnabled(g_pMainWindow->m_iNetServerMenuID, true);
g_pMainWindow->m_pNetworkManager->SetNetworkInitialized(true);
}
g_pOldSigPipeHandler = signal(SIGPIPE, SIG_IGN);
// start server
if (g_pSettings->m_sSettings[SETTINGS_NETWORK_AUTOSERVER_NUM].GetValue().bValue)
{
if (g_strDeviceType.compare("denso") == 0)
return StartServer(UDPSERVER_NAME);
else
return StartServer(UDPSERVER_NAME);
}
else
return true;
}
/*==== 2012-04-30 Liz: Control 3 Buttons: UP, DOWN, ENTER to let user key in password/CT_rating =====*/
BYTE user_input_control(BYTE number_of_digits)
{
BYTE i = 0;
// Display cursor to let user know to start key in value
//if(current_pw_digit == 0 && is_cursor_on==0)
if(is_cursor_on==0)
{
if(getMenuCurrentState() == MENU_PASSWORD_STATE) LCD_PrintStringPGM("PASSWORD? 1/1", LCD_ROW0);
UserInput();
is_cursor_on = 1;
}
// If BUTTON_DOWN is pressed, decrease digit value (from 0-9)
if (digit > 48)
{
if (BUTTON_DOWN == 0) button_down_old_state = 1;
if ((BUTTON_DOWN == 1) && (button_down_old_state == 1))
{
digit--;
UserInput();
button_down_old_state = 0;
#ifdef APP_USE_BUZZER
sound();
#endif
return 1;
}
}
// If BUTTON_UP is pressed, increase digit value (from 0-9)
if (digit < 57)
{
if (BUTTON_UP == 0) button_up_old_state = 1;
if ((BUTTON_UP == 1) && (button_up_old_state == 1))
{
digit++;
UserInput();
button_up_old_state = 0;
#ifdef APP_USE_BUZZER
sound();
#endif
return 2;
}
}
// If BUTTON_ENTER is pressed, move to next digit or submit user input
if (BUTTON_ENTER == 0) button_enter_old_state = 1;
if ((BUTTON_ENTER == 1) && (button_enter_old_state == 1))
{
button_enter_old_state = 0;
if(current_pw_digit < number_of_digits - 1)
{
UserInput();
current_pw_digit++;
digit = 48;
is_cursor_on = 0;
}
else
{
// User already key in 4-digit pw, checking if pw is correct
if(getMenuCurrentState() == MENU_PASSWORD_STATE)
{
if(char_menu_pw[0]==AppConfig.Password[0] && char_menu_pw[1]==AppConfig.Password[1]
&& char_menu_pw[2]==AppConfig.Password[2] && char_menu_pw[3]==AppConfig.Password[3])
{
LCD_ClearScreen();
setMenuCurrentState(MENU_SETTINGS_STATE);
set_current_menu(0);
gotoMenuSettingState();
}
else
{
LCD_PrintStringPGM("Wrong Password", LCD_ROW1);
Delay10KTCYx(0);
Delay10KTCYx(0);
LCD_ClearScreen();
is_cursor_on = 0;
//LCD_PrintStringPGM("Settings 2/3", LCD_ROW0);
}
}
else if(getMenuCurrentState() == SUBMENU_SETTINGS_STATE && get_current_menu() == 0) // Get CT_Rating input
{
CALIBRATION_VALUES stCalib;
// Get Calib value first
if( !MCURequestToBOTTOMBoard(MMT_GET_CALIBRATION_DATA, &stCalib, sizeof(CALIBRATION_VALUES), TRUE, TRUE) )
{
LCD_PrintStringPGM("Try Again...", LCD_ROW1);
}
else
{
// Update CT value
stCalib.CT_RANGE = atoi(char_menu_pw);
// There are changes... save it!
MCURequestToBOTTOMBoard(MMT_SET_CALIBRATION_DATA_NEW, &stCalib, sizeof(CALIBRATION_VALUES), TRUE, TRUE);
if( ((BYTE*)&stCalib)[0] != 'O' && ((BYTE*)&stCalib)[1] != 'K' )
LCD_PrintStringPGM("Try Again...", LCD_ROW1);
else
{
LCD_PrintStringPGM("OK-PLS RESET ENR", LCD_ROW1);
setMenuCurrentState(MENU_SETTINGS_STATE);
resetUserInput();
}
}
Delay10KTCYx(0);
Delay10KTCYx(0);
LCD_ClearScreen();
LCD_PrintStringPGM("Set CT_Range 1/3", LCD_ROW0);
}
else if(getMenuCurrentState() == SUBMENU_SETTINGS_STATE && get_current_menu() == 2) // Get IPAddr input
{
char s[16] = "192.168.1.";
s[10] = 0;
strcat(s, char_menu_pw);
if(!StringToIPAddress((BYTE*)s, &AppConfig.MyIPAddr))
LCD_PrintStringPGM("Try Again...", LCD_ROW1);
else
{
LCD_PrintString(s, LCD_ROW1, 0);
setMenuCurrentState(MENU_SETTINGS_STATE);
resetUserInput();
SaveAppConfig();
Reset();
}
Delay10KTCYx(0);
Delay10KTCYx(0);
LCD_ClearScreen();
LCD_PrintStringPGM("Set IP addr 3/3", LCD_ROW0);
}
resetUserInput();
}
#ifdef APP_USE_BUZZER
sound();
#endif
return 3;
}
}
int
main(int argc, char *argv[])
{
#if defined HAVE_GETOPT_LONG || defined HAVE_GETOPT_LONG_ORTE
static struct option long_opts[] = {
{ "domain", 1, 0, 'd' },
{ "publisher", 0, 0, 'p' },
{ "strength", 1, 0, 'S' },
{ "subscriber", 0, 0, 's' },
{ "refresh", 1, 0, 'R' },
{ "purge", 1, 0, 'P' },
{ "expiration", 1, 0, 'E' },
{ "minimumSeparation", 1, 0, 'm' },
{ "metaMulticast", 1, 0, 'I' },
{ "dataMulticast", 1, 0, 'i' },
{ "timetolive", 1, 0, 't' },
{ "delay", 1, 0, 'D' },
{ "verbosity", 1, 0, 'v' },
{ "quiet", 0, 0, 'q' },
{ "logfile", 1, 0, 'l' },
{ "version", 0, 0, 'V' },
{ "help", 0, 0, 'h' },
{ 0, 0, 0, 0}
};
#endif
ORTEDomain *d;
ORTEDomainProp dp;
ORTEPublication *p = NULL;
ORTESubscription *s = NULL;
int opt, domain = ORTE_DEFAULT_DOMAIN;
int32_t strength = 1;
int32_t instanceSend = 0, instanceRecv = 0;
NtpTime persistence, deadline, minimumSeparation, delay;
Boolean havePublisher = ORTE_FALSE;
Boolean haveSubscriber = ORTE_FALSE;
IPAddress smIPAddress = IPADDRESS_INVALID;
ORTEDomainAppEvents events;
ORTEInit();
ORTEDomainPropDefaultGet(&dp);
NTPTIME_BUILD(minimumSeparation, 0);
NTPTIME_BUILD(delay, 1); //1s
#if defined HAVE_GETOPT_LONG || defined HAVE_GETOPT_LONG_ORTE
while ((opt = getopt_long(argc, argv, "m:S:d:v:R:E:P:l:I:i:t:D:Vhpsq", &long_opts[0], NULL)) != EOF) {
#else
while ((opt = getopt(argc, argv, "m:S:d:v:R:E:P:l:I:i:t:D:Vhpsq")) != EOF) {
#endif
switch (opt) {
case 'S':
strength = strtol(optarg, NULL, 0);
break;
case 'd':
domain = strtol(optarg, NULL, 0);
break;
case 'p':
havePublisher = ORTE_TRUE;
break;
case 's':
haveSubscriber = ORTE_TRUE;
break;
case 'v':
ORTEVerbositySetOptions(optarg);
break;
case 'R':
NtpTimeAssembFromMs(dp.baseProp.refreshPeriod, strtol(optarg, NULL, 0), 0);
break;
case 'P':
NtpTimeAssembFromMs(dp.baseProp.purgeTime, strtol(optarg, NULL, 0), 0);
break;
case 'E':
NtpTimeAssembFromMs(dp.baseProp.expirationTime, strtol(optarg, NULL, 0), 0);
break;
case 'm':
NtpTimeAssembFromMs(minimumSeparation, strtol(optarg, NULL, 0), 0);
break;
case 'D':
NtpTimeAssembFromMs(delay, strtol(optarg, NULL, 0)/1000, strtol(optarg, NULL, 0)%1000);
break;
case 'I':
dp.multicast.enabled = ORTE_TRUE;
dp.multicast.ipAddress = StringToIPAddress(optarg);
break;
case 'i':
dp.multicast.enabled = ORTE_TRUE;
smIPAddress = StringToIPAddress(optarg);
break;
case 't':
dp.multicast.ttl = strtol(optarg, NULL, 0);
break;
case 'l':
ORTEVerbositySetLogFile(optarg);
case 'q':
quite = ORTE_TRUE;
break;
case 'V':
printf("Ocera Real-Time Ethernet (%s).\n", dp.version);
exit(0);
break;
case 'h':
default:
usage();
exit(opt == 'h' ? 0 : 1);
}
}
//initiate event system
ORTEDomainInitEvents(&events);
events.onRegFail = onRegFail;
//Create application
d = ORTEDomainAppCreate(domain, &dp, &events, ORTE_FALSE);
//Register ser./deser. rutines with maximal size 4 Bytes
ORTETypeRegisterAdd(d, "PingData", NULL, NULL, NULL, 4);
//Create publisher
if (havePublisher) {
NTPTIME_BUILD(persistence, 5);
p = ORTEPublicationCreate(
d,
"Ping",
"PingData",
&instanceSend,
&persistence,
strength,
sendCallBack,
NULL,
&delay);
if (p == NULL) {
printf("ORTEPublicationCreate failed\n");
exit(1);
}
}
if (haveSubscriber) {
NTPTIME_BUILD(deadline, 3);
s = ORTESubscriptionCreate(
d,
IMMEDIATE,
BEST_EFFORTS,
"Ping",
"PingData",
&instanceRecv,
&deadline,
&minimumSeparation,
recvCallBack,
NULL,
smIPAddress);
if (s == NULL) {
printf("ORTESubscriptionCreate failed\n");
exit(1);
}
}
//never ending loop
while (!regfail)
ORTESleepMs(1000);
exit(0);
}
void HTTPExecCmd(BYTE** argv, BYTE argc)
{
BYTE command;
BYTE var;
#if defined(ENABLE_REMOTE_CONFIG)
DWORD_VAL dwVal;
BYTE CurrentArg;
WORD_VAL TmpWord;
#endif
/*
* Design your pages such that they contain command code
* as a one character numerical value.
* Being a one character numerical value greatly simplifies
* the job.
*/
command = argv[0][0] - '0';
/*
* Find out the cgi file name and interpret parameters
* accordingly
*/
switch(command)
{
case CGI_CMD_DIGOUT: // ACTION=0
/*
* Identify the parameters.
* Compare it in upper case format.
*/
var = argv[1][0] - '0';
switch(var)
{
case CMD_LED1: // NAME=0
// Toggle LED.
LED1_IO ^= 1;
break;
case CMD_LED2: // NAME=1
// Toggle LED.
LED2_IO ^= 1;
break;
}
memcpypgm2ram((void*)argv[0], (ROM void*)COMMANDS_OK_PAGE, COMMANDS_OK_PAGE_LEN);
break;
#if defined(USE_LCD)
case CGI_CMD_LCDOUT: // ACTION=1
if(argc > 2u) // Text provided in argv[2]
{
// Convert %20 to spaces, and other URL transformations
UnencodeURL(argv[2]);
// Write 32 received characters or less to LCDText
if(strlen((char*)argv[2]) < 32u)
{
memset(LCDText, ' ', 32);
strcpy((char*)LCDText, (char*)argv[2]);
}
else
{
memcpy(LCDText, (void*)argv[2], 32);
}
// Write LCDText to the LCD
LCDUpdate();
}
else // No text provided
{
LCDErase();
}
memcpypgm2ram((void*)argv[0], (ROM void*)COMMANDS_OK_PAGE, COMMANDS_OK_PAGE_LEN);
break;
#endif
#if defined(ENABLE_REMOTE_CONFIG)
// Possibly useful code for remotely reconfiguring the board through
// HTTP
case CGI_CMD_RECONFIG: // ACTION=2
// Loop through all variables that we've been given
CurrentArg = 1;
while(argc > CurrentArg)
{
// Get the variable identifier (HTML "name"), and
// increment to the variable's value
TmpWord.v[1] = argv[CurrentArg][0];
TmpWord.v[0] = argv[CurrentArg++][1];
var = hexatob(TmpWord);
// Make sure the variable's value exists
if(CurrentArg >= argc)
break;
// Take action with this variable/value
switch(var)
{
case VAR_IP_ADDRESS:
case VAR_SUBNET_MASK:
case VAR_GATEWAY_ADDRESS:
{
// Convert the returned value to the 4 octect
// binary representation
if(!StringToIPAddress(argv[CurrentArg], (IP_ADDR*)&dwVal))
break;
// Reconfigure the App to use the new values
if(var == VAR_IP_ADDRESS)
{
// Cause the IP address to be rebroadcast
// through Announce.c or the RS232 port since
// we now have a new IP address
if(dwVal.Val != *(DWORD*)&AppConfig.MyIPAddr)
DHCPBindCount++;
// Set the new address
memcpy((void*)&AppConfig.MyIPAddr, (void*)&dwVal, sizeof(AppConfig.MyIPAddr));
}
else if(var == VAR_SUBNET_MASK)
memcpy((void*)&AppConfig.MyMask, (void*)&dwVal, sizeof(AppConfig.MyMask));
else if(var == VAR_GATEWAY_ADDRESS)
memcpy((void*)&AppConfig.MyGateway, (void*)&dwVal, sizeof(AppConfig.MyGateway));
}
break;
case VAR_DHCP:
if(AppConfig.Flags.bIsDHCPEnabled)
{
if(!(argv[CurrentArg][0]-'0'))
{
AppConfig.Flags.bIsDHCPEnabled = FALSE;
}
}
else
{
if(argv[CurrentArg][0]-'0')
{
AppConfig.MyIPAddr.Val = 0x00000000ul;
AppConfig.Flags.bIsDHCPEnabled = TRUE;
AppConfig.Flags.bInConfigMode = TRUE;
DHCPInit(0);
}
}
break;
}
// Advance to the next variable (if present)
CurrentArg++;
}
// Save any changes to non-volatile memory
SaveAppConfig(&AppConfig);
// Return the same CONFIG.CGI file as a result.
memcpypgm2ram((void*)argv[0],
(ROM void*)CONFIG_UPDATE_PAGE, CONFIG_UPDATE_PAGE_LEN);
break;
#endif // #if defined(ENABLE_REMOTE_CONFIG)
default:
memcpypgm2ram((void*)argv[0], (ROM void*)COMMANDS_OK_PAGE, COMMANDS_OK_PAGE_LEN);
break;
}
}
static void HTTPProcess(HTTP_HANDLE h) {
char bafs[26], r;
BOOL lbContinue;
static HTTP_INFO* ph;
WORD w;
static BYTE *p, *t;
ph = &HCB[h];
do {
lbContinue = FALSE;
if(!TCPIsConnected(ph->socket)) { ph->smHTTP = SM_HTTP_IDLE; break; }
switch(ph->smHTTP) {
case SM_HTTP_IDLE:
w = TCPGetArray(ph->socket, httpData, MAX_HTML_CMD_LEN);
if(!w) {
if(TCPGetRxFIFOFree(ph->socket) == 0) TCPDisconnect(ph->socket); // Request is too big, we can't support it.
break;
}
httpData[w] = 0;
t = p = httpData;
while(*p) if(*p=='%') { *t++ = hex2bin(p+1); p += 3; } else *t++ = *p++; *t = 0;
r = httpData[150]; httpData[150]=0;
lbContinue = TRUE;
ph->smHTTP = SM_HTTP_NOT_FOUND;
if(strstrrampgm(httpData,"POST")) ph->smHTTP = SM_HTTP_POST;
if(strstrrampgm(httpData,"GET")) {
ph->smHTTP = SM_HTTP_HEADER;
#ifndef _FAVICON_
if(strstrrampgm(httpData,(ROM void*)"favicon")) { TCPDisconnect(ph->socket); ph->smHTTP = SM_HTTP_IDLE; }
#else
if(strstrrampgm(httpData,"favicon")) ph->smHTTP = SM_ICO_HEADER;
#endif
if(strstrrampgm(httpData, "Sw_Pool")) AppConfig.who ^= 0x81;
if(strstrrampgm(httpData, "Sw_Mode")) AppConfig.sw_mode ^= 1;
if(strstrrampgm(httpData, "Sw_Clock")) AppConfig.CkSel ^= 1;
if(strstrrampgm(httpData, "Sw_LEDs")) bLEDs ^= 1;
}
httpData[150]=r;
break;
case SM_HTTP_POST:
exoit(ph->socket);
memcpypgm2ram(spwrk,rMinPool,SZ_ROMS );
for(r=0;r<SZ_SRCH;r++) {
BYTE *s;
p = strstrrampgm(httpData,(ROM BYTE*)(DWORD)sComa[r]);
if(p) {
p+=5;
t=strstrrampgm(p,ampa);
if(t) {
*t=0; s=p;
switch(r) {
// case C_JMAC: Hex2Mac(p); break; //S2Mac(p); break;
case C_JMIP: StringToIPAddress(p,&AppConfig.MyIPAddr); break;
case C_JMSK: StringToIPAddress(p,&AppConfig.MyMask); break;
case C_JGTW: StringToIPAddress(p,&AppConfig.MyGateway); break;
case C_PDNS: StringToIPAddress(p,&AppConfig.PrimaryDNSServer); break;
case C_SDNS: StringToIPAddress(p,&AppConfig.SecondaryDNSServer); break;
case C_WPRT: AppConfig.MyPort = atoi(p); break;
case C_MPRT: while(*p) if((*p) == ',') { *p=0; AppConfig.MinPort[0] = atoi(s); break; } else p++;
AppConfig.MinPort[1] = atoi(++p); *--p = ',';
break;
case C_MURL: while(*p) if((*p) == ',') { *p=0; strcpy(&spwrk[0],s); break; } else p++;
strcpy(&spwrk[sizeof(rMinPool)/2],++p); *--p = ',';
break;
case C_USPA: while(*p) if((*p) == ',') { *p=0; strcpy(&spwrk[sizeof(rMinPool)],s); break; } else p++;
strcpy(&spwrk[sizeof(rMinPool)+sizeof(rUsrPass)/2],++p); *--p = ',';
break;
}
*t='&';
}
}
}
ph->smHTTP = SM_HTTP_IDLE; SetUPS();
break;
case SM_HTTP_NOT_FOUND:
if(TCPIsPutReady(ph->socket) >= sizeof(hdrErr)) {
TCPPutROMString(ph->socket, hdrErr); TCPFlush(ph->socket);
TCPDisconnect(ph->socket);
ph->smHTTP = SM_HTTP_IDLE;
}
break;
#ifdef _FAVICON_
case SM_ICO_HEADER:
if ( TCPIsPutReady(ph->socket) ) {
lbContinue = TRUE;
if(TCPIsPutReady(ph->socket) >= sizeof(hdrICO)+198) {
TCPPutROMString(ph->socket, hdrICO);
TCPPutROMArray(ph->socket, favicon,198);
TCPFlush(ph->socket);
TCPDisconnect(ph->socket);
ph->smHTTP = SM_HTTP_IDLE;
}
}
break;
#endif
case SM_HTTP_HEADER:
if ( TCPIsPutReady(ph->socket) ) {
lbContinue = TRUE;
if(TCPIsPutReady(ph->socket) >= sizeof(hdrOK)) {
TCPPutROMString(ph->socket, hdrOK);
TCPFlush(ph->socket);
ph->smHTTP = SM_HTTP_GET;
ph->Pos = Page;
}
}
break;
case SM_HTTP_GET:
TCPDiscard(ph->socket);
if(TCPIsPutReady(ph->socket) >= 400) {
ph->Pos = TCPPutROMString(ph->socket, ph->Pos);
ph->Pos++;
switch (*ph->Pos) {
case 0: TCPDisconnect(ph->socket); ph->smHTTP = SM_HTTP_IDLE; ph->Pos = Page; break;
case 1: DoStic(ph->socket, 1); break;
case 2: DoStic(ph->socket, 2); break;
case 3: DoStic(ph->socket, 3); break;
// case 4: MAC2Hex(bafs); TCPPutString(ph->socket, bafs); break;
case 5: IP2String(AppConfig.MyIPAddr,bafs); TCPPutString(ph->socket, bafs); break;
case 6: IP2String(AppConfig.MyMask,bafs); TCPPutString(ph->socket, bafs); break;
case 7: IP2String(AppConfig.MyGateway,bafs); TCPPutString(ph->socket, bafs); break;
case 8: uitoa(AppConfig.MyPort,bafs); TCPPutString(ph->socket, bafs); break;
case 9: IP2String(AppConfig.PrimaryDNSServer,bafs); TCPPutString(ph->socket, bafs); break;
case 10: IP2String(AppConfig.SecondaryDNSServer,bafs); TCPPutString(ph->socket, bafs); break;
case 11: uitoa(AppConfig.MinPort[0],bafs); TCPPutString(ph->socket, bafs); TCPPut(ph->socket,','); uitoa(AppConfig.MinPort[1],bafs); TCPPutString(ph->socket, bafs); break;
case 12: TCPPutROMString(ph->socket, rMinPool[0]); TCPPut(ph->socket,','); TCPPutROMString(ph->socket, rMinPool[1]); break;
case 13: TCPPutROMString(ph->socket, rUsrPass[0]); TCPPut(ph->socket,','); TCPPutROMString(ph->socket, rUsrPass[1]); break;
}
ph->Pos++;
}
TCPFlush(ph->socket);
break;
default: break;
}
} while( lbContinue );
}
void ExecuteMenuChoice(MENU_CMD choice)
{
char response[MAX_USER_RESPONSE_LEN];
IP_ADDR tempIPValue;
IP_ADDR *destIPValue;
serPutByte('\r');
serPutByte('\n');
serPutRomString(menuCommandPrompt[choice-'0'-1]);
switch(choice)
{
case MENU_CMD_SERIAL_NUMBER:
itoa(AppConfig.SerialNumber.Val, response);
serPutString((BYTE*)response);
serPutByte(')');
serPutByte(':');
serPutByte(' ');
if ( USARTGetString(response, sizeof(response)) )
{
AppConfig.SerialNumber.Val = atoi(response);
AppConfig.MyMACAddr.v[4] = AppConfig.SerialNumber.v[1];
AppConfig.MyMACAddr.v[5] = AppConfig.SerialNumber.v[0];
}
else
goto HandleInvalidInput;
break;
case MENU_CMD_IP_ADDRESS:
destIPValue = &AppConfig.MyIPAddr;
goto ReadIPConfig;
case MENU_CMD_GATEWAY_ADDRESS:
destIPValue = &AppConfig.MyGateway;
goto ReadIPConfig;
case MENU_CMD_SUBNET_MASK:
destIPValue = &AppConfig.MyMask;
ReadIPConfig:
DisplayIPValue(destIPValue, FALSE);
serPutByte(')');
serPutByte(':');
serPutByte(' ');
USARTGetString(response, sizeof(response));
if ( !StringToIPAddress(response, &tempIPValue) )
{
HandleInvalidInput:
serPutRomString(InvalidInputMsg);
while( !serIsGetReady() );
serGetByte();
}
else
{
destIPValue->Val = tempIPValue.Val;
}
break;
case MENU_CMD_ENABLE_AUTO_CONFIG:
AppConfig.Flags.bIsDHCPEnabled = TRUE;
break;
case MENU_CMD_DISABLE_AUTO_CONFIG:
AppConfig.Flags.bIsDHCPEnabled = FALSE;
break;
case MENU_CMD_DOWNLOAD_MPFS:
#if defined(MPFS_USE_EEPROM)
DownloadMPFS();
#endif
break;
case MENU_CMD_QUIT:
#if defined(MPFS_USE_EEPROM)
appcfgSave();
#endif
break;
}
}
/*****************************************************************************
* FUNCTION: do_ifconfig_cmd
*
* RETURNS: None
*
* PARAMS: None
*
* NOTES: Responds to the user invoking ifconfig
*****************************************************************************/
void do_ifconfig_cmd(void)
{
uint8_t macAddress[6];
uint8_t conState, cpId;
IP_ADDR ipAddress;
// if user only typed in ifconfig with no other parameters
if (ARGC == 1u)
{
IfconfigDisplayStatus();
return;
}
if (WF_hibernate.state)
{
WFConsolePrintRomStr("The Wi-Fi module is in hibernate mode - command failed.", true);
return;
}
#if defined(WF_CM_DEBUG)
else if ( (ARGC == 2u) && !strcmp((char *) ARGV[1], "info") )
{
uint8_t i;
tWFCMInfoFSMStats cm_stats;
WF_CMInfoGetFSMStats(&cm_stats);
for (i = 0; i < 12; i++)
{
sprintf( (char *) g_ConsoleContext.txBuf,
"[%02X]: %02X%02X %02X%02X",
i,
cm_stats.byte[i*4 + 0],
cm_stats.byte[i*4 + 1],
cm_stats.byte[i*4 + 2],
cm_stats.byte[i*4 + 3]
);
WFConsolePrintRamStr( (char *) g_ConsoleContext.txBuf , true);
}
}
else if ( (ARGC == 2u) && !strcmp((char *) ARGV[1], "scan") )
{
if (WF_Scan(1) != WF_SUCCESS) // scan, using CP 1
WFConsolePrintRomStr("Scan failed", true);
}
else if ( (ARGC == 2u) && !strcmp((char *) ARGV[1], "scanget") ) //"scangetresult"
{
tWFScanResult pScanResult[1];
WF_ScanGetResult(0, pScanResult);
}
else if ( (ARGC == 2u) && !strcmp((char *) ARGV[1], "cpgete") ) //"cpgetelements"
{
tWFCPElements pCPElements[1];
WF_CPGetElements(1, pCPElements);
}
#endif
// else if 2 arguments and the second arg is IP address
else if ( (ARGC == 2u) && (StringToIPAddress((uint8_t*)ARGV[1], &ipAddress)) )
{
#if defined(STACK_USE_DHCP_CLIENT)
if (DHCPIsEnabled(0))
{
WFConsolePrintRomStr("Static IP address should not be set with DHCP enabled", true);
return;
}
#endif
AppConfig.MyIPAddr.v[0] = ipAddress.v[0];
AppConfig.MyIPAddr.v[1] = ipAddress.v[1];
AppConfig.MyIPAddr.v[2] = ipAddress.v[2];
AppConfig.MyIPAddr.v[3] = ipAddress.v[3];
/* Microchip DHCP client clobbers static ip on every iteration of loop, even if dhcp is turned off*/
AppConfig.DefaultIPAddr.v[0] = ipAddress.v[0];
AppConfig.DefaultIPAddr.v[1] = ipAddress.v[1];
AppConfig.DefaultIPAddr.v[2] = ipAddress.v[2];
AppConfig.DefaultIPAddr.v[3] = ipAddress.v[3];
LCDDisplayIPValue(AppConfig.MyIPAddr);
}
// else if 2 args and second arg is MAC address
else if ( (ARGC == 2u) && isMacAddress(ARGV[1], macAddress))
{
/* Can only set MAC address in idle state */
WF_CMGetConnectionState(&conState, &cpId);
if ( conState != WF_CSTATE_NOT_CONNECTED )
{
WFConsolePrintRomStr("HW MAC address can only be set in idle mode", true);
return;
}
WF_SetMacAddress( macAddress );
AppConfig.MyMACAddr.v[0] = macAddress[0];
AppConfig.MyMACAddr.v[1] = macAddress[1];
AppConfig.MyMACAddr.v[2] = macAddress[2];
AppConfig.MyMACAddr.v[3] = macAddress[3];
AppConfig.MyMACAddr.v[4] = macAddress[4];
AppConfig.MyMACAddr.v[5] = macAddress[5];
}
else if ( (2u <= ARGC) && (strcmppgm2ram((char *)ARGV[1], (ROM FAR char *)"netmask") == 0) )
{
if (ARGC != 3u)
{
missingValue();
return;
}
#if defined(STACK_USE_DHCP_CLIENT)
if ( DHCPIsEnabled(0) )
{
WFConsolePrintRomStr(
"The Netmask should not be set with DHCP enabled", true);
return;
}
#endif
if ( !StringToIPAddress((uint8_t*)ARGV[2], &ipAddress) )
{
WFConsolePrintRomStr("Invalid netmask value", true);
return;
}
AppConfig.MyMask.v[0] = ipAddress.v[0];
AppConfig.MyMask.v[1] = ipAddress.v[1];
AppConfig.MyMask.v[2] = ipAddress.v[2];
AppConfig.MyMask.v[3] = ipAddress.v[3];
/* Microchip DHCP client clobbers static netmask on every iteration of loop, even if dhcp is turned off*/
AppConfig.DefaultMask.v[0] = ipAddress.v[0];
AppConfig.DefaultMask.v[1] = ipAddress.v[1];
AppConfig.DefaultMask.v[2] = ipAddress.v[2];
AppConfig.DefaultMask.v[3] = ipAddress.v[3];
}
else if ( (2u <= ARGC) && (strcmppgm2ram((char *)ARGV[1], (ROM FAR char *)"gateway") == 0) )
{
if (ARGC != 3u)
{
missingValue();
return;
}
if ( !StringToIPAddress((uint8_t*)ARGV[2], &ipAddress) )
{
WFConsolePrintRomStr("Invalid gateway value", true);
return;
}
AppConfig.MyGateway.v[0] = ipAddress.v[0];
AppConfig.MyGateway.v[1] = ipAddress.v[1];
AppConfig.MyGateway.v[2] = ipAddress.v[2];
AppConfig.MyGateway.v[3] = ipAddress.v[3];
}
else if ( (2u <= ARGC) && (strcmppgm2ram((char*)ARGV[1], "auto-dhcp") == 0) )
{
if (ARGC != 3u)
{
missingValue();
return;
}
#if defined(STACK_USE_DHCP_CLIENT)
if (strcmppgm2ram((char*)ARGV[2], "start") == 0)
{
setDHCPState(true);
}
else if (strcmppgm2ram((char*)ARGV[2], "stop") == 0)
{
setDHCPState(false);
}
else
#endif
{
WFConsolePrintRomStr(" Invalid dhcp param", true);
return;
}
}
else
{
notHandledParam(1);
}
}
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
*/
// library header file's path
#include "orte.h"
// pregenerated header
#include "jorte/org_ocera_orte_tools_Conversions.h"
/* native function - prototype declared in pregenerated header */
JNIEXPORT jlong JNICALL
Java_org_ocera_orte_tools_JORTEConversions_StringToIPAddress
(JNIEnv *env, jclass class, jstring jstrIP)
{
const char *charIP;
long longIP;
// get IP
charIP = (*env)->GetStringUTFChars(env, jstrIP, 0);
// call ORTE function
longIP = (long)StringToIPAddress(charIP);
// free memory
(*env)->ReleaseStringUTFChars(env, jstrIP, charIP);
return(longIP);
}
void ExecuteMenuChoice(MENU_CMD choice)
{
char response[MAX_USER_RESPONSE_LEN];
IP_ADDR tempIPValue;
IP_ADDR *destIPValue;
WORD_VAL w;
BYTE offset;
serPutByte('\r');
serPutByte('\n');
serPutRomString(menuCommandPrompt[choice-'0'-1]);
switch(choice)
{
case MENU_CMD_SERIAL_NUMBER:
w.byte.LSB = appcfgGetc(APPCFG_SERIAL_NUMBER0);
w.byte.MSB = appcfgGetc(APPCFG_SERIAL_NUMBER1);
itoa(w.Val, response);
serPutString((BYTE*)response);
serPutByte(')');
serPutByte(':');
serPutByte(' ');
if ( USARTGetString(response, sizeof(response)) )
{
w.Val = atoi(response);
appcfgPutc(APPCFG_SERIAL_NUMBER0, w.byte.LSB);
appcfgPutc(APPCFG_SERIAL_NUMBER1, w.byte.MSB);
AppConfig.MyMACAddr.v[4] = w.byte.MSB;
AppConfig.MyMACAddr.v[5] = w.byte.LSB;
}
else
goto HandleInvalidInput;
break;
case MENU_CMD_IP_ADDRESS:
destIPValue = &AppConfig.MyIPAddr;
offset = APPCFG_IP0;
goto ReadIPConfig;
case MENU_CMD_GATEWAY_ADDRESS:
destIPValue = &AppConfig.MyGateway;
offset = APPCFG_GATEWAY0;
goto ReadIPConfig;
case MENU_CMD_SUBNET_MASK:
destIPValue = &AppConfig.MyMask;
offset = APPCFG_MASK0;
ReadIPConfig:
scfDisplayIPValue(destIPValue);
serPutByte(')');
serPutByte(':');
serPutByte(' ');
USARTGetString(response, sizeof(response));
if ( !StringToIPAddress(response, &tempIPValue) )
{
HandleInvalidInput:
serPutRomString(InvalidInputMsg);
while( !serIsGetReady() );
serGetByte();
}
else
{
destIPValue->Val = tempIPValue.Val;
//Update new configuration data just entered
appcfgPutc(offset++, tempIPValue.v[0]);
appcfgPutc(offset++, tempIPValue.v[1]);
appcfgPutc(offset++, tempIPValue.v[2]);
appcfgPutc(offset++, tempIPValue.v[3]);
}
break;
case MENU_CMD_ENABLE_AUTO_CONFIG:
//Set DHCP flag
appcfgPutc(APPCFG_NETFLAGS, appcfgGetc(APPCFG_NETFLAGS) | APPCFG_NETFLAGS_DHCP);
break;
case MENU_CMD_DISABLE_AUTO_CONFIG:
//Clear DHCP flag
appcfgPutc(APPCFG_NETFLAGS, appcfgGetc(APPCFG_NETFLAGS) & ~APPCFG_NETFLAGS_DHCP);
break;
case MENU_CMD_DOWNLOAD_FSYS_IMAGE:
DownloadFsysImage();
break;
case MENU_CMD_QUIT:
break;
}
}
