WebSVN - NaviCtrl - Diff - Rev 101 and 110

 #include <stdio.h>
 #include <stdarg.h>
 #include <string.h>
-#include "91x_lib.h"
-#include "ramfunc.h"
+#include "91x_lib.h"
 #include "menu.h"
 #include "printf_P.h"
 #include "GPS.h"
 #include "i2c.h"
 #include "uart0.h"
 #include "uart1.h"
 #include "uart2.h"
-#include "timer.h"
-#include "usb.h"
+#include "timer.h"
 #include "main.h"
 #include "waypoints.h"
-#include "GPS.h"
-// slave addresses
-#define FC_ADDRESS 1
-#define NC_ADDRESS 2
-#define MK3MAG_ADDRESS 3
+#include "mkprotocol.h"
 #define FALSE   0
         u8 SWPatch;
         u8 Reserved[5];
 }  __attribute__((packed)) UART_VersionInfo_t;
-u8 Request_SendFollowMe         = FALSE;
+u8 UART1_Request_VersionInfo    = FALSE;
-u8 Request_VerInfo                      = FALSE;
+u8 UART1_Request_SendFollowMe   = FALSE;
-u8 Request_ExternalControl      = FALSE;
+u8 UART1_Request_ExternalControl= FALSE;
-u8 Request_Display                      = FALSE;
+u8 UART1_Request_Display                = FALSE;
-u8 Request_Display1             = FALSE;
+u8 UART1_Request_Display1               = FALSE;
-u8 Request_DebugData            = FALSE;
-u8 Request_DebugLabel           = 255;
+u8 UART1_Request_DebugData              = FALSE;
-u8 Request_ChannelOnly          = FALSE;
+u8 UART1_Request_DebugLabel             = 255;
-u8 Request_NaviData                     = FALSE;
+u8 UART1_Request_NaviData               = FALSE;
-u8 Request_ErrorMessage     = FALSE;
+u8 UART1_Request_ErrorMessage   = FALSE;
-u8 Request_NewWaypoint          = FALSE;
+u8 UART1_Request_NewWaypoint    = FALSE;
-u8 Request_ReadWaypoint         = 255;
+u8 UART1_Request_ReadWaypoint   = 255;
-u8 Request_Data3D                   = FALSE;
+u8 UART1_Request_Data3D             = FALSE;
-u8 Request_Echo                 = FALSE;
+u8 UART1_Request_Echo               = FALSE;
+u8 DisplayLine = 0;
-u8 DisplayLine = 0;
+UART_TypeDef *DebugUART = UART1;
-UART_TypeDef *DebugUART = UART1;
+#define UART1_BAUD_RATE 57600           //Baud Rate for the serial interfaces
+// the tx buffer
-volatile u8 txd_buffer[TXD_BUFFER_LEN];
+#define UART1_TX_BUFFER_LEN  150
-volatile u8 rxd_buffer_locked = FALSE;
+u8 UART1_tbuffer[UART1_TX_BUFFER_LEN];
-volatile u8 rxd_buffer[RXD_BUFFER_LEN];
+Buffer_t UART1_tx_buffer;
-volatile u8 txd_complete = TRUE;
+// the rx buffer
-volatile u8 ReceivedBytes = 0;
+#define UART1_RX_BUFFER_LEN  150
-volatile u8 CntCrcError = 0;
+u8 UART1_rbuffer[UART1_RX_BUFFER_LEN];
-volatile u8 *pRxData = NULL;
-volatile u8 RxDataLen = 0;
+Buffer_t UART1_rx_buffer;
 volatile u8 SerialLinkOkay = 0;
 volatile u8 SerialLinkOkay = 0;
 u8 text[100];
 u8 text[100];
 u8 PcAccess = 100;
-u8 MotorTest[4] = {0,0,0,0};
+u8 PcAccess = 100;
 u8 ConfirmFrame = 0;
 DebugOut_t DebugOut;
 ExternControl_t ExternControl;
 UART_VersionInfo_t UART_VersionInfo;
 NaviData_t NaviData;
 Waypoint_t FollowMe;
-Data3D_t Data3D;
-u16 Echo; // 2 bytes recieved will be sent back as echo
 Data3D_t Data3D;
-u32 DebugData_Timer;
+u16 Echo; // 2 bytes recieved will be sent back as echo
 u32 DebugData_Interval = 5000;  // in ms
-u32 NaviData_Timer;
+u32 UART1_DebugData_Timer;
         */
         UART_StructInit(&UART_InitStructure);
         UART_InitStructure.UART_WordLength =                    UART_WordLength_8D;
         UART_InitStructure.UART_StopBits =                              UART_StopBits_1;
         UART_InitStructure.UART_Parity =                                UART_Parity_No ;
