WebSVN - NaviCtrl - Diff - Rev 49 and 110 - /tags/V2.07b

 // +  INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 // +  CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 // +  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 // +  POSSIBILITY OF SUCH DAMAGE.
 // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+#include <stdio.h>
+#include <stdarg.h>
 #include "91x_lib.h"
+#include "main.h"
 #include "uart0.h"
 #include "uart1.h"
+#include "timer.h"
 #include "ubx.h"
-#include <stdio.h>
+#include "mkprotocol.h"
-#include <stdarg.h>
+u8 UART0_Request_VersionInfo    = FALSE;
+u8 UART0_Request_NaviData               = FALSE;
+u32 UART0_NaviData_Timer;
 u32 UART0_NaviData_Interval = 0;        // in ms
 //------------------------------------------------------------------------------------
-// global variables
+// global variables
-// UART0 MUXER
+#define UART0_BAUD_RATE 57600           //Baud Rate for the serial interfaces
+// UART0 MUXER
 UART0_MuxerState_t UART0_Muxer = UART0_UNDEF;
+u16 Uart0Baudrate = UART0_BAUD_RATE;
+u16 Uart0MK3MagBaudrate = UART0_BAUD_RATE;
+// the tx buffer
+#define UART0_TX_BUFFER_LEN  150
+u8 UART0_tbuffer[UART0_TX_BUFFER_LEN];
+Buffer_t UART0_tx_buffer;
+// the rx buffer
+#define UART0_RX_BUFFER_LEN  150
-u16 Uart0Baudrate = BAUD_RATE;
-u16 Uart0MK3MagBaudrate = BAUD_RATE;
-volatile u8 txd_buffer0[TXD_BUFFER_LEN];
+u8 UART0_rbuffer[UART0_RX_BUFFER_LEN];
-volatile u8 txd_complete0 = TRUE;
+Buffer_t UART0_rx_buffer;
 static u16 ptr_txd_buffer0 = 0;
 /********************************************************/
 void UART0_Init(void)
