unsigned int mygets(unsigned int length,char *buffer)
{
while(length) /* read till length is 0 */
{
while(!DataRdyUART());
*buffer++ = ReadUART(); /* data word from HW buffer to SW buffer */
length--;
}
return(length); /* number of data yet to be received i.e.,0 */
}
void getsUART(char *buffer, unsigned char len)
{
char i; // Length counter
unsigned char data;
for(i=0;i<len;i++) // Only retrieve len characters
{
while(!DataRdyUART());// Wait for data to be received
data = ReadUART(); // Get a character from the USART
// and save in the string
*buffer = data;
buffer++; // Increment the string pointer
}
}
uint8_t ReadStringUART(uint8_t *Dest, uint8_t BufferLen)
{
uint8_t c;
uint8_t count = 0;
while(BufferLen--)
{
*Dest = '\0';
while(!DataRdyUART());
c = ReadUART();
if(c == '\r' || c == '\n')
break;
count++;
*Dest++ = c;
}
return count;
}
BYTE ReadStringUART(BYTE *Dest, BYTE BufferLen)
{
BYTE c;
BYTE count = 0;
while(BufferLen--)
{
*Dest = '\0';
while(!DataRdyUART());
c = ReadUART();
if(c == '\r' || c == '\n')
break;
count++;
*Dest++ = c;
}
return count;
}
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;
}
}
}
//////////////////////////////////////////////////////////////////////////////////////////
// NOTE: The following XMODEM code has been upgarded to MPFS2 from MPFS Classic.
// Upgrading to HTTP2 and MPFS2 is *strongly* recommended for all new designs.
// MPFS2 images can be uploaded directly using the MPFS2.exe tool.
//////////////////////////////////////////////////////////////////////////////////////////
static BOOL DownloadMPFS(void)
{
enum SM_MPFS
{
SM_MPFS_SOH,
SM_MPFS_BLOCK,
SM_MPFS_BLOCK_CMP,
SM_MPFS_DATA,
} state;
BYTE c;
MPFS_HANDLE handle;
BOOL lbDone;
BYTE blockLen=0;
BYTE lResult;
BYTE tempData[XMODEM_BLOCK_LEN];
DWORD lastTick;
DWORD currentTick;
state = SM_MPFS_SOH;
lbDone = FALSE;
handle = MPFSFormat();
// Notify the host that we are ready to receive...
lastTick = TickGet();
do
{
currentTick = TickGet();
if ( currentTick - lastTick >= (TICK_SECOND/2) )
{
lastTick = TickGet();
while(BusyUART());
WriteUART(XMODEM_NAK);
/*
* Blink LED to indicate that we are waiting for
* host to send the file.
*/
LED6_IO ^= 1;
}
} while(!DataRdyUART());
while(!lbDone)
{
if(DataRdyUART())
{
// Toggle LED as we receive the data from host.
LED6_IO ^= 1;
c = ReadUART();
}
else
{
// Real application should put some timeout to make sure
// that we do not wait forever.
continue;
}
switch(state)
{
default:
if ( c == XMODEM_SOH )
{
state = SM_MPFS_BLOCK;
}
else if ( c == XMODEM_EOT )
{
// Turn off LED when we are done.
LED6_IO = 1;
MPFSClose(handle);
while(BusyUART());
WriteUART(XMODEM_ACK);
lbDone = TRUE;
}
else
{
while(BusyUART());
WriteUART(XMODEM_NAK);
}
break;
case SM_MPFS_BLOCK:
// We do not use block information.
lResult = XMODEM_ACK;
blockLen = 0;
state = SM_MPFS_BLOCK_CMP;
break;
case SM_MPFS_BLOCK_CMP:
// We do not use 1's comp. block value.
state = SM_MPFS_DATA;
break;
case SM_MPFS_DATA:
// Buffer block data until it is over.
tempData[blockLen++] = c;
if ( blockLen > XMODEM_BLOCK_LEN )
{
lResult = XMODEM_ACK;
for ( c = 0; c < XMODEM_BLOCK_LEN; c++ )
MPFSPutArray(handle,&tempData[c],1);
MPFSPutEnd(handle);
while(BusyUART());
WriteUART(lResult);
state = SM_MPFS_SOH;
}
break;
}
}
return TRUE;
}
/*****************************************************************************
* FUNCTION: WFConsoleProcess
*
* RETURNS: None
*
* PARAMS: None
*
* NOTES: State machine called from main loop of app. Handles serial input.
*
*****************************************************************************/
void WFConsoleProcess(void)
{
//UINT8 *pStart = &(cmdline[0]);
UINT16 rc;
INT8 c;
static INT8 escape_sequence[kWFMaxInputEscapeSequence];
static INT8 esc_seq_index;
// if this state machine has been disabled
if (g_ConsoleContext.bStateMachineLoop == FALSE)
{
return;
}
// if a command was entered that is application=specific
if (g_ConsoleContext.appConsoleMsgRx == TRUE)
{
return; // wait until app done before processing further characters
}
// if no character(s) received
if ( (rc = DataRdyUART() ) == 0u )
{
return;
}
// get the character
c = (INT8) ReadUART();
// if this is the very first character received by this state machine
if (g_ConsoleContext.firstChar == FALSE)
{
Output_Monitor_Hdr();
g_ConsoleContext.firstChar = TRUE;
}
switch( GET_RX_STATE() )
{
//------------------------------------------
case kSTWaitForChar:
//------------------------------------------
// if a 'normal' printable character
if (isPrintableCharacter(c))
{
InsertCharacter(c);
}
// else if Delete key
else if (c == kWFDelete)
{
Delete();
}
// else if Backspace key
else if (c == (INT8)kWFBackspace)
{
Backspace();
}
// else if Enter key
else if (c == kWFEnter)
{
Enter();
}
// else if Escape key
else if (c == kWFEscape)
{
/* zero out escape buffer, init with ESC */
memset(escape_sequence, 0x00, sizeof(escape_sequence));
escape_sequence[0] = kWFEscape;
esc_seq_index = 1;
SET_RX_STATE(kSTWaitForEscSeqSecondChar);
}
// else if Ctrl C
else if (c == kWFCtrl_C)
{
OutputCommandPrompt();
}
else {
// Enter();
}
break;
//------------------------------------------
case kSTWaitForEscSeqSecondChar:
//------------------------------------------
/* if an arrow key, home, or end key (which is all that this state machine handles) */
if (c == 0x5b)
{
escape_sequence[1] = c;
SET_RX_STATE(kSTWaitForEscSeqThirdChar);
}
// else if user pressed escape followed by any printable character
else if (isPrintableCharacter(c))
{
InsertCharacter(c);
SET_RX_STATE(kSTWaitForChar);
}
// start this command line over
else // anything else
{
OutputCommandPrompt();
SET_RX_STATE(kSTWaitForChar);
}
break;
//------------------------------------------
case kSTWaitForEscSeqThirdChar:
//------------------------------------------
escape_sequence[2] = c;
ProcessEscapeSequence(escape_sequence);
SET_RX_STATE(kSTWaitForChar);
break;
} // end switch
}
bool AutoUpdate_UartXMODEM_24G(void)
{
enum SM_FIRMWARE_UPDATE
{
SM_FIRMWARE_UPDATE_SOH,
SM_FIRMWARE_UPDATE_BLOCK,
SM_FIRMWARE_UPDATE_BLOCK_CMP,
SM_FIRMWARE_UPDATE_DATA,
SM_FIRMWARE_UPDATE_CHECKSUM,
SM_FIRMWARE_UPDATE_FINISH,
} state;
uint8_t c;
// MPFS_HANDLE handle;
bool lbDone;
uint8_t blockLen=0;
bool lResult = false;
uint8_t BlockNumber=0, preBlockNum=0;
uint8_t checksum=0;
uint32_t lastTick;
uint32_t currentTick;
state = SM_FIRMWARE_UPDATE_SOH;
lbDone = false;
#if 0 //use button to begin update
if( BUTTON3_IO == 1u) return false;
putsUART("\n\rPress S2 (on Explorer16) to start the update.\n\r");
while(BUTTON2_IO == 1u);
#else //use console command to begin update
if(false == wf_update_begin_uart) return false;
wf_update_begin_uart = false;
#endif
MACInit();
DelayMs(100);
AutoUpdate_Initialize();
putsUART("Please initiate file transfer of firmware patch by XMODEM.\r\n");
putsUART("If S3 pressed (on Explorer16), update will stop and previous image will be restored.\r\n");
lastTick = TickGet();
do
{
currentTick = TickGet();
if ( currentTick - lastTick >= (TICK_SECOND*2) )
{
lastTick = TickGet();
while(BusyUART());
WriteUART(XMODEM_NAK);
}
} while(!DataRdyUART());
while(!lbDone)
{
if (BUTTON3_IO == 0u) // If you want to cancel AutoUpdate, please press S3
{
putsUART("You press S3 button, revert begin...\r\n");
AutoUpdate_Restore();
putsUART("revert done\r\n");
return false;
}
if(DataRdyUART())
{
c = ReadUART();
lastTick = TickGet();
}
else
{
// put some timeout to make sure that we do not wait forever.
currentTick = TickGet();
if ( currentTick - lastTick >= (TICK_SECOND*10) )
{
//if time out, copy old patch image from bank2 to bank1
putsUART("timeout, revert begin...\r\n");
AutoUpdate_Restore();
putsUART("revert done\r\n");
return false;
}
continue;
}
//dbgPrintf("(%02x) ",c);
switch(state)
{
case SM_FIRMWARE_UPDATE_SOH:
if(c == XMODEM_SOH)
{
state = SM_FIRMWARE_UPDATE_BLOCK;
dbgPrintf("\r\n! ");
checksum = c;
lResult = true;
}
else if ( c == XMODEM_EOT )
{
state = SM_FIRMWARE_UPDATE_FINISH;
while(BusyUART());
WriteUART(XMODEM_ACK);
lbDone = true;
}
else
{
dbgPrintf("\n!error\n");
while(1);
}
break;
case SM_FIRMWARE_UPDATE_BLOCK:
BlockNumber = c;
dbgPrintf("BLK=%d ",BlockNumber);
checksum += c;
state = SM_FIRMWARE_UPDATE_BLOCK_CMP;
break;
case SM_FIRMWARE_UPDATE_BLOCK_CMP:
dbgPrintf("%d ",c);
dbgPrintf("@:");
//Judge: Is it correct ?
if(c != (BlockNumber ^ 0xFF))
{
lResult = false;
dbgPrintf("\nBLOCK_CMP err: %x,%x\n", c, BlockNumber ^ 0xFF );
}
else
{
if((uint8_t)(preBlockNum+1) != BlockNumber)
{
lResult = false;
dbgPrintf("\nBLOCK err %x %x\n",preBlockNum+1,BlockNumber);
}
}
checksum += c;
blockLen = 0;
state = SM_FIRMWARE_UPDATE_DATA;
break;
case SM_FIRMWARE_UPDATE_DATA:
// Buffer block data until it is over.
tempData[blockLen++] = c;
if ( blockLen == XMODEM_BLOCK_LEN )
{
state = SM_FIRMWARE_UPDATE_CHECKSUM;
}
checksum += c;
break;
case SM_FIRMWARE_UPDATE_CHECKSUM:
dbgPrintf("Checksum=%x=%x ",checksum,c);
if(checksum != c)
{
lResult = false;
dbgPrintf("\nchecksum err\n");
}
XMODEM_SendToModule(tempData);
while(BusyUART());
if(lResult == true)
{
WriteUART(XMODEM_ACK);
preBlockNum++;
}
else
{
WriteUART(XMODEM_NAK);
}
state = SM_FIRMWARE_UPDATE_SOH;
break;
default:
dbgPrintf("\n!error\n");
while(1);
break;
}
}
AutoUpdate_Completed();
return true;
}