-        UART_InitStructure.UART_BaudRate =                              BAUD_RATE;
+        UART_InitStructure.UART_BaudRate =                              UART1_BAUD_RATE;
         UART_InitStructure. UART_HardwareFlowControl =  UART_HardwareFlowControl_None;
         UART_InitStructure.UART_Mode =                                  UART_Mode_Tx_Rx;
         UART_InitStructure.UART_FIFO =                                  UART_FIFO_Enable;
         UART_InitStructure.UART_TxFIFOLevel =                   UART_FIFOLevel_1_2;
         UART_InitStructure.UART_RxFIFOLevel =                   UART_FIFOLevel_1_2;
         // configure the uart 1 interupt line as an IRQ with priority 4 (0 is highest)
         VIC_Config(UART1_ITLine, VIC_IRQ, 4);
         // enable the uart 1 IRQ
         VIC_ITCmd(UART1_ITLine, ENABLE);
         // initialize the debug timer
-        DebugData_Timer = SetDelay(DebugData_Interval);
+        UART1_DebugData_Timer = SetDelay(UART1_DebugData_Interval);
-        NaviData_Timer = SetDelay(NaviData_Interval)+500;
+        UART1_NaviData_Timer = SetDelay(UART1_NaviData_Interval)+500;
-        // unlock rxd_buffer
+        // initialize txd buffer
+        UART1_tx_buffer.pData = UART1_tbuffer;
+        UART1_tx_buffer.Size = UART1_TX_BUFFER_LEN;
+        UART1_tx_buffer.Position = 0;
-        rxd_buffer_locked = FALSE;
+        UART1_tx_buffer.Locked = FALSE;
-        pRxData = NULL;
+        // initialize rxd buffer
-        RxDataLen = 0;
+        UART1_rx_buffer.pData = UART1_rbuffer;
+        UART1_rx_buffer.Size = UART1_RX_BUFFER_LEN;
-        // no bytes to send
+        UART1_rx_buffer.Position = 0;
-        txd_complete = TRUE;
+        UART1_rx_buffer.Locked = FALSE;
         // Fill Version Info Structure
         UART_VersionInfo.SWMajor = VERSION_MAJOR;
         UART_VersionInfo.SWMinor = VERSION_MINOR;
         UART_VersionInfo.SWPatch = VERSION_PATCH;
         UART_VersionInfo.ProtoMajor = VERSION_SERIAL_MAJOR;
         UART_VersionInfo.ProtoMinor = VERSION_SERIAL_MINOR;
         NaviData.Version = NAVIDATA_VERSION;
-        SerialPutString("\r\nUART1 init...ok");
+        UART1_PutString("\r\nUART1 init...ok");
+}
 /****************************************************************/
-/*               USART1 receiver ISR                            */
-/****************************************************************/
-void UART1_IRQHandler(void)
 /*               USART1 receiver ISR                            */
-        static u16 crc;
+/****************************************************************/
-        static u8 ptr_rxd_buffer = 0;
+void UART1_IRQHandler(void)
         static u8 crc1, crc2;
                 // if debug UART is not UART1
                 if (DebugUART != UART1)
                 {       // forward received data to the debug UART tx buffer
                         while(UART_GetFlagStatus(UART1, UART_FLAG_RxFIFOEmpty) != SET)
+                        {
-                                // wait for space in the tx buffer of the DebugUART
-                                while(UART_GetFlagStatus(DebugUART, UART_FLAG_TxFIFOFull) == SET) {};
                                 // move the byte from the rx buffer of UART1 to the tx buffer of DebugUART
                                 c = UART_ReceiveData(UART1);
                                 // check for abort condition (ESC ESC 0x55 0xAA 0x00)
                                                         UART0_Connect_to_MKGPS();
+                                                   }
                                           abortState = 0;
                                                 break;
+                                }
+                                // if the Debug uart is not UART1rederect input to the Debug UART
+                                if (DebugUART != UART1)
+                                {
+                                        // wait for space in the tx buffer of the DebugUART
+                                        while(UART_GetFlagStatus(DebugUART, UART_FLAG_TxFIFOFull) == SET) {};
+                                        // move byte to the tx fifi of the debug uart
-                                if (DebugUART != UART1) UART_SendData(DebugUART, c);
+                                        UART_SendData(DebugUART, c);
+                                }
+                        }
+                }
                 else  // DebugUART == UART1 (normal operation)