+{
     UART_InitTypeDef UART_InitStructure;
-        SerialPutString("\r\n UART0 init...");
+        UART1_PutString("\r\n UART0 init...");
         SCU_APBPeriphClockConfig(__UART0, ENABLE);  // Enable the UART0 Clock
-        Uart0Baudrate = BAUD_RATE + ((BAUD_RATE * 2)/100);   // MK3Mag baudrate is a litlle bit higher...
+        Uart0Baudrate = UART0_BAUD_RATE + ((UART0_BAUD_RATE * 2)/100);   // MK3Mag baudrate is a litlle bit higher...
         // configure the uart 0 interupt line as an IRQ with priority 10 (0 is highest)
         VIC_Config(UART0_ITLine, VIC_IRQ, 10);
         // enable the uart 0 IRQ
         VIC_ITCmd(UART0_ITLine, ENABLE);
         UART0_Connect_to_MKGPS();
-        SerialPutString("ok");
-}
-/**************************************************************/
+        // initialize txd buffer
-/*         Transmit tx buffer via debug uart                  */
+        UART0_tx_buffer.pData = UART0_tbuffer;
-/**************************************************************/
+        UART0_tx_buffer.Size = UART0_TX_BUFFER_LEN;
-void UART0_Transmit(void)
-{
-        u8 tmp_tx;
+        UART0_tx_buffer.Position = 0;
-        // if something has to be send and the txd fifo is not full
-        if((!txd_complete0) && (UART_GetFlagStatus(UART0, UART_FLAG_TxFIFOFull) == RESET))
+        UART0_tx_buffer.Locked = FALSE;
-        {
-                tmp_tx = txd_buffer0[ptr_txd_buffer0]; // read byte from txd buffer
-                // if terminating character or end of txd buffer reached
-                if((tmp_tx == '\r') || (ptr_txd_buffer0 == TXD_BUFFER_LEN))
-                {
+        // initialize rxd buffer
-                        ptr_txd_buffer0 = 0;    // reset txd buffer pointer
+        UART0_rx_buffer.pData = UART0_rbuffer;
-                        txd_complete0 = TRUE;// set complete flag
-                }
-                UART_SendData(UART0, tmp_tx); // put character to txd fifo
+        UART0_rx_buffer.Size = UART0_RX_BUFFER_LEN;
-                // set pointer to next byte
+        UART0_rx_buffer.Position = 0;
-                ptr_txd_buffer0++;
-        }
-}
-/**************************************************************/
-/* Add CRC and initiate transmission via debug uart           */
-/**************************************************************/
-void AddCRC0(u16 datalen)
-{
-        u16 tmpCRC = 0, i;
-        for(i = 0; i < datalen; i++)
-        {
-                tmpCRC += txd_buffer0[i];
-        }
-        tmpCRC %= 4096;
-        txd_buffer0[i++] = '=' + tmpCRC / 64;
-        txd_buffer0[i++] = '=' + tmpCRC % 64;
-        txd_buffer0[i++] = '\r';
+        UART0_rx_buffer.Locked = FALSE;
-        ptr_txd_buffer0 = 0;
         txd_complete0 = FALSE;
-        UART_SendData(UART0, txd_buffer0[ptr_txd_buffer0++]);   // send first byte, to be continued in the txd irq
-}
-/**************************************************************/
-/* Code output data                                           */
-/**************************************************************/
-void SendOutData0(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_buffer0[pt++] = '#';                                // Start character
-        txd_buffer0[pt++] = 'a' + Address;      // Address (a=0; b=1,...)
-        txd_buffer0[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_buffer0[pt++] = '=' + (a >> 2);
-                txd_buffer0[pt++] = '=' + (((a & 0x03) << 4) | ((b & 0xf0) >> 4));
-                txd_buffer0[pt++] = '=' + (((b & 0x0f) << 2) | ((c & 0xc0) >> 6));
-                txd_buffer0[pt++] = '=' + ( c & 0x3f);
-        }
-        va_end(ap);
-        AddCRC0(pt);    // add checksum after data block and initates the transmission
         UART1_PutString("ok");
+}
 /********************************************************/
 /*            UART0 Interrupt Handler                   */
 /********************************************************/
-void UART0_IRQHandler(void)
-{
-        u8 c;
-        /*
-        static u8 frame_error_cnt = 0;
-    // use frame error to adjust baudrate for MK3MAG
-        if((UART_GetITStatus(UART0, UART_IT_FrameError) == SET))
-        {
-           u8 msg[20];
-           frame_error_cnt++;
-           if (frame_error_cnt == 200)
-           {
-            frame_error_cnt = 0;
-            VIC_ITCmd(UART0_ITLine, DISABLE);
-            Uart0MK3MagBaudrate +=100;
-            if (Uart0MK3MagBaudrate > (BAUD_RATE+1000)) Uart0MK3MagBaudrate = BAUD_RATE;
-            Uart0Baudrate = Uart0MK3MagBaudrate;
-            SerialPutString(" adjusting UART0 baudrate to");
-            sprintf(msg, " %d baud...", Uart0MK3MagBaudrate); SerialPutString(msg);
-                while(UART_GetFlagStatus(UART0, UART_FLAG_RxFIFOEmpty) != SET)
-                        {
-                                c =  UART_ReceiveData(UART0);
-                        }
-            UART_ClearITPendingBit(UART0, UART_IT_FrameError);                  // clear frame error interrupt flag
-            UART0_Init();
-            return;
 void UART0_IRQHandler(void)
+{
-        }*/
+        u8 c;
         // if receive irq or receive timeout irq has occured
         if((UART_GetITStatus(UART0, UART_IT_Receive) != RESET) || (UART_GetITStatus(UART0, UART_IT_ReceiveTimeOut) != RESET) )
                                 c = UART_ReceiveData(UART0); // get byte from rx fifo
                                 switch(UART0_Muxer)
+                                {
                                         case UART0_MKGPS:
                                                 UBX_Parser(c); // if connected to GPS forward byte to ubx parser
+                                                MKProtocol_CollectSerialFrame(&UART0_rx_buffer, c);     // ckeck for MK-Frames also
                                                 break;
                                         case UART0_MK3MAG:
                                                 // ignore any byte send from MK3MAG
                                                 break;
                                         case UART0_UNDEF:
                                 } // eof switch(UART0_Muxer)
                         } // eof while
                 }  // eof UART0 is not the DebugUART
         } // eof receive irq or receive timeout irq
