WebSVN - NaviCtrl - Diff - Rev 291 and 295


/*#######################################################################################*/
/* !!! 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 "main.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 "compass.h"
#include "waypoints.h"
#include "mkprotocol.h"
#include "params.h"
#include "fifo.h"
#include "debug.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_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_WritePoint             = 0xFF;
u8 UART1_Request_ReadPoint              = 0;
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 512
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         ",
        "OperatingRadius ",
        "FC-Flags        ", //5
        "NC-Flags        ",
        "NickServo       ",
        "RollServo       ",
        "GPS Data        ",
        "CompassHeading  ", //10
        "GyroHeading     ",
        "SPI Error       ",
        "SPI Okay        ",
        "I2C Error       ",
        "I2C Okay        ", //15
        "*POI_INDEX      ",//    "Kalman_K        ",
        "ACC_Speed_N     ",
        "ACC_Speed_E     ",
        "Speed_z         ",//    "GPS ACC         ",
        "*DesiredAltitude",//20
        "N_Speed         ",
        "E_Speed         ",
        "*POI_ALTITUDE   ",
        "*MY_Altitude    ",
        "*AltitudeSpeed  ",//25
        "*CAM-Azimut     ",
        "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;
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, block UART IRQ geting a byte from fifo
        fifo_init(&UART1_rx_fifo, UART1_rxfifobuffer, UART1_RX_FIFO_LEN, NO_ITLine, UART1_ITLine);
 
        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(UART0_BAUD_RATE);
                                                                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;
 
        Point_t * pPoint = NULL;
        SerialMsg_t SerialMsg;
 
        // analyze header first
        MKProtocol_DecodeSerialFrameHeader(&UART1_rx_buffer, &SerialMsg);
        if( SerialMsg.Address == FC_ADDRESS )
        {
                switch(SerialMsg.CmdID)
                {
//                      case 'v': // version
                        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
                                pPoint = (Point_t*)SerialMsg.pData;
                                if(pPoint->Position.Status == NEWDATA)
                                {
 
 
                                        //PointList_Clear(); // flush the list  
                                        pPoint->Index = 1; // must be one after empty list
 
 
 
 
 
 
 
 
 
 
 
 
                                        PointList_SetAt(pPoint); // 
 
 
                                        GPS_pWaypoint = PointList_WPBegin(); // updates POI index
 
 
 
 
 
 
 
 
 
 
 
                                        BeepTime = 50;
 
 
 
 
 
 
 
                                }
                                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.StatusFlags & FC_STATUS_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.StatusFlags & FC_STATUS_MOTOR_RUN) break; // not if the motors are running
                                                TIMER2_Deinit();                        // disable servo outputs to reduce irq load
                                                UART0_Connect_to_MKGPS(UART0_BAUD_RATE);        // connect UART0 to MKGPS pins
                                                GPSData.Status = INVALID;
                                                fifo_purge(&UART1_rx_fifo);
                                                DebugUART = UART0;
                                                break;
                                        default:
                                                break;
                                }
                                break;
 
                        case 'w'://  Set point in list at index
                                {
                                        pPoint = (Point_t*)SerialMsg.pData;
 
                                        if((pPoint->Position.Status == INVALID) && (pPoint->Index == 0))
                                        {
                                                PointList_Clear();
                                                GPS_pWaypoint = PointList_WPBegin();
                                                UART1_Request_WritePoint = 0; // return new point count 
                                        }
                                        else
                                        {  // update WP in list at index
                                                UART1_Request_WritePoint = PointList_SetAt(pPoint);
                                                if(UART1_Request_WritePoint == pPoint->Index)
                                                {
                                                        BeepTime = 500;
 
                                                }
                                        }
                                }
                                break;
 
                        case 'x'://  Read Waypoint from List
                                UART1_Request_ReadPoint = 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 '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_WritePoint!= 0xFF) && (UART1_tx_buffer.Locked == FALSE))
        {
 
                MKProtocol_CreateSerialFrame(&UART1_tx_buffer, 'W', NC_ADDRESS, 1, &UART1_Request_WritePoint, sizeof(UART1_Request_WritePoint));
                UART1_Request_WritePoint = 0xFF;
        }
        else if((UART1_Request_ReadPoint) && (UART1_tx_buffer.Locked == FALSE))
        {
                u8 PointCount = PointList_GetCount();
                if (UART1_Request_ReadPoint <= PointCount)
                {
                        MKProtocol_CreateSerialFrame(&UART1_tx_buffer, 'X', NC_ADDRESS, 3, &PointCount, 1, &UART1_Request_ReadPoint, 1, PointList_GetAt(UART1_Request_ReadPoint), sizeof(Point_t));
                }
                else
                {
                        MKProtocol_CreateSerialFrame(&UART1_tx_buffer,'X', NC_ADDRESS, 1, &PointCount, sizeof(PointCount));
                }
                UART1_Request_ReadPoint = 0;
        }
        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;
        }
#ifdef DEBUG                                                                                                                    // only include functions if DEBUG is defined
        if(SendDebugOutput && (UART1_tx_buffer.Locked == FALSE))
        {
                MKProtocol_CreateSerialFrame(&UART1_tx_buffer,'0', NC_ADDRESS, 1, (u8 *) &tDebug, sizeof(tDebug));
                SendDebugOutput = 0;
        }
#endif  
        UART1_Transmit(); // output pending bytes in tx buffer
}
 
 

Rev 291	Rev 295
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 "main.h"	62	#include "main.h"
63	#include "config.h"	63	#include "config.h"
64	#include "menu.h"	64	#include "menu.h"
65	#include "GPS.h"	65	#include "GPS.h"
66	#include "i2c.h"	66	#include "i2c.h"
67	#include "uart0.h"	67	#include "uart0.h"
68	#include "uart1.h"	68	#include "uart1.h"
69	#include "uart2.h"	69	#include "uart2.h"
70	#include "timer1.h"	70	#include "timer1.h"
71	#include "timer2.h"	71	#include "timer2.h"
72	#include "analog.h"	72	#include "analog.h"
73	#include "compass.h"	73	#include "compass.h"
74	#include "waypoints.h"	74	#include "waypoints.h"
75	#include "mkprotocol.h"	75	#include "mkprotocol.h"
76	#include "params.h"	76	#include "params.h"
77	#include "fifo.h"	77	#include "fifo.h"
78	#include "debug.h"	78	#include "debug.h"
79		79
80	#define FALSE 0	80	#define FALSE 0
81	#define TRUE 1	81	#define TRUE 1
82		82
83	#define ABO_TIMEOUT 4000 // disable abo after 4 seconds	83	#define ABO_TIMEOUT 4000 // disable abo after 4 seconds
84	u32 UART1_AboTimeOut = 0;	84	u32 UART1_AboTimeOut = 0;
85		85
86	u8 UART1_Request_VersionInfo = FALSE;	86	u8 UART1_Request_VersionInfo = FALSE;
87	u8 UART1_Request_ExternalControl= FALSE;	87	u8 UART1_Request_ExternalControl= FALSE;
88	u8 UART1_Request_Display = FALSE;	88	u8 UART1_Request_Display = FALSE;
89	u8 UART1_Request_Display1 = FALSE;	89	u8 UART1_Request_Display1 = FALSE;
90	u8 UART1_Request_DebugData = FALSE;	90	u8 UART1_Request_DebugData = FALSE;
91	u8 UART1_Request_DebugLabel = 255;	91	u8 UART1_Request_DebugLabel = 255;
92	u8 UART1_Request_NaviData = FALSE;	92	u8 UART1_Request_NaviData = FALSE;
93	u8 UART1_Request_ErrorMessage = FALSE;	93	u8 UART1_Request_ErrorMessage = FALSE;
94	u8 UART1_Request_NewPoint = FALSE;	94	u8 UART1_Request_WritePoint = 0xFF;
95	u8 UART1_Request_ReadPoint = 0;	95	u8 UART1_Request_ReadPoint = 0;
96	u8 UART1_Request_Data3D = FALSE;	96	u8 UART1_Request_Data3D = FALSE;
97	u8 UART1_Request_Echo = FALSE;	97	u8 UART1_Request_Echo = FALSE;
98	u8 UART1_Request_ParameterId = 0;	98	u8 UART1_Request_ParameterId = 0;
99	u8 UART1_Request_Parameter = FALSE;	99	u8 UART1_Request_Parameter = FALSE;
100	u8 UART1_DisplayKeys = 0;	100	u8 UART1_DisplayKeys = 0;
101	u8 UART1_DisplayLine = 0;	101	u8 UART1_DisplayLine = 0;
102	u8 UART1_ConfirmFrame = 0;	102	u8 UART1_ConfirmFrame = 0;
103		103
104	UART_TypeDef *DebugUART = UART1;	104	UART_TypeDef *DebugUART = UART1;
105		105
106	// the primary rx fifo	106	// the primary rx fifo
107	#define UART1_RX_FIFO_LEN 512	107	#define UART1_RX_FIFO_LEN 512
108	u8 UART1_rxfifobuffer[UART1_RX_FIFO_LEN];	108	u8 UART1_rxfifobuffer[UART1_RX_FIFO_LEN];
109	fifo_t UART1_rx_fifo;	109	fifo_t UART1_rx_fifo;
110		110
111	// the rx buffer	111	// the rx buffer
112	#define UART1_RX_BUFFER_LEN 150	112	#define UART1_RX_BUFFER_LEN 150
113	u8 UART1_rbuffer[UART1_RX_BUFFER_LEN];	113	u8 UART1_rbuffer[UART1_RX_BUFFER_LEN];
114	Buffer_t UART1_rx_buffer;	114	Buffer_t UART1_rx_buffer;
115		115
116	// the tx buffer	116	// the tx buffer
117	#define UART1_TX_BUFFER_LEN 150	117	#define UART1_TX_BUFFER_LEN 150
118	u8 UART1_tbuffer[UART1_TX_BUFFER_LEN];	118	u8 UART1_tbuffer[UART1_TX_BUFFER_LEN];
119	Buffer_t UART1_tx_buffer;	119	Buffer_t UART1_tx_buffer;
120		120
121		121
122		122
123	volatile u8 SerialLinkOkay = 0;	123	volatile u8 SerialLinkOkay = 0;
124		124
125	u8 text[200];	125	u8 text[200];
126		126
127	const u8 ANALOG_LABEL[32][16] =	127	const u8 ANALOG_LABEL[32][16] =
128	{	128	{
129	//1234567890123456	129	//1234567890123456
130	"AngleNick ", //0	130	"AngleNick ", //0
131	"AngleRoll ",	131	"AngleRoll ",
132	"AccNick ",	132	"AccNick ",
133	"AccRoll ",	133	"AccRoll ",
134	"OperatingRadius ",	134	"OperatingRadius ",
135	"FC-Flags ", //5	135	"FC-Flags ", //5
136	"NC-Flags ",	136	"NC-Flags ",
137	"NickServo ",	137	"NickServo ",
138	"RollServo ",	138	"RollServo ",
139	"GPS Data ",	139	"GPS Data ",
140	"CompassHeading ", //10	140	"CompassHeading ", //10
141	"GyroHeading ",	141	"GyroHeading ",
142	"SPI Error ",	142	"SPI Error ",
143	"SPI Okay ",	143	"SPI Okay ",
144	"I2C Error ",	144	"I2C Error ",
145	"I2C Okay ", //15	145	"I2C Okay ", //15
146	"*POI_INDEX ",// "Kalman_K ",	146	"*POI_INDEX ",// "Kalman_K ",
147	"ACC_Speed_N ",	147	"ACC_Speed_N ",
148	"ACC_Speed_E ",	148	"ACC_Speed_E ",
149	"Speed_z ",// "GPS ACC ",	149	"Speed_z ",// "GPS ACC ",
150	"*DesiredAltitude",//20	150	"*DesiredAltitude",//20
151	"N_Speed ",	151	"N_Speed ",
152	"E_Speed ",	152	"E_Speed ",
153	"*POI_ALTITUDE ",	153	"*POI_ALTITUDE ",
154	"*MY_Altitude ",	154	"*MY_Altitude ",
155	"*AltitudeSpeed ",//25	155	"*AltitudeSpeed ",//25
156	"*CAM-Azimut ",	156	"*CAM-Azimut ",
157	"Distance N ",	157	"Distance N ",
158	"Distance E ",	158	"Distance E ",
159	"GPS_Nick ",	159	"GPS_Nick ",
160	"GPS_Roll ", //30	160	"GPS_Roll ", //30
161	"Used_Sats "	161	"Used_Sats "
162	};	162	};
163		163
164	DebugOut_t DebugOut;	164	DebugOut_t DebugOut;
165	ExternControl_t ExternControl;	165	ExternControl_t ExternControl;
166	UART_VersionInfo_t UART_VersionInfo;	166	UART_VersionInfo_t UART_VersionInfo;
167	NaviData_t NaviData;	167	NaviData_t NaviData;
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, block UART IRQ geting a byte from fifo	194	// initialize the rx fifo, block UART IRQ geting a byte from fifo
195	fifo_init(&UART1_rx_fifo, UART1_rxfifobuffer, UART1_RX_FIFO_LEN, NO_ITLine, UART1_ITLine);	195	fifo_init(&UART1_rx_fifo, UART1_rxfifobuffer, UART1_RX_FIFO_LEN, NO_ITLine, UART1_ITLine);
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\n UART1 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(UART0_BAUD_RATE);	310	UART0_Connect_to_MKGPS(UART0_BAUD_RATE);
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	{	358	{
359	//collect data from primary rx fifo	359	//collect data from primary rx fifo
360	while(fifo_get(&UART1_rx_fifo, &c))	360	while(fifo_get(&UART1_rx_fifo, &c))
361	{	361	{
362	// break if complete frame is collected	362	// break if complete frame is collected
363	if(MKProtocol_CollectSerialFrame(&UART1_rx_buffer, c)) break;	363	if(MKProtocol_CollectSerialFrame(&UART1_rx_buffer, c)) break;
364	}	364	}
365	}	365	}
366	if(UART1_rx_buffer.Locked == FALSE) return;	366	if(UART1_rx_buffer.Locked == FALSE) return;
367		367
368	Point_t * pPoint = NULL;	368	Point_t * pPoint = NULL;
369	SerialMsg_t SerialMsg;	369	SerialMsg_t SerialMsg;
370		370
371	// analyze header first	371	// analyze header first
372	MKProtocol_DecodeSerialFrameHeader(&UART1_rx_buffer, &SerialMsg);	372	MKProtocol_DecodeSerialFrameHeader(&UART1_rx_buffer, &SerialMsg);
373	if( SerialMsg.Address == FC_ADDRESS )	373	if( SerialMsg.Address == FC_ADDRESS )
374	{	374	{
375	switch(SerialMsg.CmdID)	375	switch(SerialMsg.CmdID)
376	{	376	{
377	// case 'v': // version	377	// case 'v': // version
378	case 'y': // serial poti values	378	case 'y': // serial poti values
379	case 'b': // extern control	379	case 'b': // extern control
380	Buffer_Copy(&UART1_rx_buffer, &UART2_tx_buffer); //forward to FC	380	Buffer_Copy(&UART1_rx_buffer, &UART2_tx_buffer); //forward to FC
381	Buffer_Clear(&UART1_rx_buffer); // free rc buffer for next frame	381	Buffer_Clear(&UART1_rx_buffer); // free rc buffer for next frame
382	return; //end process rx data	382	return; //end process rx data
383	break;	383	break;
384	}	384	}
385	}	385	}
386		386
387	MKProtocol_DecodeSerialFrameData(&UART1_rx_buffer, &SerialMsg); // decode serial frame in rxd buffer	387	MKProtocol_DecodeSerialFrameData(&UART1_rx_buffer, &SerialMsg); // decode serial frame in rxd buffer
388	if(SerialMsg.CmdID != 'z') SerialLinkOkay = 250; // reset SerialTimeout, but not in case of the "ping"	388	if(SerialMsg.CmdID != 'z') SerialLinkOkay = 250; // reset SerialTimeout, but not in case of the "ping"
389	switch(SerialMsg.Address) // check for Slave Address	389	switch(SerialMsg.Address) // check for Slave Address
390	{	390	{
391	case NC_ADDRESS: // own Slave Address	391	case NC_ADDRESS: // own Slave Address
392	switch(SerialMsg.CmdID)	392	switch(SerialMsg.CmdID)
393	{	393	{
394	case 'z': // connection checker	394	case 'z': // connection checker
395	memcpy(&Echo, SerialMsg.pData, sizeof(Echo)); // copy echo pattern	395	memcpy(&Echo, SerialMsg.pData, sizeof(Echo)); // copy echo pattern
396	UART1_Request_Echo = TRUE;	396	UART1_Request_Echo = TRUE;
397	break;	397	break;
398		398
399	case 'e': // request for the text of the error status	399	case 'e': // request for the text of the error status
400	UART1_Request_ErrorMessage = TRUE;	400	UART1_Request_ErrorMessage = TRUE;
401	break;	401	break;
402		402
403	case 's':// new target position	403	case 's':// new target position
404	pPoint = (Point_t*)SerialMsg.pData;	404	pPoint = (Point_t*)SerialMsg.pData;
405	if(pPoint->Position.Status == NEWDATA)	405	if(pPoint->Position.Status == NEWDATA)
406	{	406	{
407	if(pPoint->Type == POINT_TYPE_POI)	-
408	{	-
409	PointList_Clear(); // empty List	407	//PointList_Clear(); // flush the list
410	pPoint->Index = 1; // must be one after empty list	408	pPoint->Index = 1; // must be one after empty list
411	POICount = 0;	-
412	PointList_Append(pPoint);	-
413	PointCount = 2;	-
414	BeepTime = 50;	-
415	}	-
416	else	-
417	if(pPoint->Type == POINT_TYPE_WP)	-
418	{	-
419	PointList_Clear(); // empty List	-
420	PointCount = 1;	-
421	pPoint->Index = 2; // No. 1 could be the POI	-
422	WPCount = 0;	-
423	PointList_Append(pPoint);	409	PointList_SetAt(pPoint); //
424	PointCount = 2;	-
425	BeepTime = 50;	-
426	GPS_pWaypoint = PointList_WPBegin();	410	GPS_pWaypoint = PointList_WPBegin(); // updates POI index
427	}	-
428	else	-
429	if(pPoint->Type == POINT_TYPE_BOTH)	-
430	{	-
431	PointList_Clear(); // empty List	-
432	pPoint->Index = 1;	-
433	pPoint->Type = POINT_TYPE_POI;	-
434	PointList_Append(pPoint);	-
435	pPoint->Index = 2;	-
436	pPoint->Type = POINT_TYPE_WP;	-
437	PointList_Append(pPoint);	-
438	BeepTime = 50;	411	BeepTime = 50;
439	GPS_pWaypoint = PointList_WPBegin();	-
440	}	-
441	else	-
442	{	-
443	PointList_Clear(); // empty List	-
444	GPS_pWaypoint = PointList_WPBegin();	-
445	}	-
446	}	412	}
447	break;	413	break;
448		414
449	case 'u': // redirect debug uart	415	case 'u': // redirect debug uart
450	switch(SerialMsg.pData[0])	416	switch(SerialMsg.pData[0])
451	{	417	{
452	case UART_FLIGHTCTRL:	418	case UART_FLIGHTCTRL:
453	UART2_Init(); // initialize UART2 to FC pins	419	UART2_Init(); // initialize UART2 to FC pins
454	fifo_purge(&UART1_rx_fifo);	420	fifo_purge(&UART1_rx_fifo);
455	TIMER2_Deinit(); // reduce irq load	421	TIMER2_Deinit(); // reduce irq load
456	DebugUART = UART2;	422	DebugUART = UART2;
457	break;	423	break;
458	case UART_MK3MAG:	424	case UART_MK3MAG:
459	if(FC.StatusFlags & FC_STATUS_MOTOR_RUN) break; // not if the motors are running	425	if(FC.StatusFlags & FC_STATUS_MOTOR_RUN) break; // not if the motors are running
460	UART0_Connect_to_MK3MAG(); // mux UART0 to MK3MAG pins	426	UART0_Connect_to_MK3MAG(); // mux UART0 to MK3MAG pins
461	GPSData.Status = INVALID;	427	GPSData.Status = INVALID;
462	fifo_purge(&UART1_rx_fifo);	428	fifo_purge(&UART1_rx_fifo);
463	DebugUART = UART0;	429	DebugUART = UART0;
464	break;	430	break;
465	case UART_MKGPS:	431	case UART_MKGPS:
466	if(FC.StatusFlags & FC_STATUS_MOTOR_RUN) break; // not if the motors are running	432	if(FC.StatusFlags & FC_STATUS_MOTOR_RUN) break; // not if the motors are running
467	TIMER2_Deinit(); // disable servo outputs to reduce irq load	433	TIMER2_Deinit(); // disable servo outputs to reduce irq load
468	UART0_Connect_to_MKGPS(UART0_BAUD_RATE); // connect UART0 to MKGPS pins	434	UART0_Connect_to_MKGPS(UART0_BAUD_RATE); // connect UART0 to MKGPS pins
469	GPSData.Status = INVALID;	435	GPSData.Status = INVALID;
470	fifo_purge(&UART1_rx_fifo);	436	fifo_purge(&UART1_rx_fifo);
471	DebugUART = UART0;	437	DebugUART = UART0;
472	break;	438	break;
473	default:	439	default:
474	break;	440	break;
475	}	441	}
476	break;	442	break;
477		443
478	case 'w':// Append Point to List	444	case 'w':// Set point in list at index
479	{	445	{
480	pPoint = (Point_t*)SerialMsg.pData;	446	pPoint = (Point_t*)SerialMsg.pData;
481		447
482	if((pPoint->Position.Status == INVALID) && (pPoint->Index == 0))	448	if((pPoint->Position.Status == INVALID) && (pPoint->Index == 0))
483	{	449	{
484	PointList_Clear();	450	PointList_Clear();
485	GPS_pWaypoint = PointList_WPBegin();	451	GPS_pWaypoint = PointList_WPBegin();
486	UART1_Request_NewPoint = TRUE; // return new point count	452	UART1_Request_WritePoint = 0; // return new point count
487	}	453	}
488	else	454	else
489	{ // app current WP to the list	455	{ // update WP in list at index
-		456	UART1_Request_WritePoint = PointList_SetAt(pPoint);
490	if(PointList_Append(pPoint))	457	if(UART1_Request_WritePoint == pPoint->Index)
491	{	458	{
492	BeepTime = 500;	459	BeepTime = 500;
493	UART1_Request_NewPoint = TRUE; // return new WP number	-
494	}	460	}
495	}	461	}
496	}	462	}
497	break;	463	break;
498		464
499	case 'x':// Read Waypoint from List	465	case 'x':// Read Waypoint from List

Subversion Repositories NaviCtrl

(root)/tags/V0.28o/uart1.c @ 890 - Rev 291 → 295