+                {
-                        while ((UART_GetFlagStatus(UART1, UART_FLAG_RxFIFOEmpty) != SET) && (!rxd_buffer_locked))
+                        while(UART_GetFlagStatus(UART1, UART_FLAG_RxFIFOEmpty) != SET)
                         { // some byes in the fifo and rxd buffer not locked
                             // get byte from fifo
                         c = UART_ReceiveData(UART1);
-                                if((ptr_rxd_buffer == 0) && (c == '#')) // if rxd buffer is empty and syncronisation character is received
-                                {
-                                        rxd_buffer[ptr_rxd_buffer++] = c; // copy 1st byte to buffer
-                                        crc = c; // init crc
-                                }
-                                #if 0
-                                else if (ptr_rxd_buffer == 1) // handle address
-                                {
-                                        rxd_buffer[ptr_rxd_buffer++] = c; // copy byte to rxd buffer
-                                        crc += c; // update crc
-                                }
-                                #endif
-                                else if (ptr_rxd_buffer < RXD_BUFFER_LEN) // rxd buffer not full
-                                {
-                                        if (c != '\r') // no termination character received
-                                        {
-                                                rxd_buffer[ptr_rxd_buffer++] = c; // copy byte to rxd buffer
-                                                crc += c; // update crc
-                                        }
-                                        else // termination character received
-                                        {
-                                                // the last 2 bytes are no subject for checksum calculation
-                                                // they are the checksum itself
-                                                crc -= rxd_buffer[ptr_rxd_buffer-2];
-                                                crc -= rxd_buffer[ptr_rxd_buffer-1];
+                                MKProtocol_CollectSerialFrame(&UART1_rx_buffer, c);
-                                                // calculate checksum from transmitted data
-                                                crc %= 4096;
-                                                crc1 = '=' + crc / 64;
-                                                crc2 = '=' + crc % 64;
-                                                // compare checksum to transmitted checksum bytes
-                                                if((crc1 == rxd_buffer[ptr_rxd_buffer-2]) && (crc2 == rxd_buffer[ptr_rxd_buffer-1]))
-                                                {   // checksum valid
-                                                        rxd_buffer_locked = TRUE;               // lock the rxd buffer
-                                                        ReceivedBytes = ptr_rxd_buffer + 1;     // store number of received bytes
-                                                        rxd_buffer[ptr_rxd_buffer] = '\r';      // set termination character
-                                                        // if 2nd byte is an 'R' start bootloader
-                                                        if(rxd_buffer[2] == 'R')
-                                                        {
-                                                                PowerOff();
-                                                                VIC_DeInit();
-                                                                Execute_Bootloader(); // Reset-Commando - Bootloader starten
-                                                        }
-                                                } // eof checksum valid
-                                                else
-                                                {       // checksum invalid
-                                                        rxd_buffer_locked = FALSE; // unlock rxd buffer
-                                                }  // eof checksum invalid
-                                                ptr_rxd_buffer = 0; // reset rxd buffer pointer
-                                        } // eof termination character received
-                                } // rxd buffer not full
-                                else // rxd buffer overrun
-                                {
-                                        ptr_rxd_buffer = 0; // reset rxd buffer pointer
-                                        rxd_buffer_locked = FALSE; // unlock rxd buffer
-                                } // eof rxd buffer overrrun
                         } // some byes in the fifo and rxd buffer not locked
                 } // eof DebugUart = UART1