+}
+/**************************************************************/
+/* Process incomming data from debug uart                     */
+/**************************************************************/
+void UART0_ProcessRxData(void)
+{
+        SerialMsg_t SerialMsg;
+        // if data in the rxd buffer are not locked immediately return
+        if((UART0_rx_buffer.Locked == FALSE) || (DebugUART == UART0) ) return;
+        MKProtocol_DecodeSerialFrame(&UART0_rx_buffer, &SerialMsg); // decode serial frame in rxd buffer
+        switch(SerialMsg.Address) // check for Slave Address
+        {
+                case NC_ADDRESS:  // own Slave Address
+                switch(SerialMsg.CmdID)
+                {
+                        default:
+                                break;
+                } // case NC_ADDRESS
+                // "break;" is missing here to fall thru to the common commands
+                default:  // and any other Slave Address
+                switch(SerialMsg.CmdID) // check CmdID
+                {
+                        case 'o': // request for navigation information
+                                UART0_NaviData_Interval = (u32) SerialMsg.pData[0] * 10;
+                                if(UART0_NaviData_Interval > 0) UART0_Request_NaviData = TRUE;
+                                break;
+                        case 'v': // request for version info
+                                UART0_Request_VersionInfo = TRUE;
+                                break;
+                        default:
+                                // unsupported command recieved
+                                break;
+                }
+                break; // default:
+        }
+        // unlock the rxd buffer after processing
+        UART0_rx_buffer.Position = 0;
+        UART0_rx_buffer.Locked = FALSE;
+}
+/**************************************************************/
+/*         Transmit tx buffer via uart0                       */
+/**************************************************************/
+void UART0_Transmit(void)
+{
+        u8 tmp_tx;
+        if(DebugUART == UART0) return; // no data output if debug uart is rederected to UART0
+        // if something has to be send and the txd fifo is not full
+        if((UART0_tx_buffer.Locked == TRUE) && (UART_GetFlagStatus(UART0, UART_FLAG_TxFIFOFull) == RESET))
+        {
+                tmp_tx = UART0_tx_buffer.pData[UART0_tx_buffer.Position++]; // read next byte from txd buffer
+                UART_SendData(UART0, tmp_tx); // put character to txd fifo
+                // if terminating character or end of txd buffer reached
+                if((tmp_tx == '\r') || (UART0_tx_buffer.Position == UART0_tx_buffer.Size))
+                {
+                        UART0_tx_buffer.Position = 0; // reset txd buffer positon
+                        UART0_tx_buffer.Locked = FALSE;// unlock tx buffer
+                }
+        }
+}
+/**************************************************************/
+/* Send the answers to incomming commands at the uart0        */
+/**************************************************************/
+void UART0_TransmitTxData(void)
+{
+        if(DebugUART == UART0) return;
+        UART0_Transmit(); // output pending bytes in tx buffer
+        if(UART0_tx_buffer.Locked == TRUE) return;
+        if(( (UART0_NaviData_Interval && CheckDelay(UART0_NaviData_Timer) ) || UART0_Request_NaviData) && (UART0_tx_buffer.Locked == FALSE))
+        {
+                NaviData.Errorcode = ErrorCode;
+                MKProtocol_CreateSerialFrame(&UART0_tx_buffer, 'O', NC_ADDRESS,1, (u8 *)&NaviData, sizeof(NaviData));
+                UART0_NaviData_Timer = SetDelay(UART0_NaviData_Interval);
+                UART0_Request_NaviData = FALSE;
+        }
+        UART0_Transmit(); // output pending bytes in tx buffer
+}

Subversion Repositories NaviCtrl

(root)/tags/V2.07b_Beta/uart0.c @ 575 - Rev 49 → 110