void print_debug_inf_before_launch()
{
Wait ( 500 ) ;
PrintToScreen ( "\nVEX Debugger Utility\nby James Swineson\n\nStarting...\n" ) ;
PrintToScreen("Now you can switch to graphic display.\n");
ResetGD ( ) ;
}
//MailSlot of flush DNS cache sender
bool WINAPI FlushDNSMailSlotSender(
const wchar_t *Domain)
{
//Mailslot initialization
HANDLE hFile = CreateFileW(MAILSLOT_NAME, GENERIC_WRITE, FILE_SHARE_READ, nullptr, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, nullptr);
if (hFile == INVALID_HANDLE_VALUE)
{
PrintToScreen(true, L"Create mailslot error, error code is %lu.\n", GetLastError());
return false;
}
//Message initialization
std::wstring Message(MAILSLOT_MESSAGE_FLUSH_DNS);
if (Domain != nullptr)
{
Message.append(L": ");
Message.append(Domain);
}
//Write into mailslot.
DWORD cbWritten = 0;
if (!WriteFile(hFile, Message.c_str(), (DWORD)(sizeof(wchar_t) * Message.length() + 1U), &cbWritten, nullptr))
{
PrintToScreen(true, L"MailSlot write messages error, error code is %lu.\n", GetLastError());
CloseHandle(hFile);
return false;
}
else {
CloseHandle(hFile);
PrintToScreen(true, L"Flush DNS cache message was sent successfully.\n");
}
return true;
}
//Catch Control-C exception from keyboard.
BOOL WINAPI CtrlHandler(
const DWORD fdwCtrlType)
{
//Print to screen.
if (GlobalRunningStatus.Console)
{
switch (fdwCtrlType)
{
//Handle the CTRL-C signal.
case CTRL_C_EVENT:
{
PrintToScreen(true, L"Get Control-C.\n");
}break;
//Handle the CTRL-Break signal.
case CTRL_BREAK_EVENT:
{
PrintToScreen(true, L"Get Control-Break.\n");
}break;
//Handle other signals.
default:
{
PrintToScreen(true, L"Get closing signal.\n");
}break;
}
}
return FALSE;
}
GLDEF_C void TryUSBMS()
{
// Check first whether this boot is intended to load and boot an image from
// the media.
if (LoadDevice == EBootUSBMS)
{
PrintToScreen(_L("USB-MS boot scanning drives\r\n"));
// search drives for file - returns true if an image has been found
if (SearchDrives())
DoDownload();
}
PrintToScreen(_L("Starting USB Mass Storage\r\n"));
DisableMenu();
if(StartUSBMS())
{
// USB Mass Storage boot has started - don't continue with the
// bootloader, sleep here.
while(1)
User::After(10000000);
}
else
{
EnableMenu();
// Not started (probably no card in drive) revert to normal bootloader
// mode and notify the variant to rewrite it's configuration.
PrintToScreen(_L("NO VALID MEDIA\r\n"));
PrintToScreen(_L("Leaving USB Mass Storage mode\r\n"));
LoadDevice = ELoadDrive;
WriteConfig();
}
return;
}
void WaitForTouch() {
int pressed = !GetDigitalInput(button);
while(pressed == 1 && IsAutoActive()) {
SetDrive(0,0);
}
PrintToScreen ("Pressed!\n");
}
static void setArmPID() {
long armDegrees = ArmState;
long armPIDPosition = degreesToIMEticks(armDegrees);
PrintToScreen("SetArmPID: %d, %d\n", armDegrees, armPIDPosition);
UpdateSetpointIntegratedMotorEncoderPID(armL, armPIDPosition);
UpdateSetpointIntegratedMotorEncoderPID(armR, -armPIDPosition);
}
GLDEF_C void BootFault(TUint aId, TInt aLine, char aFileName[])
{
PrintToScreen(_L("BOOTFAULT: 0x%X in file %s @ line %d"), aId, aFileName, aLine);
User::After(1000); // delay to let the LCD draw the message
RDebug::Print(_L("BOOTFAULT: 0x%X in file %s @ line %d"), aId, aFileName, aLine);
User::LeaveIfError(KErrUnknown);
// Kern::Fault((const char*)buf.Ptr(),aLine);
}
void ProcessHeader(TZipInfo& a)
{
FileName=a.iName;
LoadSize=a.iUncompressedSize;
TInt size_mod_4k=LoadSize & 0xfff;
if (size_mod_4k==0)
ImageHeaderPresent=EFalse;
else if (size_mod_4k==256)
ImageHeaderPresent=ETrue;
else
{
PrintToScreen(_L("\r\n\r\nInvalid size\r\n"));
BOOT_FAULT();
}
ImageSize=ImageHeaderPresent ? LoadSize-256 : LoadSize;
PrintToScreen(_L("Unzip %lS, size %d\r\n"),&FileName,LoadSize);
#ifdef __SUPPORT_FLASH_REPRO__
if (LoadToFlash)
{
TInt r=InitFlashWrite();
if (r!=KErrNone)
{
PrintToScreen(_L("InitFlashWrite returned %d\r\n"),r);
BOOT_FAULT();
}
}
#endif
a.iOutBuf=(TUint8*)DestinationAddress();
a.iHeaderDone=2;
TRequestStatus* pS=&a.iProcessedHeader;
RThread t;
t.SetHandle(a.iThreadHandle);
t.RequestComplete(pS,0);
}
//Flush DNS cache FIFO sender
bool FlushDNSFIFOSender(
const uint8_t *Domain)
{
//Message initialization
std::string Message(FIFO_MESSAGE_FLUSH_DNS);
if (Domain != nullptr)
{
Message.append(": ");
Message.append((const char *)Domain);
}
//Write into FIFO file.
errno = 0;
int FIFO_Handle = open(FIFO_PATH_NAME, O_WRONLY|O_TRUNC|O_NONBLOCK, 0);
if (FIFO_Handle > 0)
{
if (write(FIFO_Handle, Message.c_str(), Message.length() + 1U) > 0)
{
close(FIFO_Handle);
PrintToScreen(true, L"Flush DNS cache message was sent successfully.\n");
return true;
}
else {
close(FIFO_Handle);
}
}
//Print error log.
std::lock_guard<std::mutex> ScreenMutex(ScreenLock);
PrintToScreen(false, L"FIFO write messages error");
if (errno > 0)
PrintToScreen(false, L", error code is %d.\n", errno);
else
PrintToScreen(false, L".\n");
return false;
}
GLDEF_C void AcceptUnzippedBlock(TZipInfo& aInfo, TUint8*& aOutPtr, TInt aError)
{
if (aError!=KErrNone)
{
PrintToScreen(_L("Error!\r\n"));
BOOT_FAULT();
}
#ifdef __SUPPORT_FLASH_REPRO__
if (LoadToFlash)
{
// signal flash programming thread
TInt got=(TInt)((TLinAddr)aOutPtr-(TLinAddr)DestinationAddress());
NotifyDataAvailable(got);
}
#endif
}
void DebugArm() {
long l, r;
l = GetIntegratedMotorEncoder(armL);
r = GetIntegratedMotorEncoder(armR);
PrintToScreen("arm encs: %ld, %ld\n", l, r);
}
TInt DoZipDownload(RFile &aBootFile)
{
TZipInfo z;
z.iRemain=FileSize;
InitProgressBar(0,(TUint)FileSize,_L("LOAD"));
TInt r=Initialise(z);
CHECK(r);
RThread t;
t.SetHandle(z.iThreadHandle);
while (z.iRemain && z.iThreadStatus==KRequestPending)
{
TRequestStatus dummy;
TRequestStatus* pS=&dummy;
r=ReadBlockToBuffer(z, aBootFile);
if (r != KErrNone)
{
PrintToScreen(_L("FAULT: Unzip Error %d\r\n"),r);
if (z.iFileBufW-z.iFileBufR==z.iFileBufSize)
{
PrintToScreen(_L("Check there is only one image\n\rin the zip file.\r\n"));
}
CHECK(r);
}
UpdateProgressBar(0,(TUint)(FileSize-z.iRemain));
t.RequestComplete(pS,0); // same process
while(z.iHeaderDone==0 && z.iThreadStatus==KRequestPending)
{
DELAY(20000);
}
if (z.iHeaderDone==1 && z.iThreadStatus==KRequestPending)
{
// after reading first block, process the header
ProcessHeader(z);
}
} // while
User::WaitForRequest(z.iThreadStatus);
TInt exitType=t.ExitType();
TInt exitReason=t.ExitReason();
if (z.iRemain || exitType!=EExitKill || exitReason!=KErrNone)
{
TBuf<32> exitCat=t.ExitCategory();
PrintToScreen(_L("Exit code %d,%d,%S\n"),exitType,exitReason,&exitCat);
TEST(0);
}
PrintToScreen(_L("Unzip complete\r\n"));
TUint8* pD=Buffer;
TInt len=1024;
r=ReadInputData(pD,len);
TEST(r==KErrEof);
DELAY(20000);
Cleanup(z);
return KErrNone;
}
void SaveState() {
SetSaveCompetitionIme(armL);
SetSaveCompetitionIme(armR);
GlobalData(GDATA_ARM) = ArmState;
PrintToScreen("save: %d, %d\n", ArmState);
}
/*-----------------------------------------------------------------------------------
-- FUNCTION: MonitorInputThread
--
-- DATE: October 3, 2015
--
-- REVISIONS: N/A
--
-- DESIGNER: Alvin Man
--
-- PROGRAMMER: Alvin Man
--
-- INTERFACE: DWORD WINAPI MonitorInputThread(LPVOID hwnd)
--
-- RETURNS: DWORD
--
-- NOTES: This is the main read thread code that handles receiving
-- characters from the serial port asynchronously.
-----------------------------------------------------------------------------------*/
DWORD WINAPI MonitorInputThread(LPVOID hwnd) {
DWORD readBytes;
DWORD dwRes;
DWORD readThreadExitCode;
char readBuffer[80] = "\0\0\0\0\0\0\0\0\0\0";
BOOL waitingOnRead = FALSE;
if (!SetupComm()) {
OutputDebugString("Error occurred while setting up communications");
return 0;
}
// create manual reset event for asynchronous I/O
o.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
if (o.hEvent == NULL) {
OutputDebugString("Error creating reset event");
return 0;
}
// read loop
while (1) {
//check if the session is still connected
if (!connected) {
if (GetExitCodeThread(readThread, &readThreadExitCode) != 0) {
readThread = 0;
if (!CloseHandle(hComm)) {
OutputDebugString("Error closing handle");
} else {
OutputDebugString("thread closed");
}
ExitThread(readThreadExitCode);
}
}
if (!waitingOnRead) {
//attempt to read the character from the serial port
if (!ReadFile(hComm, readBuffer, sizeof(readBuffer), &readBytes, &o)) {
if (GetLastError() != ERROR_IO_PENDING) {
MessageBox(NULL, "Error reading from serial port", "", MB_OK);
readThread = 0;
break;
} else {
waitingOnRead = TRUE;
}
}
}
if (waitingOnRead) {
//wait for overlapped I/O to complete
dwRes = WaitForSingleObject(o.hEvent, READ_TIMEOUT);
switch (dwRes) {
case WAIT_OBJECT_0:
if (!GetOverlappedResult(hComm, &o, &readBytes, FALSE)) {
MessageBox(NULL, "Error reading file", "", MB_OK);
break;
}
waitingOnRead = FALSE;
break;
case WAIT_TIMEOUT:
break;
default:
break;
}
}
// If we have read characters, print them to the screen
if (readBytes) {
PrintToScreen(readBuffer);
}
}
return 0;
}
TInt YModem::GetInnerCompression(TBool &aImageDeflated, TBool &aRomLoaderHeaderExists)
{
// Read, analyse and buffer ROM Image Header
DEBUG_PRINT((_L(">>YModem::GetInnerCompression()\r\n")))
// Try to read first 1k from the ROM Image
iDataSizeInPuffer = KHeaderBufferSize;
TUint8* pD=(TUint8*)iHeaderBuf.Ptr();
TInt r=ReadPackets(pD, iDataSizeInPuffer);
DEBUG_PRINT((_L("r:%d (0x%08x).\r\n"), r, r));
DEBUG_PRINT((_L("pD->:0x%08x.\r\n"), (TUint8*)pD));
DEBUG_PRINT((_L("iHeaderBuf.Ptr()->:0x%08x.\r\n"), (TUint8*)iHeaderBuf.Ptr()));
DEBUG_PRINT((_L("iDataSizeInPuffer:%d (0x%08x).\r\n"), iDataSizeInPuffer, iDataSizeInPuffer));
if( iDataSizeInPuffer != pD - iHeaderBuf.Ptr())
{
BOOT_FAULT();
}
// Analyse the inner compression method
const TUint8 * romLoaderSignature1 = (const TUint8*)"EPOC";
const TUint8 * romLoaderSignature2 = (const TUint8*)"ROM";
pD = (TUint8*)iHeaderBuf.Ptr();
r = KErrNone;
// Check headers
TRomHeader* romHeader= (TRomHeader *)pD;
DEBUG_PRINT((_L("pD ->:0x%08x.\r\n"), (TUint8*)pD));
DEBUG_PRINT((_L("romHeader->:0x%08x.\r\n"), (TUint8*)romHeader));
aRomLoaderHeaderExists = EFalse;
if( !memcmp1(pD, romLoaderSignature1, 4) && !memcmp1((pD+8), romLoaderSignature2, 3) )
{
// We have TRomLoaderHeader skip it
romHeader = (TRomHeader *) (pD +TROM_LOADER_HEADER_SIZE);
aRomLoaderHeaderExists = ETrue;
}
DEBUG_PRINT((_L("TRomLoaderHeader exists:%d.\r\n"), aRomLoaderHeaderExists));
DEBUG_PRINT((_L("romHeader->:0x%08x (0x%08x).\r\n"), (TUint8*)romHeader, (TUint8*)romHeader-pD));
if(romHeader->iCompressionType == 0 )
{
aImageDeflated = EFalse;
}
else if (romHeader->iCompressionType == KUidCompressionDeflate )
{
iImageDeflated = aImageDeflated = ETrue;
}
else
{
PrintToScreen(_L("Not supported compression method:0x%08x\r\n"), romHeader->iCompressionType);
r = KErrNotSupported;
}
DEBUG_PRINT((_L("iCompressionType :0x%08x\r\n"), romHeader->iCompressionType));
DEBUG_PRINT((_L("iCompressedSize :0x%08x\r\n"), romHeader->iCompressedSize));
DEBUG_PRINT((_L("iUncompressedSize:0x%08x\r\n"), romHeader->iUncompressedSize));
// Buffer it.
iHeaderStored = true;
DEBUG_PRINT((_L("<<YModem::GetInnerCompression():%d\r\n"), r))
return r;
}
void RestoreState(long *encR, long *encL) {
ArmState = GlobalData(GDATA_ARM);
*encR = GetSavedCompetitionIme(armR);
*encL = GetSavedCompetitionIme(armL);
PrintToScreen("restore: %d, %d\n", ArmState);
}
//saves the robot state to be passed from auto to user control
void SetRunningMode(MODE_TYPE mode) {
GlobalData(GDATA_LAST_MODE) = mode;
PrintToScreen("run mode: %d\n", mode);
}
void printArmIMEdegrees() {
PrintToScreen("%d\n", getArmIMEdegrees(armL));
}
//restores robot state from autonomous
MODE_TYPE GetLastMode() {
MODE_TYPE mode = (MODE_TYPE) GlobalData(GDATA_LAST_MODE);
PrintToScreen("last mode: %d\n", mode);
return mode;
}
// autonomous command to set the intake and arm to specific states
void SetScorer(ARM_STATES armStateAuto, INTAKE_STATES intakeStateAuto) {
//if(!IsAutoActive()) return;
SetIntake(intakeStateAuto);
SetArmState(armStateAuto);
PrintToScreen("armState: %d", ArmState);
}