+        }
+}
-/**************************************************************/
-/*         Transmit tx buffer via debug uart                  */
-/**************************************************************/
-void UART1_Transmit(void)
-{
-        u8 tmp_tx;
-        // if something has to be send and the txd fifo is not full
-        if((!txd_complete) && (UART_GetFlagStatus(UART1, UART_FLAG_TxFIFOFull) == RESET))
-        {
-                tmp_tx = txd_buffer[ptr_txd_buffer]; // read byte from txd buffer
-                // if terminating character or end of txd buffer reached
-                if((tmp_tx == '\r') || (ptr_txd_buffer == TXD_BUFFER_LEN))
-                {
-                        ptr_txd_buffer = 0;     // reset txd buffer pointer
-                        txd_complete = TRUE;// set complete flag
-                }
-                UART_SendData(UART1, tmp_tx); // put character to txd fifo
-                // set pointer to next byte
-                ptr_txd_buffer++;
-        }
-}
-/**************************************************************/
-/* Add CRC and initiate transmission via debug uart           */
-/**************************************************************/
-void AddCRC(u16 datalen)
-{
-        u16 tmpCRC = 0, i;
-        for(i = 0; i < datalen; i++)
-        {
-                tmpCRC += txd_buffer[i];
-        }
-        tmpCRC %= 4096;
-        txd_buffer[i++] = '=' + tmpCRC / 64;
-        txd_buffer[i++] = '=' + tmpCRC % 64;
-        txd_buffer[i++] = '\r';
-        ptr_txd_buffer = 0;
-        txd_complete = FALSE;
-        UART_SendData(UART1, txd_buffer[ptr_txd_buffer++]);     // send first byte, to be continued in the txd irq
-}
-/**************************************************************/
-/* Code output data                                           */
-/**************************************************************/
-void SendOutData(u8 cmd, u8 Address, u8 numofbuffers , ...) //u8 *data, u8 len, ....
-{
-        va_list ap;
-        u16 pt = 0;
-        u8 a,b,c;
-        u8 ptr = 0;
-        u8* pdata = NULL;
-        int len = 0;
-        txd_buffer[pt++] = '#';                         // Start character
-        txd_buffer[pt++] = 'a' + Address;       // Address (a=0; b=1,...)
-        txd_buffer[pt++] = cmd;                         // Command
-        va_start(ap, numofbuffers);
-        if(numofbuffers)
-        {
-                pdata = va_arg(ap, u8*);
-                len = va_arg(ap, int);
-                ptr = 0;
-                numofbuffers--;
-        }
-        while(len)
-        {
-                if(len)
-                {
-                        a = pdata[ptr++];
-                        len--;
-                        if((!len) && numofbuffers) // try to jump to next buffer
-                        {
-                                pdata = va_arg(ap, u8*);
-                                len = va_arg(ap, int);
-                                ptr = 0;
-                                numofbuffers--;
-                        }
-                }
-                else a = 0;
-                if(len)
-                {
-                        b = pdata[ptr++];
-                        len--;
-                        if((!len) && numofbuffers) // try to jump to next buffer
-                        {
-                                pdata = va_arg(ap, u8*);
-                                len = va_arg(ap, int);
-                                ptr = 0;
-                                numofbuffers--;
-                        }
-                }
-                else b = 0;
-                if(len)
-                {
-                        c = pdata[ptr++];
-                        len--;
-                        if((!len) && numofbuffers) // try to jump to next buffer
-                        {
-                                pdata = va_arg(ap, u8*);
-                                len = va_arg(ap, int);
-                                ptr = 0;
-                                numofbuffers--;
-                        }
-                }
-                else c = 0;
-                txd_buffer[pt++] = '=' + (a >> 2);
-                txd_buffer[pt++] = '=' + (((a & 0x03) << 4) | ((b & 0xf0) >> 4));
-                txd_buffer[pt++] = '=' + (((b & 0x0f) << 2) | ((c & 0xc0) >> 6));
-                txd_buffer[pt++] = '=' + ( c & 0x3f);
-        }
-        va_end(ap);
-        AddCRC(pt);     // add checksum after data block and initates the transmission
-}
-/**************************************************************/
-/* Decode data                                                */
-/**************************************************************/
-void Decode64(void)
-{
-        u8 a,b,c,d;
-        u8 x,y,z;
-        u8 ptrIn = 3; // start with first data byte in rx buffer
-        u8 ptrOut = 3;
-        u8 len = ReceivedBytes - 6;      // must be a multiple of 4 (3 bytes at begin and 3 bytes at end are no payload )
-        while(len)
-        {
-                a = rxd_buffer[ptrIn++] - '=';
-                b = rxd_buffer[ptrIn++] - '=';
-                c = rxd_buffer[ptrIn++] - '=';
-                d = rxd_buffer[ptrIn++] - '=';
-                //if(ptrIn > ReceivedBytes - 3) break;
-                x = (a << 2) | (b >> 4);
-                y = ((b & 0x0f) << 4) | (c >> 2);
-                z = ((c & 0x03) << 6) | d;
-                if(len--) rxd_buffer[ptrOut++] = x; else break;
-                if(len--) rxd_buffer[ptrOut++] = y; else break;
-                if(len--) rxd_buffer[ptrOut++] = z; else break;
-        }
-        pRxData = &rxd_buffer[3];
-        RxDataLen = ptrOut - 3;
-}
 /**************************************************************/
 /* Process incomming data from debug uart                     */
 /**************************************************************/
 void UART1_ProcessRxData(void)
