WebSVN - NaviCtrl - Diff - Rev 201 and 212


/*#######################################################################################*/
/* !!! THIS IS NOT FREE SOFTWARE !!!                                                     */
/*#######################################################################################*/
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// + Copyright (c) 2008 Ingo Busker, Holger Buss
// + Nur für den privaten Gebrauch / NON-COMMERCIAL USE ONLY
// + FOR NON COMMERCIAL USE ONLY
// + www.MikroKopter.com
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// + Es gilt für das gesamte Projekt (Hardware, Software, Binärfiles, Sourcecode und Dokumentation),
// + dass eine Nutzung (auch auszugsweise) nur für den privaten (nicht-kommerziellen) Gebrauch zulässig ist.
// + Sollten direkte oder indirekte kommerzielle Absichten verfolgt werden, ist mit uns (info@mikrokopter.de) Kontakt
// + bzgl. der Nutzungsbedingungen aufzunehmen.
// + Eine kommerzielle Nutzung ist z.B.Verkauf von MikroKoptern, Bestückung und Verkauf von Platinen oder Bausätzen,
// + Verkauf von Luftbildaufnahmen, usw.
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// + Werden Teile des Quellcodes (mit oder ohne Modifikation) weiterverwendet oder veröffentlicht,
// + unterliegen sie auch diesen Nutzungsbedingungen und diese Nutzungsbedingungen incl. Copyright müssen dann beiliegen
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// + Sollte die Software (auch auszugesweise) oder sonstige Informationen des MikroKopter-Projekts
// + auf anderen Webseiten oder sonstigen Medien veröffentlicht werden, muss unsere Webseite "http://www.mikrokopter.de"
// + eindeutig als Ursprung verlinkt werden
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// + Keine Gewähr auf Fehlerfreiheit, Vollständigkeit oder Funktion
// + Benutzung auf eigene Gefahr
// + Wir übernehmen keinerlei Haftung für direkte oder indirekte Personen- oder Sachschäden
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// + Die Portierung oder Nutzung der Software (oder Teile davon) auf andere Systeme (ausser der Hardware von www.mikrokopter.de) ist nur
// + mit unserer Zustimmung zulässig
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// + Die Funktion printf_P() unterliegt ihrer eigenen Lizenz und ist hiervon nicht betroffen
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// + Redistributions of source code (with or without modifications) must retain the above copyright notice,
// + this list of conditions and the following disclaimer.
// +   * Neither the name of the copyright holders nor the names of contributors may be used to endorse or promote products derived
// +     from this software without specific prior written permission.
// +   * The use of this project (hardware, software, binary files, sources and documentation) is only permitted
// +     for non-commercial use (directly or indirectly)
// +     Commercial use (for excample: selling of MikroKopters, selling of PCBs, assembly, ...) is only permitted
// +     with our written permission
// +   * If sources or documentations are redistributet on other webpages, out webpage (http://www.MikroKopter.de) must be
// +     clearly linked as origin
// +   * porting the sources to other systems or using the software on other systems (except hardware from www.mikrokopter.de) is not allowed
//
// +  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// +  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// +  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// +  ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
// +  LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
// +  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
// +  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
// +  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 <string.h>
 
#include "91x_lib.h"
#include "config.h"
#include "menu.h"
#include "GPS.h"
#include "i2c.h"
#include "uart0.h"
#include "uart1.h"
#include "uart2.h"
#include "timer1.h"
#include "timer2.h"
#include "analog.h"
#include "main.h"
#include "waypoints.h"
#include "mkprotocol.h"
#include "params.h"
#include "fifo.h"
 
#define FALSE   0
#define TRUE    1
 
#define ABO_TIMEOUT 4000 // disable abo after 4 seconds
u32 UART1_AboTimeOut = 0;
 
u8 UART1_Request_VersionInfo    = FALSE;
u8 UART1_Request_SendFollowMe   = FALSE;
u8 UART1_Request_ExternalControl= FALSE;
u8 UART1_Request_Display                = FALSE;
u8 UART1_Request_Display1               = FALSE;
u8 UART1_Request_DebugData              = FALSE;
u8 UART1_Request_DebugLabel             = 255;
u8 UART1_Request_NaviData               = FALSE;
u8 UART1_Request_ErrorMessage   = FALSE;
u8 UART1_Request_NewWaypoint    = FALSE;
u8 UART1_Request_ReadWaypoint   = 255;
u8 UART1_Request_Data3D             = FALSE;
u8 UART1_Request_Echo               = FALSE;
u8 UART1_Request_ParameterId    = 0;
u8 UART1_Request_Parameter              = FALSE;
u8 UART1_DisplayKeys                    = 0;
u8 UART1_DisplayLine                    = 0;
u8 UART1_ConfirmFrame                   = 0;
 
UART_TypeDef *DebugUART = UART1;
 
// the primary rx fifo
#define UART1_RX_FIFO_LEN 1024
u8 UART1_rxfifobuffer[UART1_RX_FIFO_LEN];
fifo_t UART1_rx_fifo;
 
// the rx buffer
#define UART1_RX_BUFFER_LEN  150
u8 UART1_rbuffer[UART1_RX_BUFFER_LEN];
Buffer_t UART1_rx_buffer;
 
// the tx buffer
#define UART1_TX_BUFFER_LEN  150
u8 UART1_tbuffer[UART1_TX_BUFFER_LEN];
Buffer_t UART1_tx_buffer;
 
 
 
volatile u8 SerialLinkOkay = 0;
 
u8 text[200];
 
const u8 ANALOG_LABEL[32][16] =
{
   //1234567890123456
        "AngleNick       ", //0
        "AngleRoll       ",
        "AccNick         ",
        "AccRoll         ",
        "                ",
        "FC-Flags        ", //5
        "NC-Flags        ",
        "NickServo       ",
        "RollServo       ",
        "GPS Data        ",
        "CompassHeading  ", //10
        "GyroHeading     ",
        "SPI Error       ",
        "SPI Okay        ",
        "I2C Error       ",
        "I2C Okay        ", //15
        "                ",//    "Kalman_K        ",
        "ACC_Speed_N     ",
        "ACC_Speed_E     ",
        "Speed_z         ",//    "GPS ACC         ",
        "                ",//    "MAXDrift        ", //20
        "N_Speed         ",
        "E_Speed         ",
        "P-Part          ",
        "I-Part          ",
        "D-Part          ",//25
        "PID-Part        ",
        "Distance N      ",
        "Distance E      ",
        "GPS_Nick        ",
        "GPS_Roll        ", //30
        "Used_Sats       "
};
 
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
 
u32 UART1_DebugData_Timer = 0;
u32 UART1_DebugData_Interval = 0;       // in ms
u32 UART1_NaviData_Timer = 0;
u32 UART1_NaviData_Interval = 0;        // in ms
u32 UART1_Data3D_Timer = 0;
u32 UART1_Data3D_Interval = 0;          // in ms
u32 UART1_Display_Timer = 0;
u32 UART1_Display_Interval = 0;         // in ms
 
