Revision 3:d55665050fcb, committed 2012-09-28

Comitter:

rjc19

Date:

Fri Sep 28 15:41:36 2012 +0000

Parent:

2:f6e5fdf2f872

Commit message:

Working serial logger needs interface improvement

Changed in this revision

--- a/CODE/DataTypes.cpp	Fri Sep 21 19:01:33 2012 +0000
+++ b/CODE/DataTypes.cpp	Fri Sep 28 15:41:36 2012 +0000
@@ -1,208 +1,208 @@
-#include "System.h"
-
-CHAR StringBuffer[256];
-
-SIGNED_WORD ByteStackPush(ByteStack * Stack,BYTE Val) {
-    if (Stack->Ptr == Stack->Size-1) {
-        return STACK_FULL;
-    } else {
-        Stack->Ptr++;
-        Stack->StackSpace[Stack->Ptr] = Val;
-        return STACK_PUSH_OK;
-    }
-}
-
-SIGNED_WORD ByteStackPOP(ByteStack * Stack) {
-    if (Stack->Ptr == 0) {
-        return STACK_EMPTY;
-    } else {
-        Stack->Ptr--;
-        return Stack->StackSpace[Stack->Ptr];
-    }
-}
-
-SIGNED_BYTE BitStackPush(BitStack * Stack,BOOL Val) {
-    WORD Offset;
-    BYTE Mask;
-
-    if (Stack->Ptr == Stack->Size-1) {
-        return STACK_FULL;
-    } else {
-
-        Stack->Ptr++;
-        Offset = (Stack->Ptr)>>3;
-        Mask = 0x01<<(Stack->Ptr&0x07);
-
-        if (Val) {
-            Stack->StackSpace[Offset] |= Mask;
-        } else {
-            Stack->StackSpace[Offset] &= ~Mask;
-        }
-
-        return STACK_PUSH_OK;
-    }
-}
-
-SIGNED_BYTE BitStackPop(BitStack * Stack) {
-    WORD Offset;
-    BYTE Mask;
-
-    if (Stack->Ptr == 0) {
-        return STACK_EMPTY;
-    } else {
-
-        Stack->Ptr++;
-        Offset = (Stack->Ptr)>>3;
-        Mask = 0x01<<(Stack->Ptr&0x07);
-
-        if (Stack->StackSpace[Offset] | Mask) {
-            return TRUE;
-        } else {
-            return FALSE;
-        }
-    }
-}
-
-#ifndef INLINE_BITPLANE_PUT
-void BitPlane_Put(BitPlane  * BP, WORD X,WORD Y, BOOL Value)
-{
-    WORD Offset;
-    BYTE Mask;
-    
-    Offset = (Y * ((BP->SizeX)>>3)) + (X>>3);
-    Mask = 0x01 << (X & 0x07);
-
-    if(Value)
-    {
-        BP->BitPlaneSpace[Offset] |= Mask;
-    }
-    else
-    {
-        BP->BitPlaneSpace[Offset] &= ~Mask;
-    }
-}
-#endif
-
-#ifndef INLINE_BITPLANE_GET
-BOOL BitPlane_Get(BitPlane  * BP, WORD X,WORD Y)
-{
-    WORD Offset;
-    BYTE Mask;
- 
-    Offset = (Y * ((BP->SizeX)>>3)) + (X>>3);
-    Mask = 0x01 << (X & 0x07);
-
-    if((BP->BitPlaneSpace[Offset])&Mask)
-    {
-        return TRUE;
-    }
-    else
-    {
-        return FALSE;
-    }
-}
-#endif
-void BitPlane_Clear(BitPlane  * BP) {
-    WORD PlaneSpaceSize;
-    WORD i;
-
-    PlaneSpaceSize = ((BP->SizeX)>>3) * BP->SizeY;
-
-    for (i=0;i<PlaneSpaceSize;i++) {
-        BP->BitPlaneSpace[i] = 0;
-    }
-}
-
-
-
-void InitByteQueue(ByteQueue *BQ,WORD Size,BYTE * Storage) {
-    WORD i;
-
-    BQ->QueueSize = Size;
-    BQ->ReadPtr=0;
-    BQ->WritePtr=0;
-    BQ->QueueStorage = Storage;
-
-    for (i=0;i<BQ->QueueSize;i++) {
-        BQ->QueueStorage[i] = 0;
-    }
-}
-
-WORD BytesInQueue(ByteQueue *BQ) {
-    if (BQ->ReadPtr > BQ->WritePtr) {
-        return (BQ->QueueSize - BQ->ReadPtr + BQ->WritePtr);
-    } else if (BQ->WritePtr > BQ->ReadPtr) {
-        return     (BQ->WritePtr - BQ->ReadPtr);
-    } else {
-        return 0;
-    }
-}
-
-SIGNED_WORD ByteEnqueue(ByteQueue *BQ,BYTE Val) {
-    if (BytesInQueue(BQ) == BQ->QueueSize) {
-        return QUEUE_FULL;
-    } else {
-        BQ->QueueStorage[BQ->WritePtr] = Val;
-        BQ->WritePtr++;
-
-        if (BQ->WritePtr >= BQ->QueueSize) {
-            BQ->WritePtr = 0;
-        }
-        return QUEUE_OK;
-    }
-}
-
-SIGNED_WORD ByteArrayEnqueue(ByteQueue *BQ,BYTE *Buf,WORD Len) {
-    WORD i;
-    for (i=0;i<Len;i++) {
-        ByteEnqueue(BQ,Buf[i]);
-    }
-    return QUEUE_OK;
-}
-
-SIGNED_WORD PrintfEnqueue(ByteQueue *BQ, const char *FormatString,...)
-{
- 
- if(WeAreInNormalMode){
-     va_list argptr; 
-     va_start(argptr,FormatString); 
-     vsprintf((CHAR *)StringBuffer,FormatString,argptr);
-     va_end(argptr);   
-     
-     ByteArrayEnqueue(BQ,(BYTE *)StringBuffer,strlen(StringBuffer));
-  
-    }
-    return QUEUE_OK;
-}
-
-SIGNED_WORD PrintfLogEnqueue(ByteQueue *BQ, const char *FormatString,...)
-{
- 
-     va_list argptr; 
-     va_start(argptr,FormatString); 
-     vsprintf((CHAR *)StringBuffer,FormatString,argptr);
-     va_end(argptr);   
-     
-     ByteArrayEnqueue(BQ,(BYTE *)StringBuffer,strlen(StringBuffer));
-           
-    return QUEUE_OK;
-}
-
-
-
-SIGNED_WORD ByteDequeue(ByteQueue *BQ,BYTE *Val) {
-
-    if (BytesInQueue(BQ) == 0) {
-        return QUEUE_EMPTY;
-    } else {
-        *Val  = BQ->QueueStorage[BQ->ReadPtr];
-
-        BQ->ReadPtr++;
-
-        if (BQ->ReadPtr >= BQ->QueueSize) {
-            BQ->ReadPtr = 0;
-        }
-        return QUEUE_OK;
-    }
-}
-
+#include "System.h"
+
+CHAR StringBuffer[256];
+
+SIGNED_WORD ByteStackPush(ByteStack * Stack,BYTE Val) {
+    if (Stack->Ptr == Stack->Size-1) {
+        return STACK_FULL;
+    } else {
+        Stack->Ptr++;
+        Stack->StackSpace[Stack->Ptr] = Val;
+        return STACK_PUSH_OK;
+    }
+}
+
+SIGNED_WORD ByteStackPOP(ByteStack * Stack) {
+    if (Stack->Ptr == 0) {
+        return STACK_EMPTY;
+    } else {
+        Stack->Ptr--;
+        return Stack->StackSpace[Stack->Ptr];
+    }
+}
+
+SIGNED_BYTE BitStackPush(BitStack * Stack,BOOL Val) {
+    WORD Offset;
+    BYTE Mask;
+
+    if (Stack->Ptr == Stack->Size-1) {
+        return STACK_FULL;
+    } else {
+
+        Stack->Ptr++;
+        Offset = (Stack->Ptr)>>3;
+        Mask = 0x01<<(Stack->Ptr&0x07);
+
+        if (Val) {
+            Stack->StackSpace[Offset] |= Mask;
+        } else {
+            Stack->StackSpace[Offset] &= ~Mask;
+        }
+
+        return STACK_PUSH_OK;
+    }
+}
+
+SIGNED_BYTE BitStackPop(BitStack * Stack) {
+    WORD Offset;
+    BYTE Mask;
+
+    if (Stack->Ptr == 0) {
+        return STACK_EMPTY;
+    } else {
+
+        Stack->Ptr++;
+        Offset = (Stack->Ptr)>>3;
+        Mask = 0x01<<(Stack->Ptr&0x07);
+
+        if (Stack->StackSpace[Offset] | Mask) {
+            return TRUE;
+        } else {
+            return FALSE;
+        }
+    }
+}
+
+#ifndef INLINE_BITPLANE_PUT
+void BitPlane_Put(BitPlane  * BP, WORD X,WORD Y, BOOL Value)
+{
+    WORD Offset;
+    BYTE Mask;
+    
+    Offset = (Y * ((BP->SizeX)>>3)) + (X>>3);
+    Mask = 0x01 << (X & 0x07);
+
+    if(Value)
+    {
+        BP->BitPlaneSpace[Offset] |= Mask;
+    }
+    else
+    {
+        BP->BitPlaneSpace[Offset] &= ~Mask;
+    }
+}
+#endif
+
+#ifndef INLINE_BITPLANE_GET
+BOOL BitPlane_Get(BitPlane  * BP, WORD X,WORD Y)
+{
+    WORD Offset;
+    BYTE Mask;
+ 
+    Offset = (Y * ((BP->SizeX)>>3)) + (X>>3);
+    Mask = 0x01 << (X & 0x07);
+
+    if((BP->BitPlaneSpace[Offset])&Mask)
+    {
+        return TRUE;
+    }
+    else
+    {
+        return FALSE;
+    }
+}
+#endif
+void BitPlane_Clear(BitPlane  * BP) {
+    WORD PlaneSpaceSize;
+    WORD i;
+
+    PlaneSpaceSize = ((BP->SizeX)>>3) * BP->SizeY;
+
+    for (i=0;i<PlaneSpaceSize;i++) {
+        BP->BitPlaneSpace[i] = 0;
+    }
+}
+
+
+
+void InitByteQueue(ByteQueue *BQ,WORD Size,BYTE * Storage) {
+    WORD i;
+
+    BQ->QueueSize = Size;
+    BQ->ReadPtr=0;
+    BQ->WritePtr=0;
+    BQ->QueueStorage = Storage;
+
+    for (i=0;i<BQ->QueueSize;i++) {
+        BQ->QueueStorage[i] = 0;
+    }
+}
+
+WORD BytesInQueue(ByteQueue *BQ) {
+    if (BQ->ReadPtr > BQ->WritePtr) {
+        return (BQ->QueueSize - BQ->ReadPtr + BQ->WritePtr);
+    } else if (BQ->WritePtr > BQ->ReadPtr) {
+        return     (BQ->WritePtr - BQ->ReadPtr);
+    } else {
+        return 0;
+    }
+}
+
+SIGNED_WORD ByteEnqueue(ByteQueue *BQ,BYTE Val) {
+    if (BytesInQueue(BQ) == BQ->QueueSize) {
+        return QUEUE_FULL;
+    } else {
+        BQ->QueueStorage[BQ->WritePtr] = Val;
+        BQ->WritePtr++;
+
+        if (BQ->WritePtr >= BQ->QueueSize) {
+            BQ->WritePtr = 0;
+        }
+        return QUEUE_OK;
+    }
+}
+
+SIGNED_WORD ByteArrayEnqueue(ByteQueue *BQ,BYTE *Buf,WORD Len) {
+    WORD i;
+    for (i=0;i<Len;i++) {
+        ByteEnqueue(BQ,Buf[i]);
+    }
+    return QUEUE_OK;
+}
+
+SIGNED_WORD PrintfEnqueue(ByteQueue *BQ, const char *FormatString,...)
+{
+ 
+ if(WeAreInNormalMode){
+     va_list argptr; 
+     va_start(argptr,FormatString); 
+     vsprintf((CHAR *)StringBuffer,FormatString,argptr);
+     va_end(argptr);   
+     
+     ByteArrayEnqueue(BQ,(BYTE *)StringBuffer,strlen(StringBuffer));
+  
+    }
+    return QUEUE_OK;
+}
+
+SIGNED_WORD PrintfLogEnqueue(ByteQueue *BQ, const char *FormatString,...)
+{
+ 
+     va_list argptr; 
+     va_start(argptr,FormatString); 
+     vsprintf((CHAR *)StringBuffer,FormatString,argptr);
+     va_end(argptr);   
+     
+     ByteArrayEnqueue(BQ,(BYTE *)StringBuffer,strlen(StringBuffer));
+           
+    return QUEUE_OK;
+}
+
+
+
+SIGNED_WORD ByteDequeue(ByteQueue *BQ,BYTE *Val) {
+
+    if (BytesInQueue(BQ) == 0) {
+        return QUEUE_EMPTY;
+    } else {
+        *Val  = BQ->QueueStorage[BQ->ReadPtr];
+
+        BQ->ReadPtr++;
+
+        if (BQ->ReadPtr >= BQ->QueueSize) {
+            BQ->ReadPtr = 0;
+        }
+        return QUEUE_OK;
+    }
+}
+