+{
         SerialMsg_t SerialMsg;
         // if data in the rxd buffer are not locked immediately return
-        if((!rxd_buffer_locked) || (DebugUART != UART1) ) return;
+        if((UART1_rx_buffer.Locked == FALSE) || (DebugUART != UART1) ) return;
         Waypoint_t * pWaypoint = NULL;
         PcAccess = 255;
-        Decode64(); // decode data block in rxd buffer
+        MKProtocol_DecodeSerialFrame(&UART1_rx_buffer, &SerialMsg); // decode serial frame in rxd buffer
-    if(rxd_buffer[2] != 'z') SerialLinkOkay = 250;               // reset SerialTimeout, but not in case of the "ping"
+    if(SerialMsg.CmdID != 'z') SerialLinkOkay = 250;      // reset SerialTimeout, but not in case of the "ping"
-        switch(rxd_buffer[1] - 'a') // check for Slave Address
+        switch(SerialMsg.Address) // check for Slave Address
         {
                 case NC_ADDRESS:  // own Slave Address
-                switch(rxd_buffer[2])
+                switch(SerialMsg.CmdID)
                 {
                         case 'z': // connection checker
-                                memcpy(&Echo, (u8*)pRxData, sizeof(Echo)); // copy echo pattern
+                                memcpy(&Echo, SerialMsg.pData, sizeof(Echo)); // copy echo pattern
-                                Request_Echo = TRUE;
+                                UART1_Request_Echo = TRUE;
                                 break;
                         case 'e': // request for the text of the error status
-                                Request_ErrorMessage = TRUE;
+                                UART1_Request_ErrorMessage = TRUE;
                                 break;
                         case 's'://  new target position
-                                pWaypoint = (Waypoint_t*)&pRxData[0];
+                                pWaypoint = (Waypoint_t*)SerialMsg.pData;
                                 BeepTime = 300;
                                 if(pWaypoint->Position.Status == NEWDATA)
+                                {
                                         WPList_Clear(); // empty WPList
                                         WPList_Append(pWaypoint);
                                         GPS_pWaypoint = WPList_Begin();
+                                }
                                 break;
                         case 'u': // redirect debug uart
-                                switch(pRxData[0])
+                                switch(SerialMsg.pData[0])
                                                 break;
+                                }
                                 break;
                         case 'w'://  Append Waypoint to List
-                                pWaypoint = (Waypoint_t*)&pRxData[0];
+                                pWaypoint = (Waypoint_t*)SerialMsg.pData;
                                 if(pWaypoint->Position.Status == INVALID)
                                 {  // clear WP List
                                         WPList_Clear();
                                         GPS_pWaypoint = WPList_Begin();
-                                        //SerialPutString("\r\nClear WP List\r\n");
+                                        //UART1_PutString("\r\nClear WP List\r\n");
+                                }
                                 else if (pWaypoint->Position.Status == NEWDATA)
                                 {  // app current WP to the list
                                         WPList_Append(pWaypoint);
                                         BeepTime = 500;
-                                        //SerialPutString("\r\nAdd WP to List\r\n");
+                                        //UART1_PutString("\r\nAdd WP to List\r\n");
                                 }
-                                Request_NewWaypoint = TRUE;
+                                UART1_Request_NewWaypoint = TRUE;
                                 break;
                         case 'x'://  Read Waypoint from List
-                                Request_ReadWaypoint = pRxData[0];
+                                UART1_Request_ReadWaypoint = SerialMsg.pData[0];
                                 break;
                         default:
                                 // unsupported command recieved
                                 break;
                 } // case NC_ADDRESS
                 // "break;" is missing here to fall thru to the common commands
                 default:  // and any other Slave Address
-                switch(rxd_buffer[2]) // check CmdID
+                switch(SerialMsg.CmdID) // check CmdID
+                {
                         case 'a':// request for the labels of the analog debug outputs
-                                Request_DebugLabel = pRxData[0];
+                                UART1_Request_DebugLabel = SerialMsg.pData[0];
-                                if(Request_DebugLabel > 31) Request_DebugLabel = 31;
+                                if(UART1_Request_DebugLabel > 31) UART1_Request_DebugLabel = 31;
                                 break;
                         case 'b': // submit extern control
-                                memcpy(&ExternControl, (u8*)&pRxData[0], sizeof(ExternControl));
+                                memcpy(&ExternControl, SerialMsg.pData, sizeof(ExternControl));
                                 ConfirmFrame = ExternControl.Frame;
                                 break;
                         case 'd': // request for debug data;
-                                DebugData_Interval = (u32) pRxData[0] * 10;
+                                UART1_DebugData_Interval = (u32) SerialMsg.pData[0] * 10;
-                                if(DebugData_Interval > 0) Request_DebugData = TRUE;
+                                if(UART1_DebugData_Interval > 0) UART1_Request_DebugData = TRUE;
                                 break;
                         case 'c': // request for 3D data;
-                                Data3D_Interval = (u32) pRxData[0] * 10;
+                                UART1_Data3D_Interval = (u32) SerialMsg.pData[0] * 10;
-                                if(Data3D_Interval > 0) Request_Data3D = TRUE;
+                                if(UART1_Data3D_Interval > 0) UART1_Request_Data3D = TRUE;
                                 break;
                         case 'g':// request for external control data
-                                Request_ExternalControl = TRUE;
+                                UART1_Request_ExternalControl = TRUE;
                                 break;
                         case 'h':// reqest for display line
-                                RemoteKeys |= pRxData[0];
+                                RemoteKeys |= SerialMsg.pData[0];
                                 if(RemoteKeys != 0) DisplayLine = 0;
-                                Request_Display = TRUE;
+                                UART1_Request_Display = TRUE;
                                 break;
                         case 'l':// reqest for display columns
-                                MenuItem = pRxData[0];
+                                MenuItem = SerialMsg.pData[0];
-                                Request_Display1 = TRUE;
+                                UART1_Request_Display1 = TRUE;
                                 break;
                         case 'o': // request for navigation information
-                                NaviData_Interval = (u32) pRxData[0] * 10;
+                                UART1_NaviData_Interval = (u32) SerialMsg.pData[0] * 10;
-                                if(NaviData_Interval > 0) Request_NaviData = TRUE;
-                                break;
+                                if(UART1_NaviData_Interval > 0) UART1_Request_NaviData = TRUE;
+                                break;
                         case 'v': // request for version info
-                                Request_VerInfo = TRUE;
+                        case 'v': // request for version info
-                                break;
+                                UART1_Request_VersionInfo = TRUE;
-                        default:
+                                break;
-                                // unsupported command recieved
+                        default:
-                                break;
+                                // unsupported command recieved
-                }
+                                break;
                 break; // default:
                 break; // default:
         // unlock the rxd buffer after processing
-        pRxData = NULL;
+        // unlock the rxd buffer after processing
-        RxDataLen = 0;
+        UART1_rx_buffer.Position = 0;
-        rxd_buffer_locked = FALSE;
+        UART1_rx_buffer.Locked = FALSE;
+}
 /*****************************************************/
 /*                   Send a character                */
 /*****************************************************/