/********************************************************/
/*            Initialization the UART1                  */
/********************************************************/
void UART1_Init (void)
{
        GPIO_InitTypeDef GPIO_InitStructure;
        UART_InitTypeDef UART_InitStructure;
 
        // initialize txd buffer
        Buffer_Init(&UART1_tx_buffer, UART1_tbuffer, UART1_TX_BUFFER_LEN);
 
        // initialize rxd buffer
        Buffer_Init(&UART1_rx_buffer, UART1_rbuffer, UART1_RX_BUFFER_LEN);
 
        // initialize the rx fifo
        fifo_init(&UART1_rx_fifo, UART1_rxfifobuffer, UART1_RX_FIFO_LEN);
 
        SCU_APBPeriphClockConfig(__UART1, ENABLE);  // Enable the UART1 Clock
        SCU_APBPeriphClockConfig(__GPIO3, ENABLE);  // Enable the GPIO3 Clock
 
        /*Configure UART1_Rx pin GPIO3.2*/
        GPIO_StructInit(&GPIO_InitStructure);
        GPIO_InitStructure.GPIO_Direction =     GPIO_PinInput;
        GPIO_InitStructure.GPIO_Pin =                   GPIO_Pin_2;
        GPIO_InitStructure.GPIO_Type =                  GPIO_Type_PushPull;
        GPIO_InitStructure.GPIO_IPInputConnected =      GPIO_IPInputConnected_Enable;
        GPIO_InitStructure.GPIO_Alternate =     GPIO_InputAlt1; // UART1_RxD
        GPIO_Init(GPIO3, &GPIO_InitStructure);
 
        /*Configure UART1_Tx pin GPIO3.3*/
        GPIO_StructInit(&GPIO_InitStructure);
        GPIO_InitStructure.GPIO_Direction =     GPIO_PinOutput;
        GPIO_InitStructure.GPIO_Pin =                   GPIO_Pin_3;
        GPIO_InitStructure.GPIO_Type =                  GPIO_Type_PushPull;
        GPIO_InitStructure.GPIO_Alternate =     GPIO_OutputAlt2; // UART1_TX
        GPIO_Init(GPIO3, &GPIO_InitStructure);
 
        /* UART1 configured as follow:
        - Word Length = 8 Bits
        - One Stop Bit
        - No parity
        - BaudRate = 57600 baud
        - Hardware flow control Disabled
        - Receive and transmit enabled
        - Receive and transmit FIFOs are Disabled
        */
        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 =                              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;
 
        UART_DeInit(UART1); // reset uart 1     to default
        UART_Init(UART1, &UART_InitStructure); // initialize uart 1
        // enable uart 1 interrupts selective
        UART_ITConfig(UART1, UART_IT_Receive | UART_IT_ReceiveTimeOut, ENABLE);
        UART_Cmd(UART1, ENABLE); // enable uart 1
        // configure the uart 1 interupt line
        VIC_Config(UART1_ITLine, VIC_IRQ, PRIORITY_UART1);
                // enable the uart 1 IRQ
        VIC_ITCmd(UART1_ITLine, ENABLE);
 
        // initialize the debug timer
        UART1_DebugData_Timer = SetDelay(UART1_DebugData_Interval);
        UART1_NaviData_Timer = SetDelay(UART1_NaviData_Interval)+500;
 
        // 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;
 
        UART1_PutString("\r\n UART1 init...ok");
}
 
 
/****************************************************************/
/*               USART1 receiver ISR                            */
/****************************************************************/
void UART1_IRQHandler(void)
{
        static u8 abortState = 0;
        u8 c;
 
        IENABLE;
 
        if((UART_GetITStatus(UART1, UART_IT_Receive) != RESET) || (UART_GetITStatus(UART1, UART_IT_ReceiveTimeOut) != RESET) )
        {
                // clear the pending bits!
                UART_ClearITPendingBit(UART1, UART_IT_Receive);
                UART_ClearITPendingBit(UART1, UART_IT_ReceiveTimeOut);
                // 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)
                        {
                                // 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)
                                switch (abortState)
                                {
                                        case 0:
                                                if (c == 27) abortState++;
                                                break;
                                        case 1:
                                                if (c == 27) abortState++;
                                                else abortState = 0;
                                        break;
                                        case 2:
                                                if (c == 0x55) abortState++;
                                                else abortState = 0;
                                                break;
                                        case 3:
                                                if (c == 0xAA) abortState++;
                                                else abortState = 0;
                                                break;
                                        case 4:
                                                if (c == 0x00)
                                                {
                                                        if(DebugUART == UART0)
                                                        {
                                                                UART0_Connect_to_MKGPS();
                                                                TIMER2_Init(); // enbable servo outputs
                                                                fifo_purge(&UART1_rx_fifo); // flush the whole fifo init buffer
                                                        }
                                                        DebugUART = UART1;
                                                }
                                                abortState = 0;
                                                break;
                                } // end switch abort state
                                // if the Debug uart is not UART1, redirect 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 fifo of the debug uart
                                        UART_SendData(DebugUART, c);
                                }
                        }
                }
                else  // DebugUART == UART1 (normal operation)
                {
                        while(UART_GetFlagStatus(UART1, UART_FLAG_RxFIFOEmpty) != SET)
                        { // some byes in the hardware fifo
                            // get byte from hardware fifo
                        c = UART_ReceiveData(UART1);
                                // put into the software fifo
                                if(!fifo_put(&UART1_rx_fifo, c))
                                {       // fifo overflow
                                        //fifo_purge(&UART1_rx_fifo); // flush the whole buffer
                                }
                        } // EOF while some byes in the hardware fifo
                } // eof DebugUart = UART1
        }
 
        IDISABLE;
}
 