--- a/CODE/Serial.cpp	Fri Sep 21 19:01:33 2012 +0000
+++ b/CODE/Serial.cpp	Fri Sep 28 15:41:36 2012 +0000
@@ -16,7 +16,7 @@
     InitByteQueue(&PCBackDoorTx,PC_BACKDOOR_TX_QUEUE_SIZE,&PCBackDoorTx_Queue_Storage[0]);
     InitByteQueue(&PCBackDoorRx,PC_BACKDOOR_RX_QUEUE_SIZE,&PCBackDoorRx_Queue_Storage[0]);
     
-    PCBackDoor.baud(57600);
+    PCBackDoor.baud(9600);
     PCBackDoor.format(8,Serial::None,1);  
  
     

--- a/CODE/System.cpp	Fri Sep 21 19:01:33 2012 +0000
+++ b/CODE/System.cpp	Fri Sep 28 15:41:36 2012 +0000
@@ -66,7 +66,7 @@
 BOOL InitDataLog();
 BOOL DataLogError;
 CHAR *ErrorMsg;
-
+WORD SerialCount=0;
 void CreateLogFileName();
 
 FATFS MyFileSystem;
@@ -147,6 +147,7 @@
         case SYSTEM_STATE_SERIAL_LOGGING:
             if(InitSerialDataLog() == FALSE){
                 PrintfLogEnqueue(&PCBackDoorTx,"%cS",SERIALSPEED);
+                SerialCount=0;
                 SystemState = NextState;
             }
             else{
@@ -601,22 +602,21 @@
 
                 case DISPLAY_SERIAL_STATUS:
  
-                    SmartSwitch_SetBrightnss(LastSerialBrightness);
-                    SmartSwitch_SetBackLightColor(2,0,2);
+                    //SmartSwitch_SetBrightnss(LastSerialBrightness);
+                    SmartSwitch_SetBackLightColor(3,0,3);
                     GFX_DrawString(&BackBuffer,"Serial Log",0,0,&Font5x7);
                     GFX_DrawHline(&BackBuffer,0,PHYSICAL_DISPLAY_XRES-1,10);
                     GFX_DrawHline(&BackBuffer,0,PHYSICAL_DISPLAY_XRES-1,11);
                     GFX_DrawHline(&BackBuffer,0,PHYSICAL_DISPLAY_XRES-1,12);
-                    GFX_printf(&BackBuffer,0,16,&Font5x7,"Rate %s",&SpeedString[0]);
-                    TranslateToText();
+                     TranslateToText();
                     if(SystemState != SYSTEM_STATE_SERIAL_LOGGING){
+                        GFX_printf(&BackBuffer,0,16,&Font5x7,"Rate %s",&SpeedString[0]);
                         GFX_printf(&BackBuffer,0,24,&Font5x7,"Not Logging");
-                        LastSerialBrightness=7;
                     }
                     else{   //we are logging
-                        GFX_printf(&BackBuffer,0,24,&Font5x7,"Logging");  
-                        if(LastSerialBrightness == 7)LastSerialBrightness=3;
-                        else LastSerialBrightness=7;                 
+                        GFX_printf(&BackBuffer,0,16,&Font5x7,"C-%d",SerialCount);
+                        GFX_printf(&BackBuffer,0,24,&Font5x7,"Logging"); 
+                        SmartSwitch_SetBackLightColor(0,0,3); 
                     }                        
                     break;
 

--- a/CODE/Terminal.cpp	Fri Sep 21 19:01:33 2012 +0000
+++ b/CODE/Terminal.cpp	Fri Sep 28 15:41:36 2012 +0000
@@ -344,6 +344,8 @@
                     }
                 }
                 SerialLineBufferPtr=0; //Always do this so we don't overflow