-s16 uart_putchar (char c)
+s16 UART1_Putchar(char c)
+{
-        if (c == '\n') uart_putchar('\r');
+        if (c == '\n') UART1_Putchar('\r');
         // wait until txd fifo is not full
         while (UART_GetFlagStatus(UART1, UART_FLAG_TxFIFOFull) != RESET);
         // transmit byte
+        UART_SendData(UART1, c);
+        return (0);
+}
+/*****************************************************/
+/*       Send a string to the debug uart              */
+/*****************************************************/
+void UART1_PutString(u8 *s)
+{
+        if(s == NULL) return;
+        while (*s != '\0' && DebugUART == UART1)
+        {
+                UART1_Putchar(*s);
+                s ++;
+        }
+}
+/**************************************************************/
+/*         Transmit tx buffer via debug uart                  */
+/**************************************************************/
-        UART_SendData(UART1, c);
+void UART1_Transmit(void)
         return (0);
         u8 tmp_tx;
         if(DebugUART != UART1) return;
-/*****************************************************/
+        // if something has to be send and the txd fifo is not full
-/*       Send a string to the debug uart              */
+        if((UART1_tx_buffer.Locked == TRUE) && (UART_GetFlagStatus(UART1, UART_FLAG_TxFIFOFull) == RESET))
+        {
+                tmp_tx = UART1_tx_buffer.pData[UART1_tx_buffer.Position++]; // read next byte from txd buffer
-/*****************************************************/
+                UART_SendData(UART1, tmp_tx); // put character to txd fifo
-void SerialPutString(u8 *s)
+                // if terminating character or end of txd buffer reached
-{
+                if((tmp_tx == '\r') || (UART1_tx_buffer.Position == UART1_tx_buffer.Size))
         if(s == NULL) return;
-        while (*s != '\0' && DebugUART == UART1)
+                        UART1_tx_buffer.Position = 0; // reset txd buffer positon
                         UART1_tx_buffer.Locked = FALSE;// unlock tx buffer
-                uart_putchar(*s);
+                }
                 s ++;
-        }
+}
-}
+/**************************************************************/
 /* Send the answers to incomming commands at the debug uart   */
 /**************************************************************/
-/* Send the answers to incomming commands at the debug uart   */
+void UART1_TransmitTxData(void)
 /**************************************************************/
-void UART1_TransmitTxData(void)
+        if(DebugUART != UART1) return;
         UART1_Transmit(); // output pending bytes in tx buffer