/**************************************************************/
/* Process incomming data from debug uart                     */
/**************************************************************/
void UART1_ProcessRxData(void)
{
        // return on forwarding uart  or unlocked rx buffer
        if(DebugUART != UART1) return;
 
        u8 c;
        // if rx buffer is not locked
        if(UART1_rx_buffer.Locked == FALSE)
        {   //collect data from primary rx fifo
                while(fifo_get(&UART1_rx_fifo, &c))
                {       // break if complete frame is collected
                        if(MKProtocol_CollectSerialFrame(&UART1_rx_buffer, c)) break;
                }
        }
        if(UART1_rx_buffer.Locked == FALSE) return;
 
        Waypoint_t * pWaypoint = NULL;
        SerialMsg_t SerialMsg;
 
        // analyze header first
        MKProtocol_DecodeSerialFrameHeader(&UART1_rx_buffer, &SerialMsg);
        if( SerialMsg.Address == FC_ADDRESS )
        {
                switch(SerialMsg.CmdID)
                {
                        case 'y': // serial poti values
                        case 'b': // extern control
                                Buffer_Copy(&UART1_rx_buffer, &UART2_tx_buffer); //forward to FC
                                Buffer_Clear(&UART1_rx_buffer); // free rc buffer for next frame
                                return; //end process rx data
                        break;
                }
        }
 
        MKProtocol_DecodeSerialFrameData(&UART1_rx_buffer, &SerialMsg); // decode serial frame in rxd buffer
    if(SerialMsg.CmdID != 'z') SerialLinkOkay = 250;      // reset SerialTimeout, but not in case of the "ping"
        switch(SerialMsg.Address) // check for Slave Address
        {
                case NC_ADDRESS:  // own Slave Address
                switch(SerialMsg.CmdID)
                {
                        case 'z': // connection checker
                                memcpy(&Echo, SerialMsg.pData, sizeof(Echo)); // copy echo pattern
                                UART1_Request_Echo = TRUE;
                                break;
 
                        case 'e': // request for the text of the error status
                                UART1_Request_ErrorMessage = TRUE;
                                break;
 
                        case 's'://  new target position
                                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(SerialMsg.pData[0])
                                {
                                        case UART_FLIGHTCTRL:
                                                UART2_Init();                           // initialize UART2 to FC pins
                                                fifo_purge(&UART1_rx_fifo);
                                                TIMER2_Deinit();                        // reduce irq load
                                                DebugUART = UART2;
                                                break;
                                        case UART_MK3MAG:
                                                if(FC.Flags & FCFLAG_MOTOR_RUN) break; // not if the motors are running
                                                UART0_Connect_to_MK3MAG();      // mux UART0 to MK3MAG pins
                                                GPSData.Status = INVALID;
                                                fifo_purge(&UART1_rx_fifo);
                                                DebugUART = UART0;
                                                break;
                                        case UART_MKGPS:
                                                if(FC.Flags & FCFLAG_MOTOR_RUN) break; // not if the motors are running
                                                TIMER2_Deinit();                        // disable servo outputs to reduce irq load
                                                UART0_Connect_to_MKGPS();       // connect UART0 to MKGPS pins
                                                GPSData.Status = INVALID;
                                                fifo_purge(&UART1_rx_fifo);
                                                DebugUART = UART0;
                                                break;
                                        default:
                                                break;
                                }
                                break;
 
                        case 'w'://  Append Waypoint to List
                                {
                                        static u8 oldIndex = 0x00;
 
                                        pWaypoint = (Waypoint_t*)SerialMsg.pData;
                                        if(pWaypoint->Position.Status == INVALID)
                                        {  // clear WP List
                                                WPList_Clear();
                                                oldIndex = 0x00;
                                                GPS_pWaypoint = WPList_Begin();
                                                UART1_Request_NewWaypoint = TRUE;
                                        }
                                        else if (pWaypoint->Position.Status == NEWDATA)
                                        {  // app current WP to the list
                                                 if (pWaypoint->Index == oldIndex + 1)
                                                {
                                                        WPList_Append(pWaypoint);
                                                        BeepTime = 500;
                                                        oldIndex = pWaypoint->Index;
                                                        UART1_Request_NewWaypoint = TRUE;
                                                }
                                        }
                                }
                                break;
 
                        case 'x'://  Read Waypoint from List
                                UART1_Request_ReadWaypoint = SerialMsg.pData[0];
                                break;
 
                        case 'j':// Set/Get NC-Parameter
                                switch(SerialMsg.pData[0])
                                {
                                        case 0: // get
                                        break;
 
                                        case 1: // set
                                        {
                                                s16 value;
                                                value = SerialMsg.pData[2] + (s16)SerialMsg.pData[3] * 0x0100;
                                                NCParams_SetValue(SerialMsg.pData[1], &value);
                                        }
                                        break;
 
                                        default:
                                        break;
                                }
                                UART1_Request_ParameterId = SerialMsg.pData[1];
                                UART1_Request_Parameter = TRUE;
                                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(SerialMsg.CmdID) // check CmdID
                {
                        case 'a':// request for the labels of the analog debug outputs
                                UART1_Request_DebugLabel = SerialMsg.pData[0];
                                if(UART1_Request_DebugLabel > 31) UART1_Request_DebugLabel = 31;
                                break;
                        /*
                        case 'b': // submit extern control
                                memcpy(&ExternControl, SerialMsg.pData, sizeof(ExternControl));
                                UART1_ConfirmFrame = ExternControl.Frame;
                                break;
                        */
                        case 'd': // request for debug data;
                                UART1_DebugData_Interval = (u32) SerialMsg.pData[0] * 10;
                                if(UART1_DebugData_Interval > 0) UART1_Request_DebugData = TRUE;
                                UART1_AboTimeOut = SetDelay(ABO_TIMEOUT);
                                break;
 
                        case 'c': // request for 3D data;
                                UART1_Data3D_Interval = (u32) SerialMsg.pData[0] * 10;
                                if(UART1_Data3D_Interval > 0) UART1_Request_Data3D = TRUE;
                                UART1_AboTimeOut = SetDelay(ABO_TIMEOUT);
                                break;
                        /*
                        case 'g':// request for external control data
                                UART1_Request_ExternalControl = TRUE;
                                break;
                        */
                        case 'h':// reqest for display line
                                if((SerialMsg.pData[0]& 0x80) == 0x00)// old format
                                {
                                        UART1_DisplayLine = 2;
                                        UART1_Display_Interval = 0;
                                }
                                else
                                {
                                        UART1_DisplayKeys |= ~SerialMsg.pData[0];
                                        UART1_Display_Interval = (u32) SerialMsg.pData[1] * 10;
                                        UART1_DisplayLine = 4;
                                        UART1_AboTimeOut = SetDelay(ABO_TIMEOUT);
                                }
                                UART1_Request_Display = TRUE;
                                break;
 
                        case 'l':// reqest for display columns
                                MenuItem = SerialMsg.pData[0];
                                UART1_Request_Display1 = TRUE;
                                break;
 
                        case 'o': // request for navigation information
                                UART1_NaviData_Interval = (u32) SerialMsg.pData[0] * 10;
                                if(UART1_NaviData_Interval > 0) UART1_Request_NaviData = TRUE;
                                UART1_AboTimeOut = SetDelay(ABO_TIMEOUT);
                                break;
 
                        case 'v': // request for version info
                                UART1_Request_VersionInfo = TRUE;
                                break;
                        default:
                                // unsupported command recieved
                                break;
                }
                break; // default:
        }
        Buffer_Clear(&UART1_rx_buffer); // free rc buffer for next frame
}
 
 
/*****************************************************/
/*                   Send a character                */
/*****************************************************/
s16 UART1_Putchar(char c)
{
        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                  */
/**************************************************************/
void UART1_Transmit(void)
{
        u8 tmp_tx;
        if(DebugUART != UART1) return;
        // if something has to be send and the txd fifo is not full
        if(UART1_tx_buffer.Locked == TRUE)
        {
                // while there is some space in the tx fifo
                while(UART_GetFlagStatus(UART1, UART_FLAG_TxFIFOFull) != SET)
                {
                        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
                        // if terminating character or end of txd buffer reached
                        if((tmp_tx == '\r') || (UART1_tx_buffer.Position == UART1_tx_buffer.DataBytes))
                        {
                                Buffer_Clear(&UART1_tx_buffer); // clear txd buffer
                                break; // end while loop
                        }
                }
        }
}
 
/**************************************************************/
/* Send the answers to incomming commands at the debug uart   */
/**************************************************************/
void UART1_TransmitTxData(void)
{
        if(DebugUART != UART1) return;
 
        if(CheckDelay(UART1_AboTimeOut))
        {
                UART1_DebugData_Interval = 0;
                UART1_NaviData_Interval = 0;
                UART1_Data3D_Interval = 0;
                UART1_Display_Interval = 0;
        }
 
        UART1_Transmit(); // output pending bytes in tx buffer
        if((UART1_tx_buffer.Locked == TRUE)) return;
 
        if(UART1_Request_Parameter && (UART1_tx_buffer.Locked == FALSE))
        {
                s16 ParamValue;
                NCParams_GetValue(UART1_Request_ParameterId, &ParamValue);
                //sprintf(text, "\r\nId=%d, value = %d\r\n", UART1_Request_ParameterId, ParamValue);
                //UART1_PutString(text);
                MKProtocol_CreateSerialFrame(&UART1_tx_buffer, 'J', NC_ADDRESS, 2, &UART1_Request_ParameterId, sizeof(UART1_Request_ParameterId), &ParamValue, sizeof(ParamValue)); // answer the param request
                UART1_Request_Parameter = FALSE;
        }
        else if(UART1_Request_Echo && (UART1_tx_buffer.Locked == FALSE))
        {
                MKProtocol_CreateSerialFrame(&UART1_tx_buffer, 'Z', NC_ADDRESS, 1, &Echo, sizeof(Echo)); // answer the echo request
                Echo = 0; // reset echo value
                UART1_Request_Echo = FALSE;
        }
        else if(UART1_Request_NewWaypoint && (UART1_tx_buffer.Locked == FALSE))
        {
                u8 WPNumber = WPList_GetCount();
                MKProtocol_CreateSerialFrame(&UART1_tx_buffer, 'W', NC_ADDRESS, 1, &WPNumber, sizeof(WPNumber));
                UART1_Request_NewWaypoint = FALSE;
        }
        else if((UART1_Request_ReadWaypoint != 0xFF) && (UART1_tx_buffer.Locked == FALSE))
        {
                u8 WPNumber = WPList_GetCount();
                if (UART1_Request_ReadWaypoint < WPNumber)
                {
                        MKProtocol_CreateSerialFrame(&UART1_tx_buffer, 'X', NC_ADDRESS, 3, &WPNumber, 1, &UART1_Request_ReadWaypoint, 1, WPList_GetAt(UART1_Request_ReadWaypoint), sizeof(Waypoint_t));
                }
                else
                {
                        MKProtocol_CreateSerialFrame(&UART1_tx_buffer,'X', NC_ADDRESS, 1, &WPNumber, sizeof(WPNumber));
                }
                UART1_Request_ReadWaypoint = 0xFF;
        }
        else if((UART1_Request_DebugLabel != 0xFF) && (UART1_tx_buffer.Locked == FALSE))
        {
                MKProtocol_CreateSerialFrame(&UART1_tx_buffer, 'A', NC_ADDRESS, 2, &UART1_Request_DebugLabel, sizeof(UART1_Request_DebugLabel), (u8 *) ANALOG_LABEL[UART1_Request_DebugLabel], 16);
                UART1_Request_DebugLabel = 0xFF;
        }
        else if(( ((UART1_NaviData_Interval > 0) && CheckDelay(UART1_NaviData_Timer) ) || UART1_Request_NaviData) && (UART1_tx_buffer.Locked == FALSE))
        {
                NaviData.Errorcode = ErrorCode;
                MKProtocol_CreateSerialFrame(&UART1_tx_buffer, 'O', NC_ADDRESS,1, (u8 *)&NaviData, sizeof(NaviData));
                UART1_NaviData_Timer = SetDelay(UART1_NaviData_Interval);
                UART1_Request_NaviData = FALSE;
        }
        else if( (( (UART1_DebugData_Interval > 0) && CheckDelay(UART1_DebugData_Timer)) || UART1_Request_DebugData) && (UART1_tx_buffer.Locked == FALSE))
        {
                MKProtocol_CreateSerialFrame(&UART1_tx_buffer, 'D', NC_ADDRESS, 1,(u8 *)&DebugOut, sizeof(DebugOut));
                UART1_DebugData_Timer = SetDelay(UART1_DebugData_Interval);
                UART1_Request_DebugData = FALSE;
        }
        else if((( (UART1_Data3D_Interval > 0) && CheckDelay(UART1_Data3D_Timer) ) || UART1_Request_Data3D) && (UART1_tx_buffer.Locked == FALSE))
        {
                MKProtocol_CreateSerialFrame(&UART1_tx_buffer, 'C', NC_ADDRESS, 1,(u8 *)&Data3D, sizeof(Data3D));
                UART1_Data3D_Timer = SetDelay(UART1_Data3D_Interval);
                UART1_Request_Data3D = FALSE;
        }
        /*
        else if(UART1_ConfirmFrame && (UART1_tx_buffer.Locked == FALSE))
        {
                MKProtocol_CreateSerialFrame(&UART1_tx_buffer, 'B', NC_ADDRESS, 1, &UART1_ConfirmFrame, sizeof(UART1_ConfirmFrame));
                UART1_ConfirmFrame = 0;
        }
        */
        /*
        else if(UART1_Request_ExternalControl && (UART1_tx_buffer.Locked == FALSE))
        {
                MKProtocol_CreateSerialFrame(&UART1_tx_buffer, 'G', NC_ADDRESS, 1, (u8 *)&ExternControl, sizeof(ExternControl));
                UART1_Request_ExternalControl = FALSE;
        }
        */
        else if( (( (UART1_Display_Interval > 0) && CheckDelay(UART1_Display_Timer)) || UART1_Request_Display) && (UART1_tx_buffer.Locked == FALSE))
        {
                if(UART1_DisplayLine > 3)
                {
                        Menu_Update(UART1_DisplayKeys);
                        UART1_DisplayKeys = 0;
                        MKProtocol_CreateSerialFrame(&UART1_tx_buffer, 'H', NC_ADDRESS, 1, (u8*)DisplayBuff, sizeof(DisplayBuff));
                }
                else
                {
                        UART1_DisplayLine = 2;
                        sprintf(text,"!!! incompatible !!!");
                        MKProtocol_CreateSerialFrame(&UART1_tx_buffer, 'H', NC_ADDRESS, 2, &UART1_DisplayLine, sizeof(UART1_DisplayLine), (u8*)&text, 20);
                        if(UART1_DisplayLine++ > 3) UART1_DisplayLine = 0;
                }
                UART1_Display_Timer = SetDelay(UART1_Display_Interval);
                UART1_Request_Display = FALSE;
        }
        else if(UART1_Request_Display1 && (UART1_tx_buffer.Locked == FALSE))
        {
                Menu_Update(0);
                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;
        }
        else if(UART1_Request_VersionInfo && (UART1_tx_buffer.Locked == FALSE))
        {
                MKProtocol_CreateSerialFrame(&UART1_tx_buffer, 'V', NC_ADDRESS,1, (u8 *)&UART_VersionInfo, sizeof(UART_VersionInfo));
                UART1_Request_VersionInfo = FALSE;
        }
        else if(UART1_Request_ErrorMessage && (UART1_tx_buffer.Locked == FALSE))
        {
                MKProtocol_CreateSerialFrame(&UART1_tx_buffer, 'E', NC_ADDRESS, 1, (u8 *)&ErrorMSG, sizeof(ErrorMSG));
                UART1_Request_ErrorMessage = FALSE;
        }
        else if(UART1_Request_SendFollowMe && (UART1_tx_buffer.Locked == FALSE) && (GPSData.NumOfSats >= 4))              // sending for "Follow me"
        {
                GPS_CopyPosition(&(GPSData.Position),&(FollowMe.Position));
                FollowMe.Position.Status = NEWDATA;
                FollowMe.Heading = -1;
                FollowMe.ToleranceRadius = 1;
                FollowMe.HoldTime = 60;
                FollowMe.Event_Flag = 0;
                FollowMe.Index = 1;
                FollowMe.reserve[0] = 0;                // reserve
                FollowMe.reserve[1] = 0;                // reserve
                FollowMe.reserve[2] = 0;                // reserve
                FollowMe.reserve[3] = 0;                // reserve
                MKProtocol_CreateSerialFrame(&UART1_tx_buffer, 's', NC_ADDRESS, 1, (u8 *)&FollowMe, sizeof(FollowMe));
                UART1_Request_SendFollowMe = FALSE;
        }
        UART1_Transmit(); // output pending bytes in tx buffer
}
 
 

Rev 201	Rev 212
1	/#######################################################################################/	1	/#######################################################################################/
2	/* !!! THIS IS NOT FREE SOFTWARE !!! */	2	/* !!! THIS IS NOT FREE SOFTWARE !!! */
3	/#######################################################################################/	3	/#######################################################################################/
4	// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++	4	// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
5	// + Copyright (c) 2008 Ingo Busker, Holger Buss	5	// + Copyright (c) 2008 Ingo Busker, Holger Buss
6	// + Nur für den privaten Gebrauch / NON-COMMERCIAL USE ONLY	6	// + Nur für den privaten Gebrauch / NON-COMMERCIAL USE ONLY
7	// + FOR NON COMMERCIAL USE ONLY	7	// + FOR NON COMMERCIAL USE ONLY
8	// + www.MikroKopter.com	8	// + www.MikroKopter.com
9	// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++	9	// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
10	// + Es gilt für das gesamte Projekt (Hardware, Software, Binärfiles, Sourcecode und Dokumentation),	10	// + Es gilt für das gesamte Projekt (Hardware, Software, Binärfiles, Sourcecode und Dokumentation),
11	// + dass eine Nutzung (auch auszugsweise) nur für den privaten (nicht-kommerziellen) Gebrauch zulässig ist.	11	// + dass eine Nutzung (auch auszugsweise) nur für den privaten (nicht-kommerziellen) Gebrauch zulässig ist.
12	// + Sollten direkte oder indirekte kommerzielle Absichten verfolgt werden, ist mit uns (info@mikrokopter.de) Kontakt	12	// + Sollten direkte oder indirekte kommerzielle Absichten verfolgt werden, ist mit uns (info@mikrokopter.de) Kontakt
13	// + bzgl. der Nutzungsbedingungen aufzunehmen.	13	// + bzgl. der Nutzungsbedingungen aufzunehmen.
14	// + Eine kommerzielle Nutzung ist z.B.Verkauf von MikroKoptern, Bestückung und Verkauf von Platinen oder Bausätzen,	14	// + Eine kommerzielle Nutzung ist z.B.Verkauf von MikroKoptern, Bestückung und Verkauf von Platinen oder Bausätzen,
15	// + Verkauf von Luftbildaufnahmen, usw.	15	// + Verkauf von Luftbildaufnahmen, usw.
16	// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++	16	// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
17	// + Werden Teile des Quellcodes (mit oder ohne Modifikation) weiterverwendet oder veröffentlicht,	17	// + Werden Teile des Quellcodes (mit oder ohne Modifikation) weiterverwendet oder veröffentlicht,
18	// + unterliegen sie auch diesen Nutzungsbedingungen und diese Nutzungsbedingungen incl. Copyright müssen dann beiliegen	18	// + unterliegen sie auch diesen Nutzungsbedingungen und diese Nutzungsbedingungen incl. Copyright müssen dann beiliegen
19	// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++	19	// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
20	// + Sollte die Software (auch auszugesweise) oder sonstige Informationen des MikroKopter-Projekts	20	// + Sollte die Software (auch auszugesweise) oder sonstige Informationen des MikroKopter-Projekts
21	// + auf anderen Webseiten oder sonstigen Medien veröffentlicht werden, muss unsere Webseite "http://www.mikrokopter.de"	21	// + auf anderen Webseiten oder sonstigen Medien veröffentlicht werden, muss unsere Webseite "http://www.mikrokopter.de"
22	// + eindeutig als Ursprung verlinkt werden	22	// + eindeutig als Ursprung verlinkt werden
23	// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++	23	// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
24	// + Keine Gewähr auf Fehlerfreiheit, Vollständigkeit oder Funktion	24	// + Keine Gewähr auf Fehlerfreiheit, Vollständigkeit oder Funktion
25	// + Benutzung auf eigene Gefahr	25	// + Benutzung auf eigene Gefahr
26	// + Wir übernehmen keinerlei Haftung für direkte oder indirekte Personen- oder Sachschäden	26	// + Wir übernehmen keinerlei Haftung für direkte oder indirekte Personen- oder Sachschäden
27	// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++	27	// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
28	// + Die Portierung oder Nutzung der Software (oder Teile davon) auf andere Systeme (ausser der Hardware von www.mikrokopter.de) ist nur	28	// + Die Portierung oder Nutzung der Software (oder Teile davon) auf andere Systeme (ausser der Hardware von www.mikrokopter.de) ist nur
29	// + mit unserer Zustimmung zulässig	29	// + mit unserer Zustimmung zulässig
30	// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++	30	// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
31	// + Die Funktion printf_P() unterliegt ihrer eigenen Lizenz und ist hiervon nicht betroffen	31	// + Die Funktion printf_P() unterliegt ihrer eigenen Lizenz und ist hiervon nicht betroffen
32	// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++	32	// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
33	// + Redistributions of source code (with or without modifications) must retain the above copyright notice,	33	// + Redistributions of source code (with or without modifications) must retain the above copyright notice,
34	// + this list of conditions and the following disclaimer.	34	// + this list of conditions and the following disclaimer.
35	// + * Neither the name of the copyright holders nor the names of contributors may be used to endorse or promote products derived	35	// + * Neither the name of the copyright holders nor the names of contributors may be used to endorse or promote products derived
36	// + from this software without specific prior written permission.	36	// + from this software without specific prior written permission.
37	// + * The use of this project (hardware, software, binary files, sources and documentation) is only permitted	37	// + * The use of this project (hardware, software, binary files, sources and documentation) is only permitted
38	// + for non-commercial use (directly or indirectly)	38	// + for non-commercial use (directly or indirectly)
39	// + Commercial use (for excample: selling of MikroKopters, selling of PCBs, assembly, ...) is only permitted	39	// + Commercial use (for excample: selling of MikroKopters, selling of PCBs, assembly, ...) is only permitted
40	// + with our written permission	40	// + with our written permission
41	// + * If sources or documentations are redistributet on other webpages, out webpage (http://www.MikroKopter.de) must be	41	// + * If sources or documentations are redistributet on other webpages, out webpage (http://www.MikroKopter.de) must be
42	// + clearly linked as origin	42	// + clearly linked as origin
43	// + * porting the sources to other systems or using the software on other systems (except hardware from www.mikrokopter.de) is not allowed	43	// + * porting the sources to other systems or using the software on other systems (except hardware from www.mikrokopter.de) is not allowed
44	//	44	//
45	// + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"	45	// + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
46	// + AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE	46	// + AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
47	// + IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE	47	// + IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
48	// + ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE	48	// + ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
49	// + LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR	49	// + LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
50	// + CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF	50	// + CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
51	// + SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS	51	// + SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
52	// + INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN	52	// + INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
53	// + CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)	53	// + CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
54	// + ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE	54	// + ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
55	// + POSSIBILITY OF SUCH DAMAGE.	55	// + POSSIBILITY OF SUCH DAMAGE.
56	// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++	56	// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
57	#include <stdio.h>	57	#include <stdio.h>
58	#include <stdarg.h>	58	#include <stdarg.h>
59	#include <string.h>	59	#include <string.h>
60		60
61	#include "91x_lib.h"	61	#include "91x_lib.h"
62	#include "config.h"	62	#include "config.h"
63	#include "menu.h"	63	#include "menu.h"
64	#include "GPS.h"	64	#include "GPS.h"
65	#include "i2c.h"	65	#include "i2c.h"
66	#include "uart0.h"	66	#include "uart0.h"
67	#include "uart1.h"	67	#include "uart1.h"
68	#include "uart2.h"	68	#include "uart2.h"
69	#include "timer1.h"	69	#include "timer1.h"
70	#include "timer2.h"	70	#include "timer2.h"
71	#include "analog.h"	71	#include "analog.h"
72	#include "main.h"	72	#include "main.h"
73	#include "waypoints.h"	73	#include "waypoints.h"
74	#include "mkprotocol.h"	74	#include "mkprotocol.h"
75	#include "params.h"	75	#include "params.h"
76	#include "fifo.h"	76	#include "fifo.h"
77		77
78	#define FALSE 0	78	#define FALSE 0
79	#define TRUE 1	79	#define TRUE 1
80		80
81	#define ABO_TIMEOUT 4000 // disable abo after 4 seconds	81	#define ABO_TIMEOUT 4000 // disable abo after 4 seconds
82	u32 UART1_AboTimeOut = 0;	82	u32 UART1_AboTimeOut = 0;
83		83
84	u8 UART1_Request_VersionInfo = FALSE;	84	u8 UART1_Request_VersionInfo = FALSE;
85	u8 UART1_Request_SendFollowMe = FALSE;	85	u8 UART1_Request_SendFollowMe = FALSE;
86	u8 UART1_Request_ExternalControl= FALSE;	86	u8 UART1_Request_ExternalControl= FALSE;
87	u8 UART1_Request_Display = FALSE;	87	u8 UART1_Request_Display = FALSE;
88	u8 UART1_Request_Display1 = FALSE;	88	u8 UART1_Request_Display1 = FALSE;
89	u8 UART1_Request_DebugData = FALSE;	89	u8 UART1_Request_DebugData = FALSE;
90	u8 UART1_Request_DebugLabel = 255;	90	u8 UART1_Request_DebugLabel = 255;
91	u8 UART1_Request_NaviData = FALSE;	91	u8 UART1_Request_NaviData = FALSE;
92	u8 UART1_Request_ErrorMessage = FALSE;	92	u8 UART1_Request_ErrorMessage = FALSE;
93	u8 UART1_Request_NewWaypoint = FALSE;	93	u8 UART1_Request_NewWaypoint = FALSE;
94	u8 UART1_Request_ReadWaypoint = 255;	94	u8 UART1_Request_ReadWaypoint = 255;
95	u8 UART1_Request_Data3D = FALSE;	95	u8 UART1_Request_Data3D = FALSE;
96	u8 UART1_Request_Echo = FALSE;	96	u8 UART1_Request_Echo = FALSE;
97	u8 UART1_Request_ParameterId = 0;	97	u8 UART1_Request_ParameterId = 0;
98	u8 UART1_Request_Parameter = FALSE;	98	u8 UART1_Request_Parameter = FALSE;
99	u8 UART1_DisplayKeys = 0;	99	u8 UART1_DisplayKeys = 0;
100	u8 UART1_DisplayLine = 0;	100	u8 UART1_DisplayLine = 0;
101	u8 UART1_ConfirmFrame = 0;	101	u8 UART1_ConfirmFrame = 0;
102		102
103	UART_TypeDef *DebugUART = UART1;	103	UART_TypeDef *DebugUART = UART1;
104		104
105	// the primary rx fifo	105	// the primary rx fifo
106	#define UART1_RX_FIFO_LEN 1024	106	#define UART1_RX_FIFO_LEN 1024
107	u8 UART1_rxfifobuffer[UART1_RX_FIFO_LEN];	107	u8 UART1_rxfifobuffer[UART1_RX_FIFO_LEN];
108	fifo_t UART1_rx_fifo;	108	fifo_t UART1_rx_fifo;
109		109
110	// the rx buffer	110	// the rx buffer
111	#define UART1_RX_BUFFER_LEN 150	111	#define UART1_RX_BUFFER_LEN 150
112	u8 UART1_rbuffer[UART1_RX_BUFFER_LEN];	112	u8 UART1_rbuffer[UART1_RX_BUFFER_LEN];
113	Buffer_t UART1_rx_buffer;	113	Buffer_t UART1_rx_buffer;
114		114
115	// the tx buffer	115	// the tx buffer
116	#define UART1_TX_BUFFER_LEN 150	116	#define UART1_TX_BUFFER_LEN 150
117	u8 UART1_tbuffer[UART1_TX_BUFFER_LEN];	117	u8 UART1_tbuffer[UART1_TX_BUFFER_LEN];
118	Buffer_t UART1_tx_buffer;	118	Buffer_t UART1_tx_buffer;
119		119
120		120
121		121
122	volatile u8 SerialLinkOkay = 0;	122	volatile u8 SerialLinkOkay = 0;
123		123
124	u8 text[200];	124	u8 text[200];
125		125
126	const u8 ANALOG_LABEL[32][16] =	126	const u8 ANALOG_LABEL[32][16] =
127	{	127	{
128	//1234567890123456	128	//1234567890123456
129	"AngleNick ", //0	129	"AngleNick ", //0
130	"AngleRoll ",	130	"AngleRoll ",
131	"AccNick ",	131	"AccNick ",
132	"AccRoll ",	132	"AccRoll ",
133	" ",	133	" ",
134	"FC-Flags ", //5	134	"FC-Flags ", //5
135	"NC-Flags ",	135	"NC-Flags ",
136	"NickServo ",	136	"NickServo ",
137	"RollServo ",	137	"RollServo ",
138	"GPS Data ",	138	"GPS Data ",
139	"CompassHeading ", //10	139	"CompassHeading ", //10
140	"GyroHeading ",	140	"GyroHeading ",
141	"SPI Error ",	141	"SPI Error ",
142	"SPI Okay ",	142	"SPI Okay ",
143	"I2C Error ",	143	"I2C Error ",
144	"I2C Okay ", //15	144	"I2C Okay ", //15
145	" ",// "Kalman_K ",	145	" ",// "Kalman_K ",
146	"ACC_Speed_N ",	146	"ACC_Speed_N ",
147	"ACC_Speed_E ",	147	"ACC_Speed_E ",
148	"Speed_z ",// "GPS ACC ",	148	"Speed_z ",// "GPS ACC ",
149	" ",// "MAXDrift ", //20	149	" ",// "MAXDrift ", //20
150	"N_Speed ",	150	"N_Speed ",
151	"E_Speed ",	151	"E_Speed ",
152	"P-Part ",	152	"P-Part ",
153	"I-Part ",	153	"I-Part ",
154	"D-Part ",//25	154	"D-Part ",//25
155	"PID-Part ",	155	"PID-Part ",
156	"Distance N ",	156	"Distance N ",
157	"Distance E ",	157	"Distance E ",
158	"GPS_Nick ",	158	"GPS_Nick ",
159	"GPS_Roll ", //30	159	"GPS_Roll ", //30
160	"Used_Sats "	160	"Used_Sats "
161	};	161	};
162		162
163	DebugOut_t DebugOut;	163	DebugOut_t DebugOut;
164	ExternControl_t ExternControl;	164	ExternControl_t ExternControl;
165	UART_VersionInfo_t UART_VersionInfo;	165	UART_VersionInfo_t UART_VersionInfo;
166	NaviData_t NaviData;	166	NaviData_t NaviData;
167	Waypoint_t FollowMe;	167	Waypoint_t FollowMe;
168	Data3D_t Data3D;	168	Data3D_t Data3D;
169	u16 Echo; // 2 bytes recieved will be sent back as echo	169	u16 Echo; // 2 bytes recieved will be sent back as echo
170		170
171	u32 UART1_DebugData_Timer = 0;	171	u32 UART1_DebugData_Timer = 0;
172	u32 UART1_DebugData_Interval = 0; // in ms	172	u32 UART1_DebugData_Interval = 0; // in ms
173	u32 UART1_NaviData_Timer = 0;	173	u32 UART1_NaviData_Timer = 0;
174	u32 UART1_NaviData_Interval = 0; // in ms	174	u32 UART1_NaviData_Interval = 0; // in ms
175	u32 UART1_Data3D_Timer = 0;	175	u32 UART1_Data3D_Timer = 0;
176	u32 UART1_Data3D_Interval = 0; // in ms	176	u32 UART1_Data3D_Interval = 0; // in ms
177	u32 UART1_Display_Timer = 0;	177	u32 UART1_Display_Timer = 0;
178	u32 UART1_Display_Interval = 0; // in ms	178	u32 UART1_Display_Interval = 0; // in ms
179		179
180	/********************************************************/	180	/********************************************************/
181	/* Initialization the UART1 */	181	/* Initialization the UART1 */
182	/********************************************************/	182	/********************************************************/
183	void UART1_Init (void)	183	void UART1_Init (void)
184	{	184	{
185	GPIO_InitTypeDef GPIO_InitStructure;	185	GPIO_InitTypeDef GPIO_InitStructure;
186	UART_InitTypeDef UART_InitStructure;	186	UART_InitTypeDef UART_InitStructure;
187		187
188	// initialize txd buffer	188	// initialize txd buffer
189	Buffer_Init(&UART1_tx_buffer, UART1_tbuffer, UART1_TX_BUFFER_LEN);	189	Buffer_Init(&UART1_tx_buffer, UART1_tbuffer, UART1_TX_BUFFER_LEN);
190		190
191	// initialize rxd buffer	191	// initialize rxd buffer
192	Buffer_Init(&UART1_rx_buffer, UART1_rbuffer, UART1_RX_BUFFER_LEN);	192	Buffer_Init(&UART1_rx_buffer, UART1_rbuffer, UART1_RX_BUFFER_LEN);
193		193
194	// initialize the rx fifo	194	// initialize the rx fifo
195	fifo_init(&UART1_rx_fifo, UART1_rxfifobuffer, UART1_RX_FIFO_LEN);	195	fifo_init(&UART1_rx_fifo, UART1_rxfifobuffer, UART1_RX_FIFO_LEN);
196		196
197	SCU_APBPeriphClockConfig(__UART1, ENABLE); // Enable the UART1 Clock	197	SCU_APBPeriphClockConfig(__UART1, ENABLE); // Enable the UART1 Clock
198	SCU_APBPeriphClockConfig(__GPIO3, ENABLE); // Enable the GPIO3 Clock	198	SCU_APBPeriphClockConfig(__GPIO3, ENABLE); // Enable the GPIO3 Clock
199		199
200	/Configure UART1_Rx pin GPIO3.2/	200	/Configure UART1_Rx pin GPIO3.2/
201	GPIO_StructInit(&GPIO_InitStructure);	201	GPIO_StructInit(&GPIO_InitStructure);
202	GPIO_InitStructure.GPIO_Direction = GPIO_PinInput;	202	GPIO_InitStructure.GPIO_Direction = GPIO_PinInput;
203	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2;	203	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2;
204	GPIO_InitStructure.GPIO_Type = GPIO_Type_PushPull;	204	GPIO_InitStructure.GPIO_Type = GPIO_Type_PushPull;
205	GPIO_InitStructure.GPIO_IPInputConnected = GPIO_IPInputConnected_Enable;	205	GPIO_InitStructure.GPIO_IPInputConnected = GPIO_IPInputConnected_Enable;
206	GPIO_InitStructure.GPIO_Alternate = GPIO_InputAlt1; // UART1_RxD	206	GPIO_InitStructure.GPIO_Alternate = GPIO_InputAlt1; // UART1_RxD
207	GPIO_Init(GPIO3, &GPIO_InitStructure);	207	GPIO_Init(GPIO3, &GPIO_InitStructure);
208		208
209	/Configure UART1_Tx pin GPIO3.3/	209	/Configure UART1_Tx pin GPIO3.3/
210	GPIO_StructInit(&GPIO_InitStructure);	210	GPIO_StructInit(&GPIO_InitStructure);
211	GPIO_InitStructure.GPIO_Direction = GPIO_PinOutput;	211	GPIO_InitStructure.GPIO_Direction = GPIO_PinOutput;
212	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_3;	212	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_3;
213	GPIO_InitStructure.GPIO_Type = GPIO_Type_PushPull;	213	GPIO_InitStructure.GPIO_Type = GPIO_Type_PushPull;
214	GPIO_InitStructure.GPIO_Alternate = GPIO_OutputAlt2; // UART1_TX	214	GPIO_InitStructure.GPIO_Alternate = GPIO_OutputAlt2; // UART1_TX
215	GPIO_Init(GPIO3, &GPIO_InitStructure);	215	GPIO_Init(GPIO3, &GPIO_InitStructure);
216		216
217	/* UART1 configured as follow:	217	/* UART1 configured as follow:
218	- Word Length = 8 Bits	218	- Word Length = 8 Bits
219	- One Stop Bit	219	- One Stop Bit
220	- No parity	220	- No parity
221	- BaudRate = 57600 baud	221	- BaudRate = 57600 baud
222	- Hardware flow control Disabled	222	- Hardware flow control Disabled
223	- Receive and transmit enabled	223	- Receive and transmit enabled
224	- Receive and transmit FIFOs are Disabled	224	- Receive and transmit FIFOs are Disabled
225	*/	225	*/
226	UART_StructInit(&UART_InitStructure);	226	UART_StructInit(&UART_InitStructure);
227	UART_InitStructure.UART_WordLength = UART_WordLength_8D;	227	UART_InitStructure.UART_WordLength = UART_WordLength_8D;
228	UART_InitStructure.UART_StopBits = UART_StopBits_1;	228	UART_InitStructure.UART_StopBits = UART_StopBits_1;
229	UART_InitStructure.UART_Parity = UART_Parity_No ;	229	UART_InitStructure.UART_Parity = UART_Parity_No ;
230	UART_InitStructure.UART_BaudRate = UART1_BAUD_RATE;	230	UART_InitStructure.UART_BaudRate = UART1_BAUD_RATE;
231	UART_InitStructure. UART_HardwareFlowControl = UART_HardwareFlowControl_None;	231	UART_InitStructure. UART_HardwareFlowControl = UART_HardwareFlowControl_None;
232	UART_InitStructure.UART_Mode = UART_Mode_Tx_Rx;	232	UART_InitStructure.UART_Mode = UART_Mode_Tx_Rx;
233	UART_InitStructure.UART_FIFO = UART_FIFO_Enable;	233	UART_InitStructure.UART_FIFO = UART_FIFO_Enable;
234	UART_InitStructure.UART_TxFIFOLevel = UART_FIFOLevel_1_2;	234	UART_InitStructure.UART_TxFIFOLevel = UART_FIFOLevel_1_2;
235	UART_InitStructure.UART_RxFIFOLevel = UART_FIFOLevel_1_2;	235	UART_InitStructure.UART_RxFIFOLevel = UART_FIFOLevel_1_2;
236		236
237	UART_DeInit(UART1); // reset uart 1 to default	237	UART_DeInit(UART1); // reset uart 1 to default
238	UART_Init(UART1, &UART_InitStructure); // initialize uart 1	238	UART_Init(UART1, &UART_InitStructure); // initialize uart 1
239	// enable uart 1 interrupts selective	239	// enable uart 1 interrupts selective
240	UART_ITConfig(UART1, UART_IT_Receive \| UART_IT_ReceiveTimeOut, ENABLE);	240	UART_ITConfig(UART1, UART_IT_Receive \| UART_IT_ReceiveTimeOut, ENABLE);
241	UART_Cmd(UART1, ENABLE); // enable uart 1	241	UART_Cmd(UART1, ENABLE); // enable uart 1
242	// configure the uart 1 interupt line	242	// configure the uart 1 interupt line
243	VIC_Config(UART1_ITLine, VIC_IRQ, PRIORITY_UART1);	243	VIC_Config(UART1_ITLine, VIC_IRQ, PRIORITY_UART1);
244	// enable the uart 1 IRQ	244	// enable the uart 1 IRQ
245	VIC_ITCmd(UART1_ITLine, ENABLE);	245	VIC_ITCmd(UART1_ITLine, ENABLE);
246		246
247	// initialize the debug timer	247	// initialize the debug timer
248	UART1_DebugData_Timer = SetDelay(UART1_DebugData_Interval);	248	UART1_DebugData_Timer = SetDelay(UART1_DebugData_Interval);
249	UART1_NaviData_Timer = SetDelay(UART1_NaviData_Interval)+500;	249	UART1_NaviData_Timer = SetDelay(UART1_NaviData_Interval)+500;
250		250
251	// Fill Version Info Structure	251	// Fill Version Info Structure
252	UART_VersionInfo.SWMajor = VERSION_MAJOR;	252	UART_VersionInfo.SWMajor = VERSION_MAJOR;
253	UART_VersionInfo.SWMinor = VERSION_MINOR;	253	UART_VersionInfo.SWMinor = VERSION_MINOR;
254	UART_VersionInfo.SWPatch = VERSION_PATCH;	254	UART_VersionInfo.SWPatch = VERSION_PATCH;
255	UART_VersionInfo.ProtoMajor = VERSION_SERIAL_MAJOR;	255	UART_VersionInfo.ProtoMajor = VERSION_SERIAL_MAJOR;
256	UART_VersionInfo.ProtoMinor = VERSION_SERIAL_MINOR;	256	UART_VersionInfo.ProtoMinor = VERSION_SERIAL_MINOR;
257		257
258	NaviData.Version = NAVIDATA_VERSION;	258	NaviData.Version = NAVIDATA_VERSION;
259		259
260	UART1_PutString("\r\nUART1 init...ok");	260	UART1_PutString("\r\n UART1 init...ok");
261	}	261	}
262		262
263		263
264	/****************************************************************/	264	/****************************************************************/
265	/* USART1 receiver ISR */	265	/* USART1 receiver ISR */
266	/****************************************************************/	266	/****************************************************************/
267	void UART1_IRQHandler(void)	267	void UART1_IRQHandler(void)
268	{	268	{
269	static u8 abortState = 0;	269	static u8 abortState = 0;
270	u8 c;	270	u8 c;
271		271
272	IENABLE;	272	IENABLE;
273		273
274	if((UART_GetITStatus(UART1, UART_IT_Receive) != RESET) \|\| (UART_GetITStatus(UART1, UART_IT_ReceiveTimeOut) != RESET) )	274	if((UART_GetITStatus(UART1, UART_IT_Receive) != RESET) \|\| (UART_GetITStatus(UART1, UART_IT_ReceiveTimeOut) != RESET) )
275	{	275	{
276	// clear the pending bits!	276	// clear the pending bits!
277	UART_ClearITPendingBit(UART1, UART_IT_Receive);	277	UART_ClearITPendingBit(UART1, UART_IT_Receive);
278	UART_ClearITPendingBit(UART1, UART_IT_ReceiveTimeOut);	278	UART_ClearITPendingBit(UART1, UART_IT_ReceiveTimeOut);
279	// if debug UART is not UART1	279	// if debug UART is not UART1
280	if (DebugUART != UART1)	280	if (DebugUART != UART1)
281	{ // forward received data to the debug UART tx buffer	281	{ // forward received data to the debug UART tx buffer
282	while(UART_GetFlagStatus(UART1, UART_FLAG_RxFIFOEmpty) != SET)	282	while(UART_GetFlagStatus(UART1, UART_FLAG_RxFIFOEmpty) != SET)
283	{	283	{
284	// move the byte from the rx buffer of UART1 to the tx buffer of DebugUART	284	// move the byte from the rx buffer of UART1 to the tx buffer of DebugUART
285	c = UART_ReceiveData(UART1);	285	c = UART_ReceiveData(UART1);
286		286
287	// check for abort condition (ESC ESC 0x55 0xAA 0x00)	287	// check for abort condition (ESC ESC 0x55 0xAA 0x00)
288	switch (abortState)	288	switch (abortState)
289	{	289	{
290	case 0:	290	case 0:
291	if (c == 27) abortState++;	291	if (c == 27) abortState++;
292	break;	292	break;
293	case 1:	293	case 1:
294	if (c == 27) abortState++;	294	if (c == 27) abortState++;
295	else abortState = 0;	295	else abortState = 0;
296	break;	296	break;
297	case 2:	297	case 2:
298	if (c == 0x55) abortState++;	298	if (c == 0x55) abortState++;
299	else abortState = 0;	299	else abortState = 0;
300	break;	300	break;
301	case 3:	301	case 3:
302	if (c == 0xAA) abortState++;	302	if (c == 0xAA) abortState++;
303	else abortState = 0;	303	else abortState = 0;
304	break;	304	break;
305	case 4:	305	case 4:
306	if (c == 0x00)	306	if (c == 0x00)
307	{	307	{
308	if(DebugUART == UART0)	308	if(DebugUART == UART0)
309	{	309	{
310	UART0_Connect_to_MKGPS();	310	UART0_Connect_to_MKGPS();
311	TIMER2_Init(); // enbable servo outputs	311	TIMER2_Init(); // enbable servo outputs
312	fifo_purge(&UART1_rx_fifo); // flush the whole fifo init buffer	312	fifo_purge(&UART1_rx_fifo); // flush the whole fifo init buffer
313	}	313	}
314	DebugUART = UART1;	314	DebugUART = UART1;
315	}	315	}
316	abortState = 0;	316	abortState = 0;
317	break;	317	break;
318	} // end switch abort state	318	} // end switch abort state
319	// if the Debug uart is not UART1, redirect input to the Debug UART	319	// if the Debug uart is not UART1, redirect input to the Debug UART
320	if (DebugUART != UART1)	320	if (DebugUART != UART1)
321	{	321	{
322	// wait for space in the tx buffer of the DebugUART	322	// wait for space in the tx buffer of the DebugUART
323	while(UART_GetFlagStatus(DebugUART, UART_FLAG_TxFIFOFull) == SET) {};	323	while(UART_GetFlagStatus(DebugUART, UART_FLAG_TxFIFOFull) == SET) {};
324	// move byte to the tx fifo of the debug uart	324	// move byte to the tx fifo of the debug uart
325	UART_SendData(DebugUART, c);	325	UART_SendData(DebugUART, c);
326	}	326	}
327	}	327	}
328	}	328	}
329	else // DebugUART == UART1 (normal operation)	329	else // DebugUART == UART1 (normal operation)
330	{	330	{
331	while(UART_GetFlagStatus(UART1, UART_FLAG_RxFIFOEmpty) != SET)	331	while(UART_GetFlagStatus(UART1, UART_FLAG_RxFIFOEmpty) != SET)
332	{ // some byes in the hardware fifo	332	{ // some byes in the hardware fifo
333	// get byte from hardware fifo	333	// get byte from hardware fifo
334	c = UART_ReceiveData(UART1);	334	c = UART_ReceiveData(UART1);
335	// put into the software fifo	335	// put into the software fifo
336	if(!fifo_put(&UART1_rx_fifo, c))	336	if(!fifo_put(&UART1_rx_fifo, c))
337	{ // fifo overflow	337	{ // fifo overflow
338	//fifo_purge(&UART1_rx_fifo); // flush the whole buffer	338	//fifo_purge(&UART1_rx_fifo); // flush the whole buffer
339	}	339	}
340	} // EOF while some byes in the hardware fifo	340	} // EOF while some byes in the hardware fifo
341	} // eof DebugUart = UART1	341	} // eof DebugUart = UART1
342	}	342	}
343		343
344	IDISABLE;	344	IDISABLE;
345	}	345	}
346		346
347	/**************************************************************/	347	/**************************************************************/
348	/* Process incomming data from debug uart */	348	/* Process incomming data from debug uart */
349	/**************************************************************/	349	/**************************************************************/
350	void UART1_ProcessRxData(void)	350	void UART1_ProcessRxData(void)
351	{	351	{
352	// return on forwarding uart or unlocked rx buffer	352	// return on forwarding uart or unlocked rx buffer
353	if(DebugUART != UART1) return;	353	if(DebugUART != UART1) return;
354		354
355	u8 c;	355	u8 c;
356	// if rx buffer is not locked	356	// if rx buffer is not locked
357	if(UART1_rx_buffer.Locked == FALSE)	357	if(UART1_rx_buffer.Locked == FALSE)
358	{ //collect data from primary rx fifo	358	{ //collect data from primary rx fifo
359	while(fifo_get(&UART1_rx_fifo, &c))	359	while(fifo_get(&UART1_rx_fifo, &c))
360	{ // break if complete frame is collected	360	{ // break if complete frame is collected
361	if(MKProtocol_CollectSerialFrame(&UART1_rx_buffer, c)) break;	361	if(MKProtocol_CollectSerialFrame(&UART1_rx_buffer, c)) break;
362	}	362	}
363	}	363	}
364	if(UART1_rx_buffer.Locked == FALSE) return;	364	if(UART1_rx_buffer.Locked == FALSE) return;
365		365
366	Waypoint_t * pWaypoint = NULL;	366	Waypoint_t * pWaypoint = NULL;
367	SerialMsg_t SerialMsg;	367	SerialMsg_t SerialMsg;
368		368
369	// analyze header first	369	// analyze header first
370	MKProtocol_DecodeSerialFrameHeader(&UART1_rx_buffer, &SerialMsg);	370	MKProtocol_DecodeSerialFrameHeader(&UART1_rx_buffer, &SerialMsg);
371	if( SerialMsg.Address == FC_ADDRESS )	371	if( SerialMsg.Address == FC_ADDRESS )
372	{	372	{
373	switch(SerialMsg.CmdID)	373	switch(SerialMsg.CmdID)
374	{	374	{
375	case 'y': // serial poti values	375	case 'y': // serial poti values
376	case 'b': // extern control	376	case 'b': // extern control
377	Buffer_Copy(&UART1_rx_buffer, &UART2_tx_buffer); //forward to FC	377	Buffer_Copy(&UART1_rx_buffer, &UART2_tx_buffer); //forward to FC
378	Buffer_Clear(&UART1_rx_buffer); // free rc buffer for next frame	378	Buffer_Clear(&UART1_rx_buffer); // free rc buffer for next frame
379	return; //end process rx data	379	return; //end process rx data
380	break;	380	break;
381	}	381	}
382	}	382	}
383		383
384	MKProtocol_DecodeSerialFrameData(&UART1_rx_buffer, &SerialMsg); // decode serial frame in rxd buffer	384	MKProtocol_DecodeSerialFrameData(&UART1_rx_buffer, &SerialMsg); // decode serial frame in rxd buffer
385	if(SerialMsg.CmdID != 'z') SerialLinkOkay = 250; // reset SerialTimeout, but not in case of the "ping"	385	if(SerialMsg.CmdID != 'z') SerialLinkOkay = 250; // reset SerialTimeout, but not in case of the "ping"
386	switch(SerialMsg.Address) // check for Slave Address	386	switch(SerialMsg.Address) // check for Slave Address
387	{	387	{
388	case NC_ADDRESS: // own Slave Address	388	case NC_ADDRESS: // own Slave Address
389	switch(SerialMsg.CmdID)	389	switch(SerialMsg.CmdID)
390	{	390	{
391	case 'z': // connection checker	391	case 'z': // connection checker
392	memcpy(&Echo, SerialMsg.pData, sizeof(Echo)); // copy echo pattern	392	memcpy(&Echo, SerialMsg.pData, sizeof(Echo)); // copy echo pattern
393	UART1_Request_Echo = TRUE;	393	UART1_Request_Echo = TRUE;
394	break;	394	break;
395		395
396	case 'e': // request for the text of the error status	396	case 'e': // request for the text of the error status
397	UART1_Request_ErrorMessage = TRUE;	397	UART1_Request_ErrorMessage = TRUE;
398	break;	398	break;
399		399
400	case 's':// new target position	400	case 's':// new target position
401	pWaypoint = (Waypoint_t*)SerialMsg.pData;	401	pWaypoint = (Waypoint_t*)SerialMsg.pData;
402	BeepTime = 300;	402	BeepTime = 300;
403	if(pWaypoint->Position.Status == NEWDATA)	403	if(pWaypoint->Position.Status == NEWDATA)
404	{	404	{
405	WPList_Clear(); // empty WPList	405	WPList_Clear(); // empty WPList
406	WPList_Append(pWaypoint);	406	WPList_Append(pWaypoint);
407	GPS_pWaypoint = WPList_Begin();	407	GPS_pWaypoint = WPList_Begin();
408	}	408	}
409	break;	409	break;
410		410
411	case 'u': // redirect debug uart	411	case 'u': // redirect debug uart
412	switch(SerialMsg.pData[0])	412	switch(SerialMsg.pData[0])
413	{	413	{
414	case UART_FLIGHTCTRL:	414	case UART_FLIGHTCTRL:
415	UART2_Init(); // initialize UART2 to FC pins	415	UART2_Init(); // initialize UART2 to FC pins
416	fifo_purge(&UART1_rx_fifo);	416	fifo_purge(&UART1_rx_fifo);
417	TIMER2_Deinit(); // reduce irq load	417	TIMER2_Deinit(); // reduce irq load
418	DebugUART = UART2;	418	DebugUART = UART2;
419	break;	419	break;
420	case UART_MK3MAG:	420	case UART_MK3MAG:
421	if(FC.Flags & FCFLAG_MOTOR_RUN) break; // not if the motors are running	421	if(FC.Flags & FCFLAG_MOTOR_RUN) break; // not if the motors are running
422	UART0_Connect_to_MK3MAG(); // mux UART0 to MK3MAG pins	422	UART0_Connect_to_MK3MAG(); // mux UART0 to MK3MAG pins
423	GPSData.Status = INVALID;	423	GPSData.Status = INVALID;
424	fifo_purge(&UART1_rx_fifo);	424	fifo_purge(&UART1_rx_fifo);
425	DebugUART = UART0;	425	DebugUART = UART0;
426	break;	426	break;
427	case UART_MKGPS:	427	case UART_MKGPS:
428	if(FC.Flags & FCFLAG_MOTOR_RUN) break; // not if the motors are running	428	if(FC.Flags & FCFLAG_MOTOR_RUN) break; // not if the motors are running
429	TIMER2_Deinit(); // disable servo outputs to reduce irq load	429	TIMER2_Deinit(); // disable servo outputs to reduce irq load
430	UART0_Connect_to_MKGPS(); // connect UART0 to MKGPS pins	430	UART0_Connect_to_MKGPS(); // connect UART0 to MKGPS pins
431	GPSData.Status = INVALID;	431	GPSData.Status = INVALID;
432	fifo_purge(&UART1_rx_fifo);	432	fifo_purge(&UART1_rx_fifo);
433	DebugUART = UART0;	433	DebugUART = UART0;
434	break;	434	break;
435	default:	435	default:
436	break;	436	break;
437	}	437	}
438	break;	438	break;
439		439
440	case 'w':// Append Waypoint to List	440	case 'w':// Append Waypoint to List
441	{	441	{
442	static u8 oldIndex = 0x00;	442	static u8 oldIndex = 0x00;
443		443
444	pWaypoint = (Waypoint_t*)SerialMsg.pData;	444	pWaypoint = (Waypoint_t*)SerialMsg.pData;
445	if(pWaypoint->Position.Status == INVALID)	445	if(pWaypoint->Position.Status == INVALID)
446	{ // clear WP List	446	{ // clear WP List
447	WPList_Clear();	447	WPList_Clear();
448	oldIndex = 0x00;	448	oldIndex = 0x00;
449	GPS_pWaypoint = WPList_Begin();	449	GPS_pWaypoint = WPList_Begin();
450	UART1_Request_NewWaypoint = TRUE;	450	UART1_Request_NewWaypoint = TRUE;
451	}	451	}
452	else if (pWaypoint->Position.Status == NEWDATA)	452	else if (pWaypoint->Position.Status == NEWDATA)
453	{ // app current WP to the list	453	{ // app current WP to the list
454	if (pWaypoint->Index == oldIndex + 1)	454	if (pWaypoint->Index == oldIndex + 1)
455	{	455	{
456	WPList_Append(pWaypoint);	456	WPList_Append(pWaypoint);
457	BeepTime = 500;	457	BeepTime = 500;
458	oldIndex = pWaypoint->Index;	458	oldIndex = pWaypoint->Index;
459	UART1_Request_NewWaypoint = TRUE;	459	UART1_Request_NewWaypoint = TRUE;
460	}	460	}
461	}	461	}
462	}	462	}
463	break;	463	break;
464		464
465	case 'x':// Read Waypoint from List	465	case 'x':// Read Waypoint from List
466	UART1_Request_ReadWaypoint = SerialMsg.pData[0];	466	UART1_Request_ReadWaypoint = SerialMsg.pData[0];
467	break;	467	break;
468		468
469	case 'j':// Set/Get NC-Parameter	469	case 'j':// Set/Get NC-Parameter
470	switch(SerialMsg.pData[0])	470	switch(SerialMsg.pData[0])
471	{	471	{
472	case 0: // get	472	case 0: // get
473	break;	473	break;
474		474
475	case 1: // set	475	case 1: // set
476	{	476	{
477	s16 value;	477	s16 value;
478	value = SerialMsg.pData[2] + (s16)SerialMsg.pData[3] * 0x0100;	478	value = SerialMsg.pData[2] + (s16)SerialMsg.pData[3] * 0x0100;
479	NCParams_SetValue(SerialMsg.pData[1], &value);	479	NCParams_SetValue(SerialMsg.pData[1], &value);
480	}	480	}
481	break;	481	break;
482		482
483	default:	483	default:
484	break;	484	break;
485	}	485	}
486	UART1_Request_ParameterId = SerialMsg.pData[1];	486	UART1_Request_ParameterId = SerialMsg.pData[1];
487	UART1_Request_Parameter = TRUE;	487	UART1_Request_Parameter = TRUE;
488	break;	488	break;
489	default:	489	default:
490	// unsupported command recieved	490	// unsupported command recieved
491	break;	491	break;
492	} // case NC_ADDRESS	492	} // case NC_ADDRESS
493	// "break;" is missing here to fall thru to the common commands	493	// "break;" is missing here to fall thru to the common commands
494		494
495	default: // and any other Slave Address	495	default: // and any other Slave Address
496		496
497	switch(SerialMsg.CmdID) // check CmdID	497	switch(SerialMsg.CmdID) // check CmdID
498	{	498	{
499	case 'a':// request for the labels of the analog debug outputs	499	case 'a':// request for the labels of the analog debug outputs
500	UART1_Request_DebugLabel = SerialMsg.pData[0];	500	UART1_Request_DebugLabel = SerialMsg.pData[0];

Subversion Repositories NaviCtrl

(root)/tags/V0.22a/uart1.c @ 741 - Rev 201 → 212