DataTypes.c

00001 #include "mbed.h"
00002 #include "DataTypes.h"
00003 
00004 CHAR StringBuffer[256];
00005 
00006 SIGNED_WORD ByteStackPush(ByteStack * Stack,BYTE Val) {
00007     if (Stack->Ptr == Stack->Size-1) {
00008         return STACK_FULL;
00009     } else {
00010         Stack->Ptr++;
00011         Stack->StackSpace[Stack->Ptr] = Val;
00012         return STACK_PUSH_OK;
00013     }
00014 }
00015 
00016 SIGNED_WORD ByteStackPOP(ByteStack * Stack) {
00017     if (Stack->Ptr == 0) {
00018         return STACK_EMPTY;
00019     } else {
00020         Stack->Ptr--;
00021         return Stack->StackSpace[Stack->Ptr];
00022     }
00023 }
00024 
00025 SIGNED_BYTE BitStackPush(BitStack * Stack,BOOL Val) {
00026     WORD Offset;
00027     BYTE Mask;
00028 
00029     if (Stack->Ptr == Stack->Size-1) {
00030         return STACK_FULL;
00031     } else {
00032 
00033         Stack->Ptr++;
00034         Offset = (Stack->Ptr)>>3;
00035         Mask = 0x01<<(Stack->Ptr&0x07);
00036 
00037         if (Val) {
00038             Stack->StackSpace[Offset] |= Mask;
00039         } else {
00040             Stack->StackSpace[Offset] &= ~Mask;
00041         }
00042 
00043         return STACK_PUSH_OK;
00044     }
00045 }
00046 
00047 SIGNED_BYTE BitStackPop(BitStack * Stack) {
00048     WORD Offset;
00049     BYTE Mask;
00050 
00051     if (Stack->Ptr == 0) {
00052         return STACK_EMPTY;
00053     } else {
00054 
00055         Stack->Ptr++;
00056         Offset = (Stack->Ptr)>>3;
00057         Mask = 0x01<<(Stack->Ptr&0x07);
00058 
00059         if (Stack->StackSpace[Offset] | Mask) {
00060             return TRUE;
00061         } else {
00062             return FALSE;
00063         }
00064     }
00065 }
00066 
00067 #ifndef INLINE_BITPLANE_PUT
00068 void BitPlane_Put(BitPlane  * BP, WORD X,WORD Y, BOOL Value)
00069 {
00070     WORD Offset;
00071     BYTE Mask;
00072     
00073     Offset = (Y * ((BP->SizeX)>>3)) + (X>>3);
00074     Mask = 0x01 << (X & 0x07);
00075 
00076     if(Value)
00077     {
00078         BP->BitPlaneSpace[Offset] |= Mask;
00079     }
00080     else
00081     {
00082         BP->BitPlaneSpace[Offset] &= ~Mask;
00083     }
00084 }
00085 #endif
00086 
00087 #ifndef INLINE_BITPLANE_GET
00088 BOOL BitPlane_Get(BitPlane  * BP, WORD X,WORD Y)
00089 {
00090     WORD Offset;
00091     BYTE Mask;
00092  
00093     Offset = (Y * ((BP->SizeX)>>3)) + (X>>3);
00094     Mask = 0x01 << (X & 0x07);
00095 
00096     if((BP->BitPlaneSpace[Offset])&Mask)
00097     {
00098         return TRUE;
00099     }
00100     else
00101     {
00102         return FALSE;
00103     }
00104 }
00105 #endif
00106 void BitPlane_Clear(BitPlane  * BP) {
00107     WORD PlaneSpaceSize;
00108     WORD i;
00109 
00110     PlaneSpaceSize = ((BP->SizeX)>>3) * BP->SizeY;
00111 
00112     for (i=0;i<PlaneSpaceSize;i++) {
00113         BP->BitPlaneSpace[i] = 0;
00114     }
00115 }
00116 
00117 
00118 
00119 void InitByteQueue(ByteQueue *BQ,WORD Size,BYTE * Storage) {
00120     WORD i;
00121 
00122     BQ->QueueSize = Size;
00123     BQ->ReadPtr=0;
00124     BQ->WritePtr=0;
00125     BQ->QueueStorage = Storage;
00126 
00127     for (i=0;i<BQ->QueueSize;i++) {
00128         BQ->QueueStorage[i] = 0;
00129     }
00130 }
00131 
00132 WORD BytesInQueue(ByteQueue *BQ) {
00133     if (BQ->ReadPtr > BQ->WritePtr) {
00134         return (BQ->QueueSize - BQ->ReadPtr + BQ->WritePtr);
00135     } else if (BQ->WritePtr > BQ->ReadPtr) {
00136         return     (BQ->WritePtr - BQ->ReadPtr);
00137     } else {
00138         return 0;
00139     }
00140 }
00141 
00142 SIGNED_WORD ByteEnqueue(ByteQueue *BQ,BYTE Val) {
00143     if (BytesInQueue(BQ) == BQ->QueueSize) {
00144         return QUEUE_FULL;
00145     } else {
00146         BQ->QueueStorage[BQ->WritePtr] = Val;
00147         BQ->WritePtr++;
00148 
00149         if (BQ->WritePtr >= BQ->QueueSize) {
00150             BQ->WritePtr = 0;
00151         }
00152         return QUEUE_OK;
00153     }
00154 }
00155 
00156 SIGNED_WORD ByteArrayEnqueue(ByteQueue *BQ,BYTE *Buf,WORD Len) {
00157     WORD i;
00158     for (i=0;i<Len;i++) {
00159         ByteEnqueue(BQ,Buf[i]);
00160     }
00161     return QUEUE_OK;
00162 }
00163 
00164 SIGNED_WORD PrintfEnqueue(ByteQueue *BQ, const char *FormatString,...)
00165 {
00166  
00167      va_list argptr; 
00168      va_start(argptr,FormatString); 
00169      vsprintf((CHAR *)StringBuffer,FormatString,argptr);
00170      va_end(argptr);   
00171      
00172      ByteArrayEnqueue(BQ,(BYTE *)StringBuffer,strlen(StringBuffer));
00173            
00174     return QUEUE_OK;
00175 }
00176 
00177 
00178 
00179 
00180 SIGNED_WORD ByteDequeue(ByteQueue *BQ,BYTE *Val) {
00181 
00182     if (BytesInQueue(BQ) == 0) {
00183         return QUEUE_EMPTY;
00184     } else {
00185         *Val  = BQ->QueueStorage[BQ->ReadPtr];
00186 
00187         BQ->ReadPtr++;
00188 
00189         if (BQ->ReadPtr >= BQ->QueueSize) {
00190             BQ->ReadPtr = 0;
00191         }
00192         return QUEUE_OK;
00193     }
00194 }