-        if(!txd_complete || (DebugUART != UART1) ) return;
+        if((UART1_tx_buffer.Locked == TRUE)) return;
-        if(Request_Echo && txd_complete)
+        if(UART1_Request_Echo && (UART1_tx_buffer.Locked == FALSE))
+        {
-                SendOutData('Z', NC_ADDRESS, 1, &Echo, sizeof(Echo)); // answer the echo request
+                MKProtocol_CreateSerialFrame(&UART1_tx_buffer, 'Z', NC_ADDRESS, 1, &Echo, sizeof(Echo)); // answer the echo request
                 Echo = 0; // reset echo value
-                Request_Echo = FALSE;
+                UART1_Request_Echo = FALSE;
         }
-        if(Request_DebugLabel != 0xFF)
+        if((UART1_Request_DebugLabel != 0xFF) && (UART1_tx_buffer.Locked == FALSE))
+        {
-                SendOutData('A', NC_ADDRESS, 2, &Request_DebugLabel, sizeof(Request_DebugLabel), (u8 *) ANALOG_LABEL[Request_DebugLabel], 16);
+                MKProtocol_CreateSerialFrame(&UART1_tx_buffer, 'A', NC_ADDRESS, 2, &UART1_Request_DebugLabel, sizeof(UART1_Request_DebugLabel), (u8 *) ANALOG_LABEL[UART1_Request_DebugLabel], 16);
-                Request_DebugLabel = 0xFF;
+                UART1_Request_DebugLabel = 0xFF;
         }
-        if(ConfirmFrame && txd_complete)
+        if(ConfirmFrame && (UART1_tx_buffer.Locked == FALSE))
+        {
-                SendOutData('B', NC_ADDRESS, 1, &ConfirmFrame, sizeof(ConfirmFrame));
+                MKProtocol_CreateSerialFrame(&UART1_tx_buffer, 'B', NC_ADDRESS, 1, &ConfirmFrame, sizeof(ConfirmFrame));
                 ConfirmFrame = 0;
+        }
-        if( (( (DebugData_Interval > 0) && CheckDelay(DebugData_Timer)) || Request_DebugData) && txd_complete)
+        if( (( (UART1_DebugData_Interval > 0) && CheckDelay(UART1_DebugData_Timer)) || UART1_Request_DebugData) && (UART1_tx_buffer.Locked == FALSE))
+        {
-                SendOutData('D', NC_ADDRESS, 1,(u8 *)&DebugOut, sizeof(DebugOut));
+                MKProtocol_CreateSerialFrame(&UART1_tx_buffer, 'D', NC_ADDRESS, 1,(u8 *)&DebugOut, sizeof(DebugOut));
-                DebugData_Timer = SetDelay(DebugData_Interval);
+                UART1_DebugData_Timer = SetDelay(UART1_DebugData_Interval);
-                Request_DebugData = FALSE;
+                UART1_Request_DebugData = FALSE;
         }
-        if((( (Data3D_Interval > 0) && CheckDelay(Data3D_Timer) ) || Request_Data3D) && txd_complete)
+        if((( (UART1_Data3D_Interval > 0) && CheckDelay(UART1_Data3D_Timer) ) || UART1_Request_Data3D) && (UART1_tx_buffer.Locked == FALSE))
         {
-                SendOutData('C', NC_ADDRESS, 1,(u8 *)&Data3D, sizeof(Data3D));
+                MKProtocol_CreateSerialFrame(&UART1_tx_buffer, 'C', NC_ADDRESS, 1,(u8 *)&Data3D, sizeof(Data3D));
-                Data3D_Timer = SetDelay(Data3D_Interval);
+                UART1_Data3D_Timer = SetDelay(UART1_Data3D_Interval);
-                Request_Data3D = FALSE;
+                UART1_Request_Data3D = FALSE;
+        }
-        if(Request_ExternalControl && txd_complete)
+        if(UART1_Request_ExternalControl && (UART1_tx_buffer.Locked == FALSE))
+        {
-                SendOutData('G', NC_ADDRESS, 1, (u8 *)&ExternControl, sizeof(ExternControl));
+                MKProtocol_CreateSerialFrame(&UART1_tx_buffer, 'G', NC_ADDRESS, 1, (u8 *)&ExternControl, sizeof(ExternControl));
-                Request_ExternalControl = FALSE;
+                UART1_Request_ExternalControl = FALSE;
+        }
-        if(Request_Display && txd_complete)
-        {
+        if(UART1_Request_Display && (UART1_tx_buffer.Locked == FALSE))
-                LCD_PrintMenu();
+        {
-                SendOutData('H', NC_ADDRESS, 2, &DisplayLine, sizeof(DisplayLine), (u8*)&DisplayBuff[DisplayLine * 20], 20);
+                LCD_PrintMenu();
-                DisplayLine++;
+                MKProtocol_CreateSerialFrame(&UART1_tx_buffer, 'H', NC_ADDRESS, 2, &DisplayLine, sizeof(DisplayLine), (u8*)&DisplayBuff[DisplayLine * 20], 20);
-                if(DisplayLine >= 4) DisplayLine = 0;
+                DisplayLine++;
-                Request_Display = FALSE;
+                if(DisplayLine >= 4) DisplayLine = 0;
-        }
+                UART1_Request_Display = FALSE;
-        if(Request_Display1 && txd_complete)
+        }
         if(UART1_Request_Display1 && (UART1_tx_buffer.Locked == FALSE))
