System.c

00001 #include "System.h"
00002 
00003 DigitalOut EXT_LED0(LED2);
00004 DigitalOut ETH_LED_GREEN(p29);
00005 DigitalOut ETH_LED_YELLOW(p30);
00006 DigitalIn  ActionButton(p28);
00007 DigitalIn  SDCardDetect(p9);
00008 Ticker  SystemTick;
00009 
00010 WORD UpdateHostTerminalTick;
00011 WORD DisplayUpdateTick;
00012 WORD ButtonCheckTick;
00013 WORD DisplayShutOffTick;
00014 
00015 BYTE SystemState;
00016 CHAR DTBuf[32];
00017 CHAR DataLineBuf[256];
00018 
00019 //*****************************************************************
00020 //smart Display related stuff
00021 //*****************************************************************
00022 
00023 #define DISPLAY_MEASUREMENTS       0x00
00024 #define DISPLAY_BATTERY            0x01
00025 #define DISPLAY_DATE_TIME          0x02
00026 #define DISPLAY_CARD_STATUS        0x03
00027 #define DISPLAY_BUFFER_STATS       0x04
00028 #define DISPLAY_FIRMWARE_VERSION   0x05
00029 #define DISPLAY_ID                 0x06
00030 #define DISPLAY_OFF                0xFF
00031 
00032 #define NUM_DISPLAYS               7
00033 #define DISPLAY_SHUTOFF_TIME    10000
00034 
00035 BYTE DisplayMode;
00036 BYTE LastBackLightColor = 0;
00037 
00038 //*****************************************************************
00039 //Action Button Related stuff
00040 //*****************************************************************
00041 #define WAITING_FOR_PRESS   0x00
00042 #define WAITING_FOR_RELEASE 0x01
00043 
00044 BYTE PreviousButtonState;   
00045 BYTE CurrentButtonState;   
00046 WORD ButtonHoldTime;
00047 BYTE ButtonCheckState;
00048 void ActionButtonHandler(WORD ButtonPressTime);
00049 
00050 //*****************************************************************
00051 //Terminal Related stuff
00052 //*****************************************************************
00053 
00054 //#define MAX_TERMINAL_LINE_CHARS 128
00055 //CHAR TerminalLineBuf[MAX_TERMINAL_LINE_CHARS];
00056 //BYTE TerminalPos;
00057 time_t CurrentTime_InSec;
00058 tm *CurrentTime;
00059 BOOL ProcessTerminalLine(CHAR * LineIn);
00060 BOOL CheckForTime(CHAR *LineIn);
00061 BOOL CheckForDate(CHAR *LineIn);
00062 BOOL CheckForTimeInit(CHAR * LineIn);
00063 BOOL CheckforConfig(CHAR *LineIn);
00064 
00065 //*****************************************************************
00066 //Logging Related Stuff
00067 //*****************************************************************
00068 CHAR CurrentLogFileName[256];
00069 BOOL InitDataLog();
00070 BOOL DataLogError;
00071 CHAR *ErrorMsg;
00072 
00073 void CreateLogFileName();
00074 
00075 FATFS MyFileSystem;
00076 FIL  CurrentLogFileHandle;
00077 
00078 //DataBlock MyDataBlock[2];
00079 DataBlock MyDataBlock;
00080 
00081 BYTE ActiveDataBlock;
00082 DWORD   DataBlocksWritten;
00083 DWORD   DataPointIndex;
00084 SIGNED_DWORD ReadWriteDifferential;
00085 
00086 DWORD   WritesSinceLastFlush;
00087 
00088 #define BINARY_WRITE_CACHE_THRESHOLD   512
00089 BYTE    BinaryDataCache[BINARY_WRITE_CACHE_THRESHOLD + 64];
00090 DWORD   BinaryDataCachePtr;
00091 
00092 #define NUM_WRITES_BEFORE_FLUSH (10)
00093 
00094 //*****************************************************************
00095 //Misc System Related Stuff
00096 //*****************************************************************
00097 void SystemTickIrq();
00098 void AdjustIOffset();
00099 
00100 void InitRobotPowerMeasurementSystem()
00101 {
00102     InitDataBlocks(&MyDataBlock);
00103      
00104     ActiveDataBlock = 0;
00105     DataBlocksWritten = 0;
00106     DataPointIndex = 0;
00107     
00108     SystemTick.attach_us(&SystemTickIrq,10000);
00109     CurrentTime_InSec = time(NULL);
00110   
00111     DataLogError = FALSE;
00112 }
00113 
00114 
00115 void InitDataBlocks(DataBlock * DB)
00116 {
00117     int i;
00118   
00119     for(i=0;i<DATA_BLOCK_SIZE;i++)
00120     {
00121         DB->Voltage[i] = 0;
00122         DB->Current[i] = 0;
00123     }
00124     
00125      DB->WriteOutPtr = 0;
00126      DB->ReadInPtr = 0;
00127 }
00128 
00129 
00130 void EnterSystemState(BYTE NextState)
00131 {
00132     switch(NextState)
00133     {
00134         default:
00135         case SYSTEM_STATE_INIT:
00136             DisplayMode = DISPLAY_MEASUREMENTS;
00137             SystemState = NextState;
00138         break;
00139         
00140         case SYSTEM_STATE_LOGGING:
00141               DisplayMode = DISPLAY_CARD_STATUS;
00142               
00143               if(InitDataLog() == FALSE)
00144               {
00145                 SystemState = NextState;
00146               
00147               }
00148               else
00149               {
00150                 SystemState = SYSTEM_STATE_IDLE;
00151               }
00152               
00153         break;
00154         
00155         case SYSTEM_STATE_IDLE:
00156             DisplayMode = DISPLAY_CARD_STATUS;
00157             if(SystemState == SYSTEM_STATE_LOGGING)
00158             {
00159                 f_close(&CurrentLogFileHandle);
00160                 f_mount(0,NULL);
00161                 PrintfEnqueue(&PCBackDoorTx,"Logging terminated on file %s\r\n>",CurrentLogFileName);
00162             }
00163             
00164             SystemState = NextState;
00165         break;
00166     }
00167 }
00168 
00169 BOOL InitDataLog()
00170 {
00171     UINT BytesWritten;
00172     
00173     PrintfEnqueue(&PCBackDoorTx,"\r\n\r\bInitializing Data log....\r\n");
00174     CreateLogFileName();
00175     PrintfEnqueue(&PCBackDoorTx,"Filename: %s\r\n",CurrentLogFileName);
00176     PrintfEnqueue(&PCBackDoorTx,"Attempting File Open....\r\n");
00177    
00178     BinaryDataCachePtr = 0;
00179     WritesSinceLastFlush = 0;
00180     
00181     f_mount(0,&MyFileSystem);
00182     if(f_open(&CurrentLogFileHandle,&CurrentLogFileName[0],FA_WRITE | FA_OPEN_ALWAYS) != FR_OK)
00183       {
00184                 DataLogError = TRUE;
00185                 PrintfEnqueue(&PCBackDoorTx,"Could not open file!\r\n>");
00186                 ErrorMsg = "Write Error!";
00187                 return TRUE;
00188       }
00189     
00190      DataBlocksWritten = 0;
00191      DataPointIndex = 0;
00192      
00193      DataLogError = FALSE;
00194      PrintfEnqueue(&PCBackDoorTx,"Writing Headers....\r\n");
00195      time(&CurrentTime_InSec);
00196      strftime(DTBuf,128, "%Y.%m.%d", localtime(&CurrentTime_InSec));
00197      f_printf(&CurrentLogFileHandle, "Date      %s\r\n",DTBuf);
00198      strftime(DTBuf,128, "%H:%M:%S", localtime(&CurrentTime_InSec));
00199      f_printf(&CurrentLogFileHandle, "Time      %s\r\n\n",DTBuf);
00200      sprintf(DTBuf, "Sample Rate   %.1f Hz\r\n\r\n",SAMPLE_RATE);
00201      f_write(&CurrentLogFileHandle,DTBuf,strlen(DTBuf),&BytesWritten);
00202      PrintfEnqueue(&PCBackDoorTx,"Headers Written.... Starting log\r\n");
00203     
00204     
00205     PrintfEnqueue(&PCBackDoorTx,"\r\n>"); 
00206 
00207     return FALSE;
00208 }
00209 
00210 
00211 void CreateLogFileName()
00212 {
00213      time(&CurrentTime_InSec);
00214      strftime(CurrentLogFileName,256, "F%Y.%m.%d.%H.%M.%S.csv", localtime(&CurrentTime_InSec));
00215 }     
00216 
00217 
00218 
00219 void SystemTickIrq()
00220 {
00221     if(UpdateHostTerminalTick<0xFFFF)
00222         UpdateHostTerminalTick++;
00223         
00224     if(DisplayUpdateTick<0xFFFF)
00225         DisplayUpdateTick++;
00226         
00227     if(ButtonCheckTick<0xFFFF)
00228          ButtonCheckTick++;
00229          
00230      if(DisplayShutOffTick<0xFFFF)
00231         DisplayShutOffTick++;
00232 }
00233 
00234 void InitButton()
00235 {
00236     ButtonCheckState = WAITING_FOR_PRESS;
00237     ButtonCheckTick = 0;
00238     PreviousButtonState = FALSE;
00239     CurrentButtonState = FALSE;
00240 
00241 }
00242 void CheckButton()
00243 {
00244     if(ButtonCheckTick>0)
00245     {
00246         ButtonCheckTick = 0;
00247         
00248         PreviousButtonState = CurrentButtonState;
00249         CurrentButtonState = ActionButton.read();    
00250     
00251         switch(ButtonCheckState)
00252         {
00253             default:
00254             case WAITING_FOR_PRESS:
00255             
00256             if(CurrentButtonState == TRUE && PreviousButtonState == FALSE)
00257             {
00258                 ButtonCheckState = WAITING_FOR_RELEASE; 
00259             }
00260             
00261             ButtonHoldTime = 0;
00262             
00263             break;
00264                         
00265             case WAITING_FOR_RELEASE:
00266             
00267             if(CurrentButtonState == TRUE && PreviousButtonState == TRUE)
00268             {
00269                 ButtonHoldTime++;
00270             }
00271             else if(CurrentButtonState == FALSE && PreviousButtonState == TRUE)
00272             {
00273                 ActionButtonHandler(ButtonHoldTime);
00274                 ButtonCheckState = WAITING_FOR_PRESS;    
00275             }
00276             else
00277             {
00278                ButtonCheckState = WAITING_FOR_PRESS;    
00279             }
00280             break;
00281         }
00282     }
00283 }
00284 
00285 
00286 void ActionButtonHandler(WORD ButtonPressTime)
00287 {
00288     DisplayShutOffTick = 0;
00289 
00290     if(ButtonPressTime<50)
00291     {
00292        if(DisplayMode == DISPLAY_OFF)
00293        {
00294          PowerUpSmartSwitch();
00295          SmartSwitch_Reset();
00296          SmartSwitchClear();
00297          DisplayMode = DISPLAY_MEASUREMENTS;
00298        }
00299        else
00300        {
00301        
00302             if(DataLogError == TRUE)
00303             {
00304                 DataLogError = FALSE;
00305             }
00306             else
00307             {
00308                 DisplayMode++;
00309                
00310                 if(DisplayMode >= NUM_DISPLAYS)
00311                 {
00312                     DisplayMode = 0;
00313                 }
00314             }
00315         }
00316     }
00317     
00318     else if(ButtonPressTime>100 && ButtonPressTime<500)
00319     {
00320         switch(SystemState)
00321         {
00322             default:
00323             case SYSTEM_STATE_IDLE:
00324                switch(DisplayMode)
00325                {
00326                    default:
00327                  
00328                     break;
00329                
00330                     case DISPLAY_MEASUREMENTS:
00331                         AdjustIOffset();
00332                     break;
00333                     
00334                     
00335                     case DISPLAY_FIRMWARE_VERSION:
00336                         LoadConfiguration();
00337                     break;
00338                     
00339                     
00340                     case DISPLAY_CARD_STATUS:
00341                          if(SDCardDetect == 1)
00342                             {
00343                                 EnterSystemState(SYSTEM_STATE_LOGGING);
00344                             }
00345                     break;
00346                }
00347             break;
00348             
00349          
00350             case SYSTEM_STATE_LOGGING:
00351               EnterSystemState(SYSTEM_STATE_IDLE);
00352              // unmount the file system
00353               f_mount(0,NULL);
00354             break;
00355         }
00356     }
00357 }
00358 
00359 void AdjustIOffset()
00360 {
00361     DWORD SamplesToTake;
00362     DWORD i;
00363     float RunningSum = 0;
00364     
00365     PrintfEnqueue(&PCBackDoorTx,"Zeroing ACS576.....\r\n");
00366     
00367     ADCDataRdy=0;
00368     
00369     SamplesToTake = (DWORD)(SAMPLE_RATE)*2;
00370     
00371     for(i=0;i<SamplesToTake;i++)
00372     {
00373         SmartSwitch_SetBackLightColor2((BYTE)((float)i/(float)SamplesToTake * 64));
00374         
00375         while(ADCDataRdy == FALSE)
00376         {
00377         
00378         }
00379         ADCDataRdy = FALSE;
00380         RunningSum += RobotBusCurrentHR;
00381     }
00382     
00383     ACS576_IOFFSET_TRIM += RunningSum / SamplesToTake;
00384 
00385     SmartSwitch_SetBackLightColor(3,3,3);
00386     
00387     PrintfEnqueue(&PCBackDoorTx,"Exporting new configuration file.....\r\n>");
00388     
00389     ExportConfigurationSettings();
00390 }
00391 
00392 
00393 /*void UpdateHostTerminal()
00394 {
00395  BYTE NextCharIn;
00396  
00397     if(BytesInQueue(&PCBackDoorRx)>0)
00398     {
00399         ByteDequeue(&PCBackDoorRx,&NextCharIn);
00400         
00401         switch(NextCharIn)
00402         {
00403             case '\r':
00404              
00405              TerminalLineBuf[TerminalPos++] = 0x0;
00406              ByteEnqueue(&PCBackDoorTx,NextCharIn);
00407              ProcessTerminalLine(TerminalLineBuf);
00408              ByteEnqueue(&PCBackDoorTx,'\n');
00409              ByteEnqueue(&PCBackDoorTx,'>');
00410              TerminalPos = 0;
00411               
00412             break;
00413             
00414             case '\b':
00415                 if(TerminalPos > 0)
00416                 {
00417                     TerminalPos--;    
00418                     ByteEnqueue(&PCBackDoorTx,NextCharIn);
00419                 }
00420             break;
00421             
00422             default:
00423                 
00424                 if(NextCharIn > 32)
00425                 {
00426                     if(TerminalPos < MAX_TERMINAL_LINE_CHARS-1)
00427                     {
00428                          TerminalLineBuf[TerminalPos++] = NextCharIn;
00429                            ByteEnqueue(&PCBackDoorTx,NextCharIn);
00430                     }
00431                 }
00432             
00433             break;
00434         
00435         }
00436     }
00437  
00438 }
00439 */
00440 
00441 BOOL ProcessTerminalLine(CHAR * LineIn)
00442 {
00443     CheckForTime(LineIn);
00444     CheckForDate(LineIn);
00445     CheckForTimeInit(LineIn);
00446     CheckforConfig(LineIn);
00447     return TRUE;
00448 }
00449 
00450 BOOL CheckforConfig(CHAR *LineIn)
00451 {
00452     if(!strcmp(LineIn,"config"))
00453     {
00454         LoadConfiguration();
00455     }
00456     return TRUE;
00457 }
00458 
00459 
00460 BOOL CheckForTimeInit(CHAR * LineIn)
00461 {
00462     if(!strcmp(LineIn,"tinit"))
00463     {
00464         set_time(1256729737);
00465        PrintfEnqueue(&PCBackDoorTx,"\r\nTime Reset\r\n");
00466     }
00467     
00468     return TRUE;
00469 
00470 }
00471 
00472 BOOL CheckForTime(CHAR *LineIn)
00473 {
00474     int Hour,Minute,Second=0;
00475     int Items;
00476     BOOL Error = FALSE;
00477      time_t TimeStampTemp;
00478     
00479     
00480     Items = sscanf(LineIn, "time=%d : %d  : %d", &Hour, &Minute, &Second);
00481     if(Items == 3)
00482     {
00483         PrintfEnqueue(&PCBackDoorTx,"\r\n");
00484         if(Hour>23)
00485         {
00486             PrintfEnqueue(&PCBackDoorTx,"Hour entry must be between 0 and 24\r\n");
00487             Error = TRUE;
00488         }
00489         if(Minute>60)
00490         {
00491             PrintfEnqueue(&PCBackDoorTx,"Minute entry must be between 0 and 60\r\n");
00492             Error = TRUE;
00493         }
00494         if(Second>60)
00495         {
00496             PrintfEnqueue(&PCBackDoorTx,"Second entry must be between 0 and 60\r\n");
00497             Error = TRUE;
00498         }
00499         
00500         if(Error == TRUE)
00501         {
00502          PrintfEnqueue(&PCBackDoorTx,"Error in time format.  Time not changed.\r\n");
00503         }
00504         else
00505         {
00506             TimeStampTemp = time(NULL);
00507             //convert to tm struct 
00508             CurrentTime = localtime(&TimeStampTemp);
00509             //dump in our new valus
00510             CurrentTime->tm_sec = Second;
00511             CurrentTime->tm_min = Minute;
00512             CurrentTime->tm_hour = Hour;
00513             //set the new time
00514             set_time(mktime(CurrentTime));
00515             PrintfEnqueue(&PCBackDoorTx,"Time set to %d:%d:%d\r\n",Hour,Minute,Second);
00516         }
00517      
00518       }
00519    return FALSE;
00520 }
00521 
00522 BOOL CheckForDate(CHAR *LineIn)
00523 {
00524     int Day,Month,Year=0;
00525     int Items;
00526     BOOL Error = FALSE;
00527     time_t TimeStampTemp;
00528     
00529     Items = sscanf(LineIn, "date=%d / %d  / %d", &Month, &Day, &Year);
00530     if(Items == 3)
00531     {
00532         PrintfEnqueue(&PCBackDoorTx,"\r\n");
00533         if(Month>12 || Month < 1)
00534         {
00535             PrintfEnqueue(&PCBackDoorTx,"Month entry must be between 1 and 12\r\n");
00536             Error = TRUE;
00537         }
00538         if(Day>31 || Day<1)
00539         {
00540             PrintfEnqueue(&PCBackDoorTx,"Day entry must be between 1 and 31\r\n");
00541             Error = TRUE;
00542         }
00543         if(Year<1900)
00544         {
00545             PrintfEnqueue(&PCBackDoorTx,"Year entry must be greater than 1900\r\n");
00546             Error = TRUE;
00547         }
00548         
00549         if(Error == TRUE)
00550         {
00551          PrintfEnqueue(&PCBackDoorTx,"Error in time format.  Date not changed.\r\n");
00552         }
00553         else
00554         {
00555             //Get the current time in seconds since unix epoch
00556             TimeStampTemp = time(NULL);
00557             //convert to tm struct fom
00558             CurrentTime = localtime(&TimeStampTemp);
00559             //dump in our new valus
00560             CurrentTime->tm_mon = Month-1;
00561             CurrentTime->tm_mday = Day;
00562             CurrentTime->tm_year = Year - 1900;
00563             //set the new time
00564             set_time(mktime(CurrentTime));
00565             PrintfEnqueue(&PCBackDoorTx,"Date set to %d/%d/%d\r\n",Month,Day,Year);
00566         }
00567      
00568       }
00569    return FALSE;
00570 }
00571 
00572 
00573 
00574 void UpdateDisplay()
00575 {
00576 
00577     if(DisplayShutOffTick > DISPLAY_SHUTOFF_TIME)
00578     {
00579         DisplayMode = DISPLAY_OFF;
00580         SmartSwitchClear();
00581        PowerDownSmartSwitch();
00582     }
00583     else
00584     {
00585         if(DisplayUpdateTick > 25)
00586         {
00587             GFX_FullDisplayBufferClear(&BackBuffer);
00588             DisplayUpdateTick = 0;
00589                 switch(DisplayMode)
00590                 {
00591                     default:
00592                     case DISPLAY_MEASUREMENTS:
00593                       SmartSwitch_SetBackLightColor(3,3,3);
00594                        GFX_DrawString(&BackBuffer,"Robot Bus",0,0,&Font5x7);
00595                        GFX_DrawHline(&BackBuffer,0,PHYSICAL_DISPLAY_XRES-1,10);
00596                        GFX_DrawHline(&BackBuffer,0,PHYSICAL_DISPLAY_XRES-1,11);
00597                        GFX_DrawHline(&BackBuffer,0,PHYSICAL_DISPLAY_XRES-1,12);
00598                         
00599                        GFX_printf(&BackBuffer,0,16,&Font5x7,"V: %.2fv",RobotBusVoltageHR);
00600                        GFX_printf(&BackBuffer,0,24,&Font5x7,"I: %.2fa",RobotBusCurrentHR);
00601                     break;
00602                     
00603                    
00604                     case DISPLAY_BATTERY:
00605                        SmartSwitch_SetBackLightColor(3,3,0);
00606                        GFX_DrawString(&BackBuffer,"Battery",0,0,&Font5x7);
00607                        GFX_DrawHline(&BackBuffer,0,PHYSICAL_DISPLAY_XRES-1,10);
00608                        GFX_DrawHline(&BackBuffer,0,PHYSICAL_DISPLAY_XRES-1,11);
00609                        GFX_DrawHline(&BackBuffer,0,PHYSICAL_DISPLAY_XRES-1,12);
00610                         
00611                        GFX_printf(&BackBuffer,0,16,&Font5x7,"V: %.1fv",BatteryVoltage);
00612                       
00613                     break;
00614                     
00615                      case DISPLAY_DATE_TIME:
00616                        SmartSwitch_SetBackLightColor(1,3,0);
00617                        GFX_DrawString(&BackBuffer,"Date/Time",0,0,&Font5x7);
00618                        GFX_DrawHline(&BackBuffer,0,PHYSICAL_DISPLAY_XRES-1,10);
00619                        GFX_DrawHline(&BackBuffer,0,PHYSICAL_DISPLAY_XRES-1,11);
00620                        GFX_DrawHline(&BackBuffer,0,PHYSICAL_DISPLAY_XRES-1,12);
00621                         
00622                        time(&CurrentTime_InSec);
00623                        strftime(DTBuf, 32, "%m.%d.%Y", localtime(&CurrentTime_InSec));
00624                        GFX_printf(&BackBuffer,0,16,&Font5x7,"%s",DTBuf);
00625                       
00626                        strftime(DTBuf, 32, "%H:%M:%S", localtime(&CurrentTime_InSec));
00627                        GFX_printf(&BackBuffer,0,24,&Font5x7,"%s",DTBuf);
00628                     break;
00629                     
00630                      case DISPLAY_BUFFER_STATS:
00631                      SmartSwitch_SetBackLightColor(3,3,3);
00632                      GFX_DrawString(&BackBuffer,"Buf Status",0,0,&Font5x7);
00633                      GFX_DrawHline(&BackBuffer,0,PHYSICAL_DISPLAY_XRES-1,10);
00634                      GFX_DrawHline(&BackBuffer,0,PHYSICAL_DISPLAY_XRES-1,11);
00635                      GFX_DrawHline(&BackBuffer,0,PHYSICAL_DISPLAY_XRES-1,12);
00636                      GFX_printf(&BackBuffer,0,16,&Font3x5,"R/W Diff:");
00637                      GFX_printf(&BackBuffer,0,24,&Font3x5,"%04d/%d",ReadWriteDifferential,DATA_BLOCK_SIZE);
00638                     break;
00639                     
00640                     case DISPLAY_FIRMWARE_VERSION:
00641                      SmartSwitch_SetBackLightColor(3,3,3);
00642                      GFX_DrawString(&BackBuffer,"Firmware Version",0,0,&Font3x5);
00643                      GFX_DrawHline(&BackBuffer,0,PHYSICAL_DISPLAY_XRES-1,10);
00644                      GFX_DrawHline(&BackBuffer,0,PHYSICAL_DISPLAY_XRES-1,11);
00645                      GFX_DrawHline(&BackBuffer,0,PHYSICAL_DISPLAY_XRES-1,12);
00646                      GFX_printf(&BackBuffer,19,20,&Font5x7,"%d.%d",FIRMWARE_VERSION_MAJOR,FIRMWARE_VERSION_MINOR);
00647                     break;
00648                     
00649                     case DISPLAY_ID:
00650                      SmartSwitch_SetBackLightColor(3,3,3);
00651                      GFX_DrawString(&BackBuffer,"ID",0,0,&Font3x5);
00652                      GFX_DrawHline(&BackBuffer,0,PHYSICAL_DISPLAY_XRES-1,10);
00653                      GFX_DrawHline(&BackBuffer,0,PHYSICAL_DISPLAY_XRES-1,11);
00654                      GFX_DrawHline(&BackBuffer,0,PHYSICAL_DISPLAY_XRES-1,12);
00655                      GFX_printf(&BackBuffer,0,20,&Font5x7,"%s",ID);
00656                     break;
00657                     
00658                     case DISPLAY_CARD_STATUS:
00659                                          
00660                       if(SDCardDetect == 1)
00661                       {
00662                         
00663                           switch(SystemState)
00664                           {
00665                             default:
00666                             case SYSTEM_STATE_IDLE:
00667                                 switch(LastBackLightColor)
00668                                  {
00669                                     default:
00670                                     case SMART_SWITCH_BACKLIGHT_GREEN:
00671                                          LastBackLightColor = SMART_SWITCH_BACKLIGHT_YELLOW;  
00672                                          SmartSwitch_SetBackLightColor2(LastBackLightColor);
00673                                     break;
00674                                     
00675                                     case SMART_SWITCH_BACKLIGHT_YELLOW:
00676                                         LastBackLightColor = SMART_SWITCH_BACKLIGHT_GREEN;
00677                                         SmartSwitch_SetBackLightColor2(LastBackLightColor);
00678                                     break;
00679                                   }
00680                                
00681                                
00682                               if(DataLogError == TRUE)
00683                               {
00684                                    GFX_DrawString(&BackBuffer,"Error!",0,0,&Font5x7); 
00685                                    GFX_DrawString(&BackBuffer,ErrorMsg,0,16,&Font3x5);
00686                               }  
00687                               else
00688                               { 
00689                                   GFX_DrawString(&BackBuffer,"SD Detected",0,16,&Font5x7);
00690                                   GFX_DrawString(&BackBuffer,"Idle....",0,0,&Font5x7);
00691                                   GFX_DrawString(&BackBuffer,"Not Logging",0,24,&Font5x7);    
00692                               }
00693                             break;
00694                          
00695                          
00696                             case SYSTEM_STATE_LOGGING:
00697                                 SmartSwitch_SetBackLightColor2(SMART_SWITCH_BACKLIGHT_GREEN);
00698                                
00699                                 GFX_DrawString(&BackBuffer,"Logging Data....",0,0,&Font5x7);
00700                                 GFX_DrawString(&BackBuffer,&CurrentLogFileName[4],0,16,&Font5x7);
00701                                 GFX_printf(&BackBuffer,0,26,&Font3x5,"Block: %d",DataBlocksWritten);
00702                                 
00703                             break;
00704                          }
00705                       }
00706                       else
00707                       {
00708                           GFX_DrawString(&BackBuffer,"No SD Card!",0,0,&Font5x7);
00709                           
00710                             switch(LastBackLightColor)
00711                             {
00712                                 default:
00713                                 case SMART_SWITCH_BACKLIGHT_RED:
00714                                      LastBackLightColor = SMART_SWITCH_BACKLIGHT_YELLOW;  
00715                                      SmartSwitch_SetBackLightColor2(LastBackLightColor);
00716                                 break;
00717                                 
00718                                 case SMART_SWITCH_BACKLIGHT_YELLOW:
00719                                     LastBackLightColor = SMART_SWITCH_BACKLIGHT_RED;
00720                                     SmartSwitch_SetBackLightColor2(LastBackLightColor);
00721                                 break;
00722                               }
00723                       } 
00724                     
00725                        GFX_DrawHline(&BackBuffer,0,PHYSICAL_DISPLAY_XRES-1,10);
00726                        GFX_DrawHline(&BackBuffer,0,PHYSICAL_DISPLAY_XRES-1,11);
00727                        GFX_DrawHline(&BackBuffer,0,PHYSICAL_DISPLAY_XRES-1,12);
00728                     
00729                     break;
00730                 }
00731              GFX_DumpRenderContextToPhysicalScreen(&BackBuffer);
00732         }
00733     }
00734 }
00735 
00736 
00737 void CheckSDCardStatus()
00738 {
00739     //Make sure that the SD card stays in while logging
00740     switch(SystemState)
00741     {
00742         case SYSTEM_STATE_LOGGING:
00743             if(SDCardDetect == 0)
00744             {
00745                 //Gracefully shut the logging system down.....
00746                 EnterSystemState(SYSTEM_STATE_IDLE);
00747             }
00748         break;
00749         
00750         default:
00751         break;
00752     } 
00753 }
00754 
00755 
00756 void LogData()
00757 {
00758     WORD i;
00759     int ElementsToWrite;
00760     UINT BytesWritten;
00761     
00762     if(RobotBusVoltageHR < 9)
00763     {
00764         EnterSystemState(SYSTEM_STATE_IDLE);
00765         return;
00766     }
00767     
00768     if(DataLogError == TRUE)
00769     {
00770         EnterSystemState(SYSTEM_STATE_IDLE);
00771     }
00772     else
00773     {
00774         if(MyDataBlock.ReadInPtr < MyDataBlock.WriteOutPtr)
00775         {
00776            ElementsToWrite =  MyDataBlock.ReadInPtr + (DATA_BLOCK_SIZE - MyDataBlock.WriteOutPtr);
00777         }
00778         else
00779         {
00780             ElementsToWrite = MyDataBlock.ReadInPtr - MyDataBlock.WriteOutPtr;
00781         }
00782         
00783         if(ElementsToWrite > WRITE_BLOCK_THRESH)
00784         {
00785                 for(i=0;i<ElementsToWrite;i++)
00786                 {
00787                     BinaryDataCachePtr += sprintf((char *)&BinaryDataCache[BinaryDataCachePtr],"%d,%.2f,%.2f\r\n",DataPointIndex,MyDataBlock.Voltage[MyDataBlock.WriteOutPtr],MyDataBlock.Current[MyDataBlock.WriteOutPtr]);
00788                     if(BinaryDataCachePtr>=BINARY_WRITE_CACHE_THRESHOLD)
00789                     {
00790                         EXT_LED0 = 1;  
00791                         f_write(&CurrentLogFileHandle,BinaryDataCache,BinaryDataCachePtr,&BytesWritten);
00792                         
00793                         BinaryDataCachePtr = 0;
00794                       
00795                         EXT_LED0=0;
00796                     }
00797                     DataPointIndex++;
00798                     MyDataBlock.WriteOutPtr++;
00799                     if(MyDataBlock.WriteOutPtr == DATA_BLOCK_SIZE)
00800                     {
00801                         MyDataBlock.WriteOutPtr = 0;
00802                     }
00803                 }
00804                 if(WritesSinceLastFlush > NUM_WRITES_BEFORE_FLUSH)
00805                  {
00806                             f_close(&CurrentLogFileHandle);
00807                             WritesSinceLastFlush = 0;
00808                             f_open(&CurrentLogFileHandle,&CurrentLogFileName[0],FA_WRITE | FA_OPEN_ALWAYS);
00809                             f_lseek(&CurrentLogFileHandle, CurrentLogFileHandle.fsize);
00810                  }
00811                DataBlocksWritten++;
00812       }
00813     }
00814 }
00815 
00816 
00817 
00818 void DisplayBootMsg()
00819 {
00820    PrintfEnqueue(&PCBackDoorTx,"\r\n\r\n");
00821    PrintfEnqueue(&PCBackDoorTx,".______     _______. __    __            ___      .______       __   \r\n");
00822    PrintfEnqueue(&PCBackDoorTx,"|   _  \\   /       ||  |  |  |          /   \\     |   _  \\     |  |  \r\n");
00823    PrintfEnqueue(&PCBackDoorTx,"|  |_)  | |   (----`|  |  |  |  ______ /  ^  \\    |  |_)  |    |  |  \r\n");   
00824    PrintfEnqueue(&PCBackDoorTx,"|   ___/   \\   \\    |  |  |  | |______/  /_\\  \\   |      /     |  |  \r\n");
00825    PrintfEnqueue(&PCBackDoorTx,"|  |   .----)   |   |  `--'  |       /  _____  \\  |  |\\  \\----.|  `----.\r\n");
00826    PrintfEnqueue(&PCBackDoorTx,"| _|   |_______/     \\______/       /__/     \\__\\ | _| `._____||_______|\r\n");
00827    PrintfEnqueue(&PCBackDoorTx,"---------------------------------------------------------------------------\r\n");
00828    PrintfEnqueue(&PCBackDoorTx,"HyPER MPMC Control Terminal\r\n\r\n>");
00829 }