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; }