-                LCD_PrintMenu();
+        {
-                SendOutData('L', NC_ADDRESS, 3, (u8*)&MenuItem, sizeof(MenuItem), (u8*)&MaxMenuItem, sizeof(MaxMenuItem),(u8*)DisplayBuff, sizeof(DisplayBuff));
+                LCD_PrintMenu();
-                Request_Display1 = FALSE;
+                MKProtocol_CreateSerialFrame(&UART1_tx_buffer, 'L', NC_ADDRESS, 3, (u8*)&MenuItem, sizeof(MenuItem), (u8*)&MaxMenuItem, sizeof(MaxMenuItem),(u8*)DisplayBuff, sizeof(DisplayBuff));
                 UART1_Request_Display1 = FALSE;
         if(Request_VerInfo && txd_complete)
         if(UART1_Request_VersionInfo && (UART1_tx_buffer.Locked == FALSE))
                 FollowMe.Event_Flag = 0;
                 FollowMe.reserve[0] = 0;                // reserve
                 FollowMe.reserve[1] = 0;                // reserve
                 FollowMe.reserve[2] = 0;                // reserve
                 FollowMe.reserve[3] = 0;                // reserve
-                SendOutData('s', NC_ADDRESS, 1, (u8 *)&FollowMe, sizeof(FollowMe));
+                MKProtocol_CreateSerialFrame(&UART1_tx_buffer, 's', NC_ADDRESS, 1, (u8 *)&FollowMe, sizeof(FollowMe));
-                Request_SendFollowMe = FALSE;
+                UART1_Request_SendFollowMe = FALSE;
+        }
-        if(Request_NewWaypoint && txd_complete)
+        if(UART1_Request_NewWaypoint && (UART1_tx_buffer.Locked == FALSE))
+        {
                 u8 WPNumber = WPList_GetCount();
-                SendOutData('W', NC_ADDRESS, 1, &WPNumber, sizeof(WPNumber));
+                MKProtocol_CreateSerialFrame(&UART1_tx_buffer, 'W', NC_ADDRESS, 1, &WPNumber, sizeof(WPNumber));
-                Request_NewWaypoint = FALSE;
+                UART1_Request_NewWaypoint = FALSE;
+        }
-        if((Request_ReadWaypoint != 0xFF) && txd_complete)
+        if((UART1_Request_ReadWaypoint != 0xFF) && (UART1_tx_buffer.Locked == FALSE))
+        {
                 u8 WPNumber = WPList_GetCount();
-                if (Request_ReadWaypoint < WPNumber)
+                if (UART1_Request_ReadWaypoint < WPNumber)
+                {
-                        SendOutData('X', NC_ADDRESS, 3, &WPNumber, 1, &Request_ReadWaypoint, 1, WPList_GetAt(Request_ReadWaypoint), sizeof(Waypoint_t));
+                        MKProtocol_CreateSerialFrame(&UART1_tx_buffer, 'X', NC_ADDRESS, 3, &WPNumber, 1, &UART1_Request_ReadWaypoint, 1, WPList_GetAt(UART1_Request_ReadWaypoint), sizeof(Waypoint_t));
+                }
                 else
+                {
-                        SendOutData('X', NC_ADDRESS, 1, &WPNumber, sizeof(WPNumber));
+                        MKProtocol_CreateSerialFrame(&UART1_tx_buffer,'X', NC_ADDRESS, 1, &WPNumber, sizeof(WPNumber));
+                }
-                Request_ReadWaypoint = 0xFF;
+                UART1_Request_ReadWaypoint = 0xFF;
+        }
+        UART1_Transmit(); // output pending bytes in tx buffer
+}

Subversion Repositories NaviCtrl

(root)/tags/V0.30a/uart1.c @ 622 - Rev 101 → 110