static void MENU_update(void)
{
static const far rom char *values[] = {
(ROMCHAR)"OFF",
(ROMCHAR)"ON",
};
static const far rom char *formats[] = {
(ROMCHAR)" STEREO ",
(ROMCHAR)" BASS BOOST ",
(ROMCHAR)" RDS ",
(ROMCHAR)" ABOUT "
};
memset(menu[0].title, ' ', 16);
memset(menu[1].title, ' ', 16);
memset(menu[2].title, ' ', 16);
strcpypgm2ram(menu[0].title, formats[0]);
strcpypgm2ram(menu[1].title, formats[1]);
strcpypgm2ram(menu[2].title, formats[2]);
strcpypgm2ram(menu[3].title, formats[3]);
strcatpgm2ram(menu[0].title, values[!(mem_data->flags & RDA_FLAG_MONO)]);
strcatpgm2ram(menu[1].title, values[(mem_data->flags & RDA_FLAG_BASS) == RDA_FLAG_BASS]);
strcatpgm2ram(menu[2].title, values[(mem_data->flags & RDA_FLAG_RDS) == RDA_FLAG_RDS]);
}
void main(void)
{
int count = 0;
char buffer[20];
OSCCON = OSCCON_VALUE; // Sets 16MHz
modemSetup();
aprsMakeCallsignPgm(&(s_packet.to), APRS_ADDRESS_TEST, APRS_DESTINATION_SSID_NONE);
aprsMakeCallsignPgm(&(s_packet.from), "M0RJC", 9);
aprsSetLastAddress(&(s_packet.from));
while(1)
{
modemTxMode();
modemStartTone(0);
Delay10KTCYx(0); // 2,560,000 cycles * 4MHz
modemStartTone(1);
Delay10KTCYx(0); // 2,560,000 cycles * 4MHz
strcpypgm2ram(s_packet.message, ">Test Message from M0RJC tracker project");
aprsSendPacket(&s_packet);
Delay10KTCYx(0); // 2,560,000 cycles * 4MHz
Delay10KTCYx(0); // 2,560,000 cycles * 4MHz
Delay10KTCYx(0); // 2,560,000 cycles * 4MHz
strcpypgm2ram(s_packet.message, ":M0RJC :If you can read this it works. ");
itoa(count++, buffer);
strcat(s_packet.message, buffer);
aprsSendPacket(&s_packet);
Delay10KTCYx(0); // 2,560,000 cycles * 4MHz
Delay10KTCYx(0); // 2,560,000 cycles * 4MHz
Delay10KTCYx(0); // 2,560,000 cycles * 4MHz
strcpypgm2ram(s_packet.message, ":M0RJC :Message Again. ");
itoa(count++, buffer);
strcat(s_packet.message, buffer);
aprsSendPacket(&s_packet);
modemRxMode();
Delay10KTCYx(0); // 2,560,000 cycles * 4MHz
Delay10KTCYx(0); // 2,560,000 cycles * 4MHz
}
}
void net_msg_tpms(void)
{
char k;
long p;
int b,a;
if ((car_tpms_t[0]==0)&&(car_tpms_t[1]==0)&&
(car_tpms_t[2]==0)&&(car_tpms_t[3]==0))
return; // No TPMS, no report
strcpypgm2ram(net_scratchpad,(char const rom far*)"MP-0 W");
for (k=0;k<4;k++)
{
if (car_tpms_t[k]>0)
{
p = (long)((float)car_tpms_p[k]/0.2755);
b = (p / 10);
a = (p % 10);
sprintf(net_msg_scratchpad, (rom far char*)"%d.%d,%d,",
b,a,(int)(car_tpms_t[k]-40));
strcat(net_scratchpad,net_msg_scratchpad);
}
else
{
strcatpgm2ram(net_scratchpad, (rom far char*)"0,0,");
}
}
net_scratchpad[strlen(net_scratchpad)-1] = 0; // Remove trailing ','
net_msg_encode_puts();
}
void PutsString(const rom char *str)
{
if (!WaitToReadySerial()) return;
strcpypgm2ram(uartOutBuffer, (const far rom char*)str);
WriteSerial(uartOutBuffer);
if (!WaitToReadySerial()) return;
}
/*********************************************************************
* 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();
}
/*! **********************************************************************
* Function: sendROM(void)
*
* @brief
*
* Include: Local to Menusystem.c
*
* @description: Transmits the given string from ROM over serial
*
* @input The string to transmit
*
* Returns: None
*************************************************************************/
static void sendROM(const rom char *romchar) {
char temp[80] = {0};
int j;
// Convert the string from ROM to RAM
strcpypgm2ram(temp, romchar);
transmit(temp);
for (j = 0; j < 8000; j++); //Some Arbitrary Delay
}
void net_msg_firmware(void)
{
// Send firmware version and GSM signal level
strcpypgm2ram(net_scratchpad,(char const rom far*)"MP-0 F");
sprintf(net_msg_scratchpad, (rom far char*)"1.0.8,%s,%d",
car_vin, net_sq);
strcat(net_scratchpad,net_msg_scratchpad);
net_msg_encode_puts();
}
// Receive a NET msg from the OVMS server
void net_msg_in(char* msg)
{
int k;
if (net_msg_serverok == 0)
{
if (memcmppgm2ram(msg, (char const rom far*)"MP-S 0 ", 7) == 0)
{
net_msg_server_welcome(msg+7);
}
return; // otherwise ignore it
}
// Ok, we've got an encrypted message waiting for work.
// The following is a nasty hack because base64decode doesn't like incoming
// messages of length divisible by 4, and is really expecting a CRLF
// terminated string, so we give it one...
strcatpgm2ram(msg,(char const rom far*)"\r\n");
k = base64decode(msg,net_scratchpad);
RC4_crypt(&rx_crypto1, &rx_crypto2, net_scratchpad, k);
if (memcmppgm2ram(net_scratchpad, (char const rom far*)"MP-0 ", 5) == 0)
{
msg = net_scratchpad+5;
switch (*msg)
{
case 'A': // PING
strcpypgm2ram(net_scratchpad,(char const rom far*)"MP-0 a");
if (net_msg_sendpending==0)
{
net_msg_start();
net_msg_encode_puts();
net_msg_send();
}
break;
case 'Z': // PEER connection
if (msg[1] != '0')
{
net_apps_connected = 1;
if (net_msg_sendpending==0)
{
net_msg_start();
net_msg_stat();
net_msg_gps();
net_msg_tpms();
net_msg_firmware();
net_msg_environment();
net_msg_send();
}
}
else
{
net_apps_connected = 0;
}
break;
}
}
}
void net_msg_firmware(void)
{
// TODO: GSM signal level not reported yet
strcpypgm2ram(net_scratchpad,(char const rom far*)"MP-0 F");
sprintf(net_msg_scratchpad, (rom far char*)"1.0.0,%s,%d",
car_vin,0);
strcat(net_scratchpad,net_msg_scratchpad);
net_msg_encode_puts();
}
Move getMoveFromList(char id) {
Move newMove;
switch (id) {
case 'F':
strcpypgm2ram(newMove.moveName, "FAIL");
newMove.baseDamage = 100;
newMove.moveType = EARTH;
newMove.uses = 10;
break;
default:
strcpypgm2ram(newMove.moveName, "SCRATCH");
newMove.baseDamage = 6;
newMove.moveType = EARTH;
newMove.uses = 15;
break;
}
return newMove;
}
void net_msg_valettrunk(void)
{
char *p;
delay100(2);
net_msg_start();
strcpypgm2ram(net_scratchpad,(char const rom far*)"MP-0 PATrunk has been opened (valet mode).");
net_msg_encode_puts();
net_msg_send();
}
void net_msg_alarm(void)
{
char *p;
delay100(2);
net_msg_start();
strcpypgm2ram(net_scratchpad,(char const rom far*)"MP-0 PAVehicle alarm is sounding!");
net_msg_encode_puts();
net_msg_send();
}
void net_msg_environment(void)
{
strcpypgm2ram(net_scratchpad,(char const rom far*)"MP-0 D");
sprintf(net_msg_scratchpad, (rom far char*)"%d,%d,%d,%d,%d,%d,%d,%lu,%d",
car_doors1, car_doors2, car_lockstate,
car_tpem, car_tmotor, car_tbattery,
car_trip, car_odometer, car_speed);
strcat(net_scratchpad,net_msg_scratchpad);
net_msg_encode_puts();
}
void net_msg_gps(void)
{
strcpypgm2ram(net_scratchpad,(char const rom far*)"MP-0 L");
format_latlon(car_latitude,net_msg_scratchpad);
strcat(net_scratchpad,net_msg_scratchpad);
strcatpgm2ram(net_scratchpad,(char const rom far*)",");
format_latlon(car_longitude,net_msg_scratchpad);
strcat(net_scratchpad,net_msg_scratchpad);
net_msg_encode_puts();
}
void xpl_send_sensor_basic_output(enum XPL_MSG_TYPE msg_type) {
char result[4];
xpl_print_header(msg_type);
printf("sensor.basic\n{\ndevice=output%i\n",xpl_output_id);
strcpypgm2ram(result,output_get_state(xpl_output_id));
printf("type=output\ncurrent=%s\n}\n",result);
return;
}
/******************************************************************************
* Function: void ReadMessageFromEEPROM(void)
*
* PreCondition: None
*
* Input: None
*
* Output: None
*
* Side Effects: None
*
* Overview: This function will save a store message from the EEPROM
* to memory. If no valid message is on EEPROM, save a
* default one.
*
* Note:
*
*****************************************************************************/
void ReadMessageFromEEPROM()
{
char length, eeprom_crc, eeprom_message[MESSAGE_LENGTH+1];
eeprom_crc = readEEPROM(0x00);
length = readEEPROM(0x01);
// Se o CRC do comprimento da mensagem for incorrecto, n‹o se faz load da mensagem
if (crc(0,length) != eeprom_crc)
strcpypgm2ram(message, MESSAGE_DEFAULT);
else
{
eeprom_crc = readEEPROM(0x02);
readStrEEPROM(0x03, length, eeprom_message);
eeprom_message[length] = '\0';
if (strcrc(eeprom_message) != eeprom_crc)
strcpypgm2ram(message, MESSAGE_DEFAULT);
else
strcpy(message, eeprom_message);
}
}
/********************************************************************
* Function: void ProcessIO(void)
*
* PreCondition: None
*
* Input: None
*
* Output: None
*
* Side Effects: None
*
* Overview: This function is a place holder for other user
* routines. It is a mixture of both USB and
* non-USB tasks.
*
* Note: None
*******************************************************************/
void ProcessIO(void)
{
static unsigned char cerr,nl,n,i,b;
static unsigned int p,q;
static rtccTimeDate td;
// Soft Start the APP_VDD
if(AppPowerReady() == FALSE) return;
/* --------------------
* User input section, handles touchbuttons, and the menu button
* for less cpu stress it runs on every 2000th loop.
* buttonstate bits flags if the butoon pressed or released for
* exclude repetition. position and screen variables points the
* cursors place, and the action depends on it (incrementing,
* decrementing variables even the position and screen variable.
* if the screen variable changed, the screenvalid become false
* pointing the drawing section to refresh screen.
* if the positon variable changed, the positionchanged become
* true pointing that the cursor moves.
* -------------------- */
if(executionTick++>2000)
{
executionTick=0;
//<editor-fold desc="reset button">
if(buttonstate.bits.b3) // button RB0 : Menu
{
if(PORTBbits.RB0)
{
resetcounter=0;
screenvalid=0;
buttonstate.bits.b3=0;
}
else
{
strcpypgm2ram(cbuf,(const rom far char *)"Reset ");
if(!(resetcounter++%10)||(!resetcounter))
{
itoa(10-resetcounter/10,cbuf+6);
rjustify(cbuf+6,2);
oledPutStringINV((unsigned char *)cbuf,7,0);
}
if(resetcounter>105)
{
_asm
RESET
_endasm
}
}
}
else
if(!PORTBbits.RB0)
void net_msg_alert(void)
{
char *p;
delay100(2);
net_msg_start();
strcpypgm2ram(net_scratchpad,(char const rom far*)"MP-0 PA");
switch (car_chargemode)
{
case 0x00:
strcatpgm2ram(net_scratchpad,(char const rom far *)"Standard - "); // Charge Mode Standard
break;
case 0x01:
strcatpgm2ram(net_scratchpad,(char const rom far *)"Storage - "); // Storage
break;
case 0x03:
strcatpgm2ram(net_scratchpad,(char const rom far *)"Range - "); // Range
break;
case 0x04:
strcatpgm2ram(net_scratchpad,(char const rom far *)"Performance - "); // Performance
}
switch (car_chargestate)
{
case 0x01:
strcatpgm2ram(net_scratchpad,(char const rom far *)"Charging"); // Charge State Charging
break;
case 0x02:
strcatpgm2ram(net_scratchpad,(char const rom far *)"Charging, Topping off"); // Topping off
break;
case 0x04:
strcatpgm2ram(net_scratchpad,(char const rom far *)"Charging Done"); // Done
break;
default:
strcatpgm2ram(net_scratchpad,(char const rom far *)"Charging Stopped"); // Stopped
}
strcatpgm2ram(net_scratchpad,(char const rom far *)"\rIdeal Range: "); // Ideal Range
p = par_get(PARAM_MILESKM);
if (*p == 'M') // Kmh or Miles
sprintf(net_msg_scratchpad, (rom far char*)"%u mi", car_idealrange); // Miles
else
sprintf(net_msg_scratchpad, (rom far char*)"%u Km", (unsigned int) ((float) car_idealrange * 1.609)); // Kmh
strcat((char*)net_scratchpad,net_msg_scratchpad);
strcatpgm2ram(net_scratchpad,(char const rom far *)" SOC: ");
sprintf(net_msg_scratchpad, (rom far char*)"%u%%", car_SOC); // 95%
strcat(net_scratchpad,net_msg_scratchpad);
net_msg_encode_puts();
net_msg_send();
}
/*******************************************************************************
* FUNCTION NAME: PrintString
* PURPOSE: Prints a string to the serial port.
* CALLED FROM: anywhere
* ARGUMENTS: none
* Argument Type IO Description
* -------- ------------- -- -----------
* bufr pointer I word of data to be transmitted
* RETURNS: void
*******************************************************************************/
void PrintString(char *bufr)
{
static int len,I;
strcpypgm2ram (ifi_printfBufr,(rom char *) bufr); /*Move from flash to ram*/
len = (int) strlen((const char *)ifi_printfBufr);
if (len > 80) len = 80;
for (I=0;I<len;I++)
{
TXREG = ifi_printfBufr[I];
Wait4TXEmpty();
}
}
void net_msg_stat(void)
{
char *p;
strcpypgm2ram(net_scratchpad,(char const rom far*)"MP-0 S");
p = par_get(PARAM_MILESKM);
sprintf(net_msg_scratchpad,(rom far char*)"%d,%s,%d,%d,",car_SOC,p,car_linevoltage,car_chargecurrent);
strcat(net_scratchpad,net_msg_scratchpad);
switch (car_chargestate)
{
case 0x01:
strcatpgm2ram(net_scratchpad,(char const rom far*)"charging,"); // Charge State Charging
break;
case 0x02:
strcatpgm2ram(net_scratchpad,(char const rom far*)"topoff,"); // Topping off
break;
case 0x04:
strcatpgm2ram(net_scratchpad,(char const rom far*)"done,"); // Done
break;
default:
strcatpgm2ram(net_scratchpad,(char const rom far*)"stopped,"); // Stopped
}
switch (car_chargemode)
{
case 0x00:
strcatpgm2ram(net_scratchpad,(char const rom far*)"standard,"); // Charge Mode Standard
break;
case 0x01:
strcatpgm2ram(net_scratchpad,(char const rom far*)"storage,"); // Storage
break;
case 0x03:
strcatpgm2ram(net_scratchpad,(char const rom far*)"range,"); // Range
break;
case 0x04:
strcatpgm2ram(net_scratchpad,(char const rom far*)"performance,"); // Performance
default:
strcatpgm2ram(net_scratchpad,(char const rom far*)",");
}
if (*p == 'M') // Kmh or Miles
sprintf(net_msg_scratchpad, (rom far char*)"%u,", car_idealrange);
else
sprintf(net_msg_scratchpad, (rom far char*)"%u,", (unsigned int) ((float) car_idealrange * 1.609));
strcat(net_scratchpad,net_msg_scratchpad);
if (*p == 'M') // Kmh or Miles
sprintf(net_msg_scratchpad, (rom far char*)"%u", car_estrange);
else
sprintf(net_msg_scratchpad, (rom far char*)"%u", (unsigned int) ((float) car_estrange * 1.609));
strcat(net_scratchpad,net_msg_scratchpad);
net_msg_encode_puts();
}
tZGVoidReturn ZGErrorHandler(ROM char *p_errorString)
{
#if defined STACK_USE_UART
ZG_PUTRSUART("ERROR: ");
ZG_PUTRSUART(p_errorString);
ZG_PUTRSUART("\r\n");
#endif
#if defined(USE_LCD)
strcpypgm2ram((char*)LCDText, p_errorString);
LCDUpdate();
#endif
while (1);
}
// Encode the message in net_scratchpad and start the send process
void net_msg_encode_puts(void)
{
int k;
char code;
if (net_state == NET_STATE_DIAGMODE)
{
net_puts_ram(net_scratchpad);
}
else
{
if ((ptokenmade==1)&&
(net_scratchpad[5]!='E')&&
(net_scratchpad[5]!='A')&&
(net_scratchpad[5]!='a')&&
(net_scratchpad[5]!='g')&&
(net_scratchpad[5]!='P'))
{
// We must convert the message to a paranoid one...
// The message in net_scratchpad is of the form MP-0 X...
// Where X is the code and ... is the (optional) data
// Let's rebuild it in the net_msg_scratchpad...
code = net_scratchpad[5];
strcpy(net_msg_scratchpad,net_scratchpad+6);
// Paranoid encrypt the message part of the transaction
RC4_setup(&pm_crypto1, &pm_crypto2, pdigest, MD5_SIZE);
for (k=0;k<1024;k++)
{
net_scratchpad[0] = 0;
RC4_crypt(&pm_crypto1, &pm_crypto2, net_scratchpad, 1);
}
k=strlen(net_msg_scratchpad);
RC4_crypt(&pm_crypto1, &pm_crypto2, net_msg_scratchpad, k);
strcpypgm2ram(net_scratchpad,(char const rom far*)"MP-0 EM");
net_scratchpad[7] = code;
base64encode(net_msg_scratchpad,k,net_scratchpad+8);
// The messdage is now in paranoid mode...
}
k=strlen(net_scratchpad);
RC4_crypt(&tx_crypto1, &tx_crypto2, net_scratchpad, k);
base64encodesend(net_scratchpad,k);
}
net_puts_rom("\r\n");
}
void setUImsg( UINT8 msgIndex )
{
UINT8 i;
UINT8 msg[32];
clearLCD();
strcpypgm2ram(msg,UI_MSG[msgIndex]);
i = 0;
while( msg[i] != '\0')
{
putCharToLcd(msg[i]);
i++;
}
}
void net_msg_environment(void)
{
unsigned long park;
if (car_parktime == 0)
park = 0;
else
park = car_time - car_parktime;
strcpypgm2ram(net_scratchpad,(char const rom far*)"MP-0 D");
sprintf(net_msg_scratchpad, (rom far char*)"%d,%d,%d,%d,%d,%d,%d,%lu,%d,%lu",
car_doors1, car_doors2, car_lockstate,
car_tpem, car_tmotor, car_tbattery,
car_trip, car_odometer, car_speed, park);
strcat(net_scratchpad,net_msg_scratchpad);
net_msg_encode_puts();
}
void net_msg_forward_sms(char *caller, char *SMS)
{
//Server not ready, stop sending
//TODO: store this message inside buffer, resend it when server is connected
if ((net_msg_serverok == 0)||(net_msg_sendpending)>0)
return;
delay100(2);
net_msg_start();
strcpypgm2ram(net_scratchpad,(char const rom far*)"MP-0 PA");
strcatpgm2ram(net_scratchpad,(char const rom far*)"SMS FROM: ");
strcat(net_scratchpad, caller);
strcatpgm2ram(net_scratchpad,(char const rom far*)" - MSG: ");
SMS[70]=0; // Hacky limit on the max size of an SMS forwarded
strcat(net_scratchpad, SMS);
net_msg_encode_puts();
net_msg_send();
}
unsigned int print_ticket(unsigned int source,unsigned int destination)
{
unsigned int final_amount =0,final_amount_cpy =0,fx =0,final_length_cpy =0,j,final_amount_length =0;
unsigned char final_disp[20],afx[5];
if(source > destination)
{
final_amount = (source - destination)*5;
}
if(destination>source)
{
final_amount = (destination - source)*5;
}
final_amount_cpy = final_amount;
final_disp[0] = 'R';
final_disp[1] = 's';
final_disp[2] = ':';
final_disp[3] = '1';
final_disp[4] = '*';
final_amount_length=10;
for(j=0;j<=final_amount_length;j++)
{
fx=final_amount_cpy%10;
afx[j]=inttochar(fx);
final_amount_cpy = final_amount_cpy/10;
}
final_length_cpy=final_amount_length;
for(j=0;j<=final_amount_length;j++)
{
final_disp[j+5]=afx[final_length_cpy-1];
final_length_cpy=final_length_cpy-1;
}
final_disp[final_amount_length+5] = '=';
final_length_cpy=final_amount_length;
for(j=0;j<=final_amount_length;j++)
{
final_disp[final_amount_length+6+j]=afx[final_length_cpy-1];
final_length_cpy=final_length_cpy-1;
}
DelayMs(2);
strcpypgm2ram((char*)LCDText, final_disp);
display_row(1);
//display_row(1,final_disp);
return final_amount;
}
/* Update item value */
void updateItemValue(ButtonSettings *buttonSettings, char *data) {
/* update only if the lenght of all fields if larger than zero */
if (strlen((char *)&buttonSettings->itemUpdateHost) == 0
|| strlen((char *)&buttonSettings->itemUpdatePort) == 0
|| strlen((char *)&buttonSettings->itemUpdateMethod) == 0
|| strlen((char *)&buttonSettings->itemUpdateUrl) == 0)
return;
/* create a new HTTP Request object */
HTTPRequest httpRequest;
strcpypgm2ram((char *)&httpRequest.data, data);
strcpy((char *)&httpRequest.method, (char *)&buttonSettings->itemUpdateMethod);
strcpy((char *)&httpRequest.host, (char *)&buttonSettings->itemUpdateHost);
strcpy((char *)&httpRequest.port, (char *)&buttonSettings->itemUpdatePort);
strcpy((char *)&httpRequest.itemUrl, (char *)&buttonSettings->itemUpdateUrl);
/* Add the HTTP Request to the queue */
SendHTTPRequest(&httpRequest, &itemUpdateQueue);
}
/********************************************************************
* Function: void ProcessMenu(void)
*
* PreCondition: None
*
* Input: None
*
* Output: None
*
* Side Effects: None
*
* Overview: This function parses the input string given
* by the user.
*
* Note: None
*******************************************************************/
void ProcessMenu(void)
{
int i; // Debug
// If the line is empty return.
if(RS232cp == 0) return;
// Strip the CR/NL character.
RS232_Out_Data[RS232cp] = '\0';
// Test different menu options
if(strcmpram2pgm("help", RS232_Out_Data) == 0)
putrsUSBUSART("\r\nAvailable commands:\r\n\r\n* help - Displays this message, recursive style!\r\n* setMessage <text> - Defines a new message to be displayed on the POV.\r\n* showMessage - Shows the current message\r\n* version - Displays firmware version.");
else if(strncmpram2pgm("setMessage ", RS232_Out_Data, 10) == 0)
{
// Copy message
strncpy(message, &RS232_Out_Data[11], MESSAGE_LENGTH);
message[MESSAGE_LENGTH] = '\0';
writeEEPROM(0x00, crc(0x00, (char) strlen(message)));
writeEEPROM(0x01, (char) strlen(message));
writeStrEEPROM(0x03, strlen(message), message);
writeEEPROM(0x02, strcrc(message));
// Display confirmation
strcpypgm2ram(RS232_Out_Data, "\r\nYour message is now defined as:\r\n\t");
strcat(RS232_Out_Data, message);
putsUSBUSART(RS232_Out_Data);
}
else if(strcmpram2pgm("showMessage", RS232_Out_Data) == 0)
{
sprintf(RS232_Out_Data, "\r\nYour message is defined as:\r\n\t%s", message);
putsUSBUSART(RS232_Out_Data);
}
else if(strcmpram2pgm("version", RS232_Out_Data) == 0)
putrsUSBUSART("\r\nPOV serial configuration. Version 0.9");
else
putrsUSBUSART("\r\nUnknown command. Type 'help' for the list of available commands.");
clearRS232Buffer = 1;
}
void WriteLCDMenu(void)
{// Update the LCD screen
// Blank the LCD display
strcpypgm2ram((char*)LCDText, (ROM char*)" ");
// Show the name
strcpy((char*)LCDText, (char*)Products[curItem].name);
LCDText[strlen((char*)Products[curItem].name)] = ' ';
// Show the price, or sold out status
if(Products[curItem].stock == 0u)
{
memcpypgm2ram(&LCDText[12], (ROM void*)"SOLD", 4);
}
else
{
LCDText[11] = '$';
WritePriceLCD(Products[curItem].price, 12);
}
// Show the current credit
LCDText[16] = '$';
WritePriceLCD(curCredit, 17);
// Show the vend button if available
if(Products[curItem].stock != 0u && Products[curItem].price <= curCredit)
memcpypgm2ram(&LCDText[22], (ROM void*)"Vend", 4);
else
memcpypgm2ram(&LCDText[23], (ROM void*)"--", 2);
// Show the rest of the buttons
if(curItem != 0u)
memcpypgm2ram(&LCDText[27], (ROM void*)"<<", 2);
if(curItem != MAX_PRODUCTS-1)
memcpypgm2ram(&LCDText[30], (ROM void*)">>", 2);
// Update to the screen
LCDUpdate();
}
bool_t ValidateCommandReceived(char type, char code[], char result[], char* g, char* m)
{
if(isNumber(code))
{
int cmd = atoi(code);
if( (type == 'G') )
{
// CHEQUEAR QUE PASA SI SE SOBREPASA DEL TAMAÑO DEL ARRAY
if( (cmd < gCodesCount) && (gCodes[cmd] != NULL) )
{
strcpypgm2ram(result, (const rom char far *)"CMDS|");
*g = cmd;
return true;
}
else
{
strcpypgm2ram(result, (const rom char far *)"ERR:CMDNS|");
return false;
}
}
if( (type == 'M') )
{
// CHEQUEAR QUE PASA SI SE SOBREPASA DEL TAMAÑO DEL ARRAY
if( (cmd < mCodesCount) && (mCodes[cmd] != NULL) )
{
strcpypgm2ram(result, (const rom char far *)"CMDS|");
*m = cmd;
return true;
}
else
{
strcpypgm2ram(result, (const rom char far *)"ERR:CMDNS|");
return false;
}
}
}
// to handle custom g code
if( (type == 'G') && (atoi(code) == -1) )
{
strcpypgm2ram(result, (const rom char far *)"CMDS|");
*g = atoi(code);
return true;
}
strcpypgm2ram(result, (const rom char far *)"ERR:CMDE|");
return false;
}