+                SerialCount++;
+                if(SerialCount > 5000)SerialCount=0;
                 break;
             default:
                 AngleCount=0;

--- a/CODE/chan_fat_fs/diskio.cpp	Fri Sep 21 19:01:33 2012 +0000
+++ b/CODE/chan_fat_fs/diskio.cpp	Fri Sep 28 15:41:36 2012 +0000
@@ -158,7 +158,8 @@
     rc = Host_EnumDev();       /* Enumerate the device connected                                            */
     if (rc != OK)
     {
-        fprintf(stderr, "Could not enumerate device: %d\n", rc);
+        //fprintf(stderr, "Could not enumerate device: %d\n", rc);
+        PrintfEnqueue(&PCBackDoorTx,"Could not enumerate device: %d\n", rc);
         return rc;
     }
         
@@ -167,11 +168,13 @@
     rc = MS_Init( &_blkSize, &_numBlks, inquiryResult );
     if (rc != OK)
     {
-        fprintf(stderr, "Could not initialize mass storage interface: %d\n", rc);
+        //fprintf(stderr, "Could not initialize mass storage interface: %d\n", rc);
+        PrintfEnqueue(&PCBackDoorTx,"Could not initialize mass storage interface: %d\n", rc);
         return rc;
     }
-    printf("Successfully initialized mass storage interface; %d blocks of size %d\n", _numBlks, _blkSize);
-    print_inquiry(inquiryResult);
+    //printf("Successfully initialized mass storage interface; %d blocks of size %d\n", _numBlks, _blkSize);
+    PrintfEnqueue(&PCBackDoorTx,"Successfully initialized mass storage interface; %d blocks of size %d\n", _numBlks, _blkSize);
+    //print_inquiry(inquiryResult);
     // FATFileSystem supports only 512-byte blocks
     return _blkSize == 512 ? OK : 1;
 }

--- a/HEADERS/FIRMWARE_VERSION.h	Fri Sep 21 19:01:33 2012 +0000
+++ b/HEADERS/FIRMWARE_VERSION.h	Fri Sep 28 15:41:36 2012 +0000
@@ -2,7 +2,7 @@
 #define FIRMWARE_VERSION_H
 
 #define FIRMWARE_VERSION_MAJOR  (1)
-#define FIRMWARE_VERSION_MINOR  (0)
+#define FIRMWARE_VERSION_MINOR  (5)
 
 #endif
 

--- a/HEADERS/System.h	Fri Sep 21 19:01:33 2012 +0000
+++ b/HEADERS/System.h	Fri Sep 28 15:41:36 2012 +0000
@@ -37,7 +37,7 @@
 extern FIL  CurrentLogFileHandle;
 extern BYTE DisplayMode;
 extern UINT LinesWritten;
-
+extern WORD SerialCount;
 #define NUMBEROFLINESBEFORESYNC 10
 
 #define DATA_BLOCK_SIZE    1024