WebSVN - NaviCtrl - Diff - Rev 483 and 486


/*#######################################################################################*/
/* !!! THIS IS NOT FREE SOFTWARE !!!                                                     */
/*#######################################################################################*/
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// + www.MikroKopter.com
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// + Software Nutzungsbedingungen (english version: see below)
// + der Fa. HiSystems GmbH, Flachsmeerstrasse 2, 26802 Moormerland - nachfolgend Lizenzgeber genannt -
// + Der Lizenzgeber räumt dem Kunden ein nicht-ausschließliches, zeitlich und räumlich* unbeschränktes Recht ein, die im den
// + Mikrocontroller verwendete Firmware für die Hardware Flight-Ctrl, Navi-Ctrl, BL-Ctrl, MK3Mag & PC-Programm MikroKopter-Tool 
// + - nachfolgend Software genannt - nur für private Zwecke zu nutzen.
// + Der Einsatz dieser Software ist nur auf oder mit Produkten des Lizenzgebers zulässig.
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// + Die vom Lizenzgeber gelieferte Software ist urheberrechtlich geschützt. Alle Rechte an der Software sowie an sonstigen im
// + Rahmen der Vertragsanbahnung und Vertragsdurchführung überlassenen Unterlagen stehen im Verhältnis der Vertragspartner ausschließlich dem Lizenzgeber zu.
// + Die in der Software enthaltenen Copyright-Vermerke, Markenzeichen, andere Rechtsvorbehalte, Seriennummern sowie
// + sonstige der Programmidentifikation dienenden Merkmale dürfen vom Kunden nicht verändert oder unkenntlich gemacht werden.
// + Der Kunde trifft angemessene Vorkehrungen für den sicheren Einsatz der Software. Er wird die Software gründlich auf deren
// + Verwendbarkeit zu dem von ihm beabsichtigten Zweck testen, bevor er diese operativ einsetzt.
// + Die Haftung des Lizenzgebers wird - soweit gesetzlich zulässig - begrenzt in Höhe des typischen und vorhersehbaren
// + Schadens. Die gesetzliche Haftung bei Personenschäden und nach dem Produkthaftungsgesetz bleibt unberührt. Dem Lizenzgeber steht jedoch der Einwand 
// + des Mitverschuldens offen.
// + Der Kunde trifft angemessene Vorkehrungen für den Fall, dass die Software ganz oder teilweise nicht ordnungsgemäß arbeitet.
// + Er wird die Software gründlich auf deren Verwendbarkeit zu dem von ihm beabsichtigten Zweck testen, bevor er diese operativ einsetzt.
// + Der Kunde wird er seine Daten vor Einsatz der Software nach dem Stand der Technik sichern.
// + Der Kunde ist darüber unterrichtet, dass der Lizenzgeber seine Daten im zur Vertragsdurchführung erforderlichen Umfang
// + und auf Grundlage der Datenschutzvorschriften erhebt, speichert, verarbeitet und, sofern notwendig, an Dritte übermittelt.
// + *) Die räumliche Nutzung bezieht sich nur auf den Einsatzort, nicht auf die Reichweite der programmierten Software.
// + #### ENDE DER NUTZUNGSBEDINGUNGEN ####'
// +  Hinweis: Informationen über erweiterte Nutzungsrechte (wie z.B. Nutzung für nicht-private Zwecke) sind auf Anfrage per Email an info(@)hisystems.de verfügbar.
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// + Software LICENSING TERMS
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// + of HiSystems GmbH, Flachsmeerstrasse 2, 26802 Moormerland, Germany - the Licensor -
// + The Licensor grants the customer a non-exclusive license to use the microcontroller firmware of the Flight-Ctrl, Navi-Ctrl, BL-Ctrl, and MK3Mag hardware 
// + (the Software) exclusively for private purposes. The License is unrestricted with respect to time and territory*.
// + The Software may only be used with the Licensor's products.
// + The Software provided by the Licensor is protected by copyright. With respect to the relationship between the parties to this
// + agreement, all rights pertaining to the Software and other documents provided during the preparation and execution of this
// + agreement shall be the property of the Licensor.
// + The information contained in the Software copyright notices, trademarks, other legal reservations, serial numbers and other
// + features that can be used to identify the program may not be altered or defaced by the customer.
// + The customer shall be responsible for taking reasonable precautions
// + for the safe use of the Software. The customer shall test the Software thoroughly regarding its suitability for the
// + intended purpose before implementing it for actual operation. The Licensor's liability shall be limited to the extent of typical and
// + foreseeable damage to the extent permitted by law, notwithstanding statutory liability for bodily injury and product
// + liability. However, the Licensor shall be entitled to the defense of contributory negligence.
// + The customer will take adequate precautions in the case, that the software is not working properly. The customer will test
// + the software for his purpose before any operational usage. The customer will backup his data before using the software.
// + The customer understands that the Licensor collects, stores and processes, and, where required, forwards, customer data
// + to third parties to the extent necessary for executing the agreement, subject to applicable data protection and privacy regulations.
// + *) The territory aspect only refers to the place where the Software is used, not its programmed range.
// + #### END OF LICENSING TERMS ####
// + Note: For information on license extensions (e.g. commercial use), please contact us at info(@)hisystems.de.
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include <string.h>
 
#include "91x_lib.h"
#include "main.h"
#include "config.h"
#include "menu.h"
#include "GPS.h"
#include "i2c0.h"
#include "i2c1.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"
#include "spi_slave.h"
#include "ftphelper.h"
#include "led.h"
#include "fat16.h"
 
 
#define FALSE   0
#define TRUE    1
 
#define ABO_TIMEOUT 8000 // disable abo after 8 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_MotorData          = FALSE;
u8 UART1_Request_Echo               = FALSE;
u8 UART1_Request_ParameterId    = 0;
u8 UART1_Request_Parameter              = FALSE;
u8 UART1_Request_SystemTime             = FALSE;
u8 UART1_DisplayKeys                    = 0;
u8 UART1_DisplayLine                    = 0;
u8 UART1_ConfirmFrame                   = 0;
u8 UART1_Request_FTP                    = FALSE;
u8 LastTransmittedFCStatusFlags2 = 0;
u8 UART1_ExternalControlConfirmFrame = FALSE;
u8 Send_NMEA_RMC = FALSE;
 
UART_TypeDef *DebugUART = UART1;
 
#ifdef FOLLOW_ME
#define FOLLOW_ME_INTERVAL 200 // 5 Hz
u32 UART1_FollowMe_Timer        = 0;
Point_t FollowMe;
#endif
 
// 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  1024
u8 UART1_rbuffer[UART1_RX_BUFFER_LEN];
Buffer_t UART1_rx_buffer;
 
// the tx buffer
#define UART1_TX_BUFFER_LEN  1024
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        ",
        "Voltage  [0,1V] ",
        "Current  [0,1A] ",
        "GPS Data        ",
        "CompassHeading  ", //10
        "GyroHeading     ",
        "SPI Error       ", // achtung: muss auf 12 bleiben
        "SPI Okay        ",
        "I2C Error       ",
        "I2C Okay        ", //15
        "16              ",
        "17              ",
        "18              ",
        "19              ", // SD-Card-time 
        "EarthMagnet [%] ", //20
        "Ground Speed    ", //  "Z_Speed         ",
        "N_Speed         ",
        "E_Speed         ",
        "Magnet X        ",
        "Magnet Y        ", //25
        "Magnet Z        ",
        "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_MotorData_Timer = 0;
u32 UART1_MotorData_Interval = 0;               // in ms
u32 UART1_Display_Timer = 0;
u32 UART1_Display_Interval = 0;         // in ms
u32 NMEA_Timer = 0;
u32 NMEA_Interval = 500;// 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_FIFO =                                  UART_FIFO_Disable;
//      UART_InitStructure.UART_TxFIFOLevel =                   UART_FIFOLevel_1_2;
        UART_InitStructure.UART_TxFIFOLevel =                   UART_FIFOLevel_1_8; // FIFO size 16 bytes, FIFO level 2 bytes
        UART_InitStructure.UART_RxFIFOLevel =                   UART_FIFOLevel_1_2; // FIFO size 16 bytes, FIFO level 8 bytes 
 
        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;
        NMEA_Timer = SetDelay(14000);
 
        // 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;
    UART_VersionInfo.HWMajor = Version_HW & 0x7f;
    UART_VersionInfo.reserved2 = 0;  
        UART_VersionInfo.Flags = 0;
        NaviData.Version = NAVIDATA_VERSION;
 
        UART1_PutString("\r\n UART1 init...ok");
}
 
 
/****************************************************************/
/*               USART1 receiver ISR                            */
/****************************************************************/
void UART1_IRQHandler(void)
{
        static u8 abortState = 0;
        u8 c;
 
        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
        }
 
 
 
        VIC1->VAR = 0xFF; // write any value to VIC1 Vector address register
}
 
/**************************************************************/
/* Process incomming data from debug uart                     */
/**************************************************************/
void UART1_ProcessRxData(void)
{
        // return on forwarding uart  or unlocked rx buffer
        u8 c;
        if(DebugUART != UART1) return;
        // 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 'b': // extern control
                                          UART1_ExternalControlConfirmFrame = 1;
                        case 'y': // serial poti values
                                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 't': // request for the GPS time 
                                UART1_Request_SystemTime  = TRUE;
                                break;
 
                        case 'f': // ftp command
                                UART1_Request_FTP = SerialMsg.pData[0];
                                //if (UART1_Request_FTP == FTP_CMD_SET_CWD || UART1_Request_FTP == FTP_CMD_GET_FILE) 
                                memcpy(&FTP_data, &SerialMsg.pData[1], sizeof(FTP_data)); // copy ftp parameter
                        break;
 
                        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)
                                {
                                        //if(!(FC.StatusFlags & FC_STATUS_FLY)) PointList_Clear(); // flush the list
                                        //pPoint->Index = 1; // must be one after empty list
                                        PointList_SetAt(pPoint);
                                        if(FC.StatusFlags & FC_STATUS_FLY) PointList_WPActive(TRUE);
                                        GPS_pWaypoint = PointList_WPBegin(); // updates POI index
                                        if(GPS_pWaypoint != NULL) // if new WP exist
                                        {   // update WP hold time stamp immediately!
                                                EnableNewWpHeading();
/*                                              if(GPS_pWaypoint->Heading > 0 && GPS_pWaypoint->Heading <= 360)
                                                {
                                                 CAM_Orientation.Azimuth = GPS_pWaypoint->Heading;
                                                 CAM_Orientation.UpdateMask |= CAM_UPDATE_AZIMUTH;
                                                }
*/
                                        }
                                        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
                                                if(pPoint->Index > MaxNumberOfWaypoints)
                                                 {
                                                  UART1_Request_WritePoint = 254;
                                                  pPoint->Index = MaxNumberOfWaypoints;
                                                 }
                                                 else
                                                 UART1_Request_WritePoint = PointList_SetAt(pPoint);
                                                if(FC.StatusFlags & FC_STATUS_FLY) PointList_WPActive(TRUE);
                                                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 'k': // request for Motor data;
                                UART1_MotorData_Interval = (u32) SerialMsg.pData[0] * 10;
                                if(UART1_MotorData_Interval > 0) UART1_Request_MotorData = 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)
{
        u32 timeout = 10000;
        if (c == '\n') UART1_Putchar('\r');
        // wait until txd fifo is not full
        while(UART_GetFlagStatus(UART1, UART_FLAG_TxFIFOFull) != RESET) if(--timeout == 0) return(0);
        // transmit byte
        UART_SendData(UART1, c);
        #ifdef FOLLOW_ME
        if(TransmitAlsoToFC) UART_SendData(UART2, c);
        #endif
        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(I2C0_State != I2C_STATE_IDLE)   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
                        #ifdef FOLLOW_ME
                        if(TransmitAlsoToFC)
                        {
                                UART_SendData(UART2, tmp_tx); // put character to txd fifo
                        }
                        #endif
                        // if terminating character or end of txd buffer reached
                        if((tmp_tx == '\0') || (UART1_tx_buffer.Position == UART1_tx_buffer.DataBytes))
                        {
                                Buffer_Clear(&UART1_tx_buffer); // clear txd buffer
                                #ifdef FOLLOW_ME
                                TransmitAlsoToFC = 0;
                                #endif
                                break; // end while loop
                        }
                }
        }
}
 
//$GPGGA,HHMMSS.ss,BBBB.BBBB,b,LLLLL.LLLL,l,Q,NN,D.D,H.H,h,G.G,g,A.A,RRRR*PP
//$GPGGA,191410,4735.5634,N,00739.3538,E,1,04,4.4,351.5,M,48.0,M,,*45
//$GPGGA,092120.20,,,,,0,00,99.99,,,,,,*6C
//http://www.kowoma.de/gps/zusatzerklaerungen/NMEA.htm
void CreateNmeaGGA(void)
{
 unsigned char array[200], i = 0, crc = 0, x;
 long tmp1, tmp2;
 i += sprintf(array, "$GPGGA,");
// +++++++++++++++++++++++++++++++++++++++++++
 if(SystemTime.Valid)
  {
   i += sprintf(&array[i], "%02d%02d%02d.%02d,",SystemTime.Hour,SystemTime.Min,SystemTime.Sec,SystemTime.mSec/10);
  }
 else
  {
  i += sprintf(&array[i], ",");
  }
// +++++++++++++++++++++++++++++++++++++++++++
 if(GPSData.Flags & FLAG_GPSFIXOK)
 {
  tmp1 = abs(GPSData.Position.Latitude)/10000000L;
  i += sprintf(&array[i],"%02d",(int)tmp1);
 
  tmp1 = abs(GPSData.Position.Latitude)%10000000L;
  tmp1 *= 6; // in Minuten
  tmp2 = tmp1 / 1000000L;
  i += sprintf(&array[i],"%02d",(int)tmp2);
  tmp2 = tmp1 % 1000000L;
  tmp2 /= 10; // eine Stelle zu viel
  i += sprintf(&array[i],".%05d,",(int)tmp2);
 
  if(GPSData.Position.Latitude >= 0) i += sprintf(&array[i],"N,");
  else i += sprintf(&array[i],"S,");
// +++++++++++++++++++++++++++++++++++++++++++
 
  tmp1 = abs(GPSData.Position.Longitude)/10000000L;
  i += sprintf(&array[i],"%03d",(int)tmp1);
 
  tmp1 = abs(GPSData.Position.Longitude)%10000000L;
  tmp1 *= 6; // in Minuten
  tmp2 = tmp1 / 1000000L;
  i += sprintf(&array[i],"%02d",(int)tmp2);
  tmp2 = tmp1 % 1000000L;
  tmp2 /= 10; // eine Stelle zu viel
  i += sprintf(&array[i],".%05d,",(int)tmp2);
 
 
  if(GPSData.Position.Longitude >= 0) i += sprintf(&array[i],"E,");
  else i += sprintf(&array[i],"W,");
  i += sprintf(&array[i],"%d,",GPSData.SatFix);
  i += sprintf(&array[i],"%d,",GPSData.NumOfSats);
  i += sprintf(&array[i],"%d.%d,",GPSData.Position_Accuracy/100,abs(GPSData.Position_Accuracy%100));
//  i += sprintf(&array[i],"%d.%d,M,",GPSData.Position.Altitude/1000,abs(GPSData.Position.Altitude%1000)/100);
 tmp1 = NaviData.Altimeter / 2; // in dm
  i += sprintf(&array[i],"%d.%d,M,",tmp1 / 10,abs(tmp1 % 10));
  i += sprintf(&array[i],",,,*");
 }
 else
  {
   i += sprintf(&array[i], ",,,,%d,00,99.99,,,,,,*",GPSData.NumOfSats);
  }
 for(x=1; x<i-1; x++)
  {
   crc ^= array[x];
  }
  i += sprintf(&array[i], "%02x%c%c",crc,0x0d,0x0a);
  AddSerialData(&UART1_tx_buffer,array,i);
 
// +++++++++++++++++++++++++++++++++++++++++++
}
 
//$GPRMC,162614.123,A,5230.5900,N,01322.3900,E,10.0,90.0,131006,1.2,E,A*13
//$GPRMC,HHMMSS.sss,A,BBBB.BBBB,b,LLLLL.LLLL,l,GG.G,RR.R,DDMMYY,M.M,m,F*PP
 
void CreateNmeaRMC(void)
{
 unsigned char array[200], i = 0, crc = 0, x;
 int tmp_int;
 long tmp1, tmp2;
// +++++++++++++++++++++++++++++++++++++++++++
 i += sprintf(array, "$GPRMC,");
// +++++++++++++++++++++++++++++++++++++++++++
 if(SystemTime.Valid)
  {
   i += sprintf(&array[i], "%02d%02d%02d.%03d,",SystemTime.Hour,SystemTime.Min,SystemTime.Sec,SystemTime.mSec);
  }
 else
  {
  i += sprintf(&array[i], ",");
  }
 if(GPSData.Flags & FLAG_GPSFIXOK)
 {
// +++++++++++++++++++++++++++++++++++++++++++
  tmp1 = abs(GPSData.Position.Latitude)/10000000L;
  i += sprintf(&array[i],"A,%02d",(int)tmp1); // Status: A = Okay  V = Warnung
 
  tmp1 = abs(GPSData.Position.Latitude)%10000000L;
  tmp1 *= 6; // in Minuten
  tmp2 = tmp1 / 1000000L;
  i += sprintf(&array[i],"%02d",(int)tmp2);
  tmp2 = tmp1 % 1000000L;
  tmp2 /= 10; // eine Stelle zu viel
  i += sprintf(&array[i],".%05d,",(int)tmp2);
  if(GPSData.Position.Latitude >= 0) i += sprintf(&array[i],"N,");
  else i += sprintf(&array[i],"S,");
// +++++++++++++++++++++++++++++++++++++++++++
  tmp1 = abs(GPSData.Position.Longitude)/10000000L;
  i += sprintf(&array[i],"%03d",(int)tmp1);
 
  tmp1 = abs(GPSData.Position.Longitude)%10000000L;
  tmp1 *= 6; // in Minuten
  tmp2 = tmp1 / 1000000L;
  i += sprintf(&array[i],"%02d",(int)tmp2);
  tmp2 = tmp1 % 1000000L;
  tmp2 /= 10; // eine Stelle zu viel
  i += sprintf(&array[i],".%05d,",(int)tmp2);
  if(GPSData.Position.Longitude >= 0) i += sprintf(&array[i],"E,");
  else i += sprintf(&array[i],"W,");
// +++++++++++++++++++++++++++++++++++++++++++
  tmp_int = GPSData.Speed_Ground; // in cm/sek
  tmp_int *= 90;
  tmp_int /= 463;
  i += sprintf(&array[i],"%02d.%d,",tmp_int/10,tmp_int%10); // in Knoten
// +++++++++++++++++++++++++++++++++++++++++++
  i += sprintf(&array[i],"%03d.%d,",GyroCompassCorrected/10,GyroCompassCorrected%10);
// +++++++++++++++++++++++++++++++++++++++++++
 if(SystemTime.Valid)
  {
   i += sprintf(&array[i], "%02d%02d%02d,",SystemTime.Day,SystemTime.Month,SystemTime.Year);
  }
 else
  {
  i += sprintf(&array[i], ",");
  }
// +++++++++++++++++++++++++++++++++++++++++++
  i += sprintf(&array[i],"%d.%1d,", abs(GeoMagDec)/10,abs(GeoMagDec)%10);
  if(GeoMagDec < 0) i += sprintf(&array[i], "W,"); else i += sprintf(&array[i], "E,");
// +++++++++++++++++++++++++++++++++++++++++++
  if(GPSData.Flags & FLAG_DIFFSOLN) i += sprintf(&array[i], "D,");
  else i += sprintf(&array[i], "A,");
 }
 else // kein Satfix
  {
   i += sprintf(&array[i], "V,,,,,,,,,,N*");
  }
// +++++++++++++++++++++++++++++++++++++++++++
//  CRC
// +++++++++++++++++++++++++++++++++++++++++++
 for(x=1; x<i-1; x++)
  {
   crc ^= array[x];
  }
  i += sprintf(&array[i], "%02x%c%c",crc,0x0d,0x0a);
// +++++++++++++++++++++++++++++++++++++++++++
  AddSerialData(&UART1_tx_buffer,array,i);
// +++++++++++++++++++++++++++++++++++++++++++
/*
 
 
 
                                GPSData.Flags =         (GPSData.Flags & 0xf0) | (UbxSol.Flags & 0x0f); // we take only the lower bits
                                GPSData.NumOfSats =                     UbxSol.numSV;
                                GPSData.SatFix =                                UbxSol.GPSfix;
                                GPSData.Position_Accuracy =             UbxSol.PAcc;
                                GPSData.Speed_Accuracy =                UbxSol.SAcc;
                                SetGPSTime(&SystemTime); // update system time
                                // NAV POSLLH
                                GPSData.Position.Status =               INVALID;
                                GPSData.Position.Longitude =    UbxPosLlh.LON;
                                GPSData.Position.Latitude =     UbxPosLlh.LAT;
                                GPSData.Position.Altitude =     UbxPosLlh.HMSL;
                                GPSData.Position.Status =               NEWDATA;
                                // NAV VELNED
                                GPSData.Speed_East =                    UbxVelNed.VEL_E;
                                GPSData.Speed_North =                   UbxVelNed.VEL_N;
                                GPSData.Speed_Top       =                       -UbxVelNed.VEL_D;
                                GPSData.Speed_Ground =                  UbxVelNed.GSpeed;
                                GPSData.Heading =                               UbxVelNed.Heading;
        SystemTime.Year = 0;
        SystemTime.Month = 0;
        SystemTime.Day = 0;
        SystemTime.Hour = 0;
        SystemTime.Min = 0;
        SystemTime.Sec = 0;
        SystemTime.mSec = 0;
        SystemTime.Valid = 0;
       
                                FromFlightCtrl.GyroHeading / 10;//NaviData.HomePositionDeviation.Bearing / 2;
                                        if(GPSData.Position.Latitude < 0) ToFlightCtrl.Param.Byte[5]  = 1; // 1 = S
                                        else ToFlightCtrl.Param.Byte[5]  = 0; // 1 = S
                                        i1 = abs(GPSData.Position.Latitude)/10000000L;
                                        i2 = abs(GPSData.Position.Latitude)%10000000L;
 
 
 
                                        if(!(NCFlags & NC_FLAG_GPS_OK)) {i1 = 0; i2 = 0;}
                                        i1 *= 100;
                                        i1 += i2 / 100000;
                                        i2  = i2 % 100000;
                                        i2 /= 10;
                                        ToFlightCtrl.Param.Byte[6]  = i1 % 256;
                                        ToFlightCtrl.Param.Byte[7]  = i1 / 256;
                                        ToFlightCtrl.Param.Byte[8]  = i2 % 256;
                                        ToFlightCtrl.Param.Byte[9]  = i2 / 256;
                                        break;
                                case 1:
                                        ToFlightCtrl.Param.Byte[11] = HOTT_GPS_PACKET_ID;
                                        ToFlightCtrl.Param.Byte[0] = 11+3;      // index          +3, weil bei HoTT V4 3 Bytes eingeschoben wurden
                                        ToFlightCtrl.Param.Byte[1] = 8-1;       // how many
                                        //-----------------------------
                                        if(GPSData.Position.Longitude < 0) ToFlightCtrl.Param.Byte[2]  = 1; // 1 = E
                                        else ToFlightCtrl.Param.Byte[2]  = 0; // 1 = S
                                        i1 = abs(GPSData.Position.Longitude)/10000000L;
                                        i2 = abs(GPSData.Position.Longitude)%10000000L;
 
*/
}
 
 
/**************************************************************/
/* Send the answers to incomming commands at the debug uart   */
/**************************************************************/
void UART1_TransmitTxData(void)
{
static u8 motorindex1 = 255, motorindex2 = 0;
        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_MotorData_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);
                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_FTP && (UART1_tx_buffer.Locked == FALSE))
        {
                u8 errorcode = FTP_ERROR_NONE;
        if(FC.StatusFlags & FC_STATUS_MOTOR_RUN) errorcode = FTP_ERROR_MOTOR_RUN;
                else if (!Partition.IsValid) errorcode = FTP_ERROR_NO_SDCARD;
 
                if (!errorcode) CheckFTPCommand(UART1_Request_FTP);
                else
                {
                        u8 cmd = FTP_CMD_ERROR;
                        MKProtocol_CreateSerialFrame(&UART1_tx_buffer, 'F', NC_ADDRESS, 2, &cmd, 1, &errorcode, 1);
                }
 
                UART1_Request_FTP = 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_ExternalControlConfirmFrame && (UART1_tx_buffer.Locked == FALSE))
        {
                MKProtocol_CreateSerialFrame(&UART1_tx_buffer, 'B', NC_ADDRESS, 1,(u8 *)&UART1_ExternalControlConfirmFrame, sizeof(UART1_ExternalControlConfirmFrame));
                UART1_ExternalControlConfirmFrame = 0;
        }
        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;
                LastTransmittedFCStatusFlags2 = NaviData.FCStatusFlags2;
        }
        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))
        {
                Data3D.StickNick = FC.StickNick;
                Data3D.StickRoll = FC.StickRoll;
        Data3D.StickYaw = FC.StickYaw;
        Data3D.StickGas = FC.StickGas;
                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_MotorData_Interval > 0) && CheckDelay(UART1_MotorData_Timer) ) || UART1_Request_MotorData) && (UART1_tx_buffer.Locked == FALSE))
        {
                do
                {
                 motorindex1++;
                 motorindex1%=12;
         if(!motorindex1) {motorindex2++;  motorindex2 %= 12;};
                 if(motorindex1 == motorindex2) break;
                }
                while((Motor[motorindex1].State & 0x80) != 0x80); // skip unused Motors
 
                MKProtocol_CreateSerialFrame(&UART1_tx_buffer, 'K', NC_ADDRESS, 2, &motorindex1, sizeof(motorindex1),(u8 *)&Motor[motorindex1], sizeof(Motor_t));
            UART1_MotorData_Timer = SetDelay(UART1_MotorData_Interval);
                UART1_Request_MotorData = FALSE;
        }
        else if((((NMEA_Interval > 0) && CheckDelay(NMEA_Timer))) && (UART1_tx_buffer.Locked == FALSE))
        {
                CreateNmeaGGA();
                Send_NMEA_RMC = TRUE;   // das muss noch da hinter
                NMEA_Timer = SetDelay(NMEA_Interval);
        }
        else if(Send_NMEA_RMC == TRUE && (UART1_tx_buffer.Locked == FALSE))
        {
          CreateNmeaRMC();
          Send_NMEA_RMC = 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_SystemTime && (UART1_tx_buffer.Locked == FALSE))
        {
                MKProtocol_CreateSerialFrame(&UART1_tx_buffer, 'T', NC_ADDRESS,1, (u8 *)&SystemTime, sizeof(SystemTime));
                UART1_Request_SystemTime = 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 FOLLOW_ME
        else if(CheckDelay(UART1_FollowMe_Timer) && (UART1_tx_buffer.Locked == FALSE))
        {
                if((GPSData.Status != INVALID) && (GPSData.SatFix == SATFIX_3D) && (GPSData.Flags & FLAG_GPSFIXOK) && (GPSData.NumOfSats >= 4))
                {
                        TransmitAlsoToFC = 1;
                        // update FollowMe content
                        FollowMe.Position.Longitude     = GPSData.Position.Longitude;
                        FollowMe.Position.Latitude      = GPSData.Position.Latitude;
                        FollowMe.Position.Status = NEWDATA;
                        FollowMe.Position.Altitude = 1;
                        // 0  -> no Orientation
                        // 1-360 -> CompassCourse Setpoint
                        // -1 -> points to  WP1 -> itself
                FollowMe.Heading = -1;
                        FollowMe.ToleranceRadius = 1;
                        FollowMe.HoldTime = 60;
                        FollowMe.Event_Flag = 1;
                        FollowMe.Index = 1; // 0 = Delete List, 1 place at first entry in the list
                        FollowMe.Type = POINT_TYPE_WP;
                        FollowMe.WP_EventChannelValue = 100;  // set servo value
                        FollowMe.AltitudeRate = 0;                        // do not change height
                        FollowMe.Speed = 0;                             // rate to change the Position (0 = max)
                        FollowMe.CamAngle = 255;                // Camera servo angle in degree (255 -> POI-Automatic)
                        FollowMe.Name[0] = 'F';             // Name of that point (ASCII)
                        FollowMe.Name[1] = 'O';             // Name of that point (ASCII)
                        FollowMe.Name[2] = 'L';             // Name of that point (ASCII)
                        FollowMe.Name[3] = 'L';             // Name of that point (ASCII)
                        FollowMe.reserve[0] = 0;                // reserve
                        FollowMe.reserve[1] = 0;                // reserve
                        MKProtocol_CreateSerialFrame(&UART1_tx_buffer, 's', NC_ADDRESS, 1, (u8 *)&FollowMe, sizeof(FollowMe));
                }
                UART1_FollowMe_Timer = SetDelay(FOLLOW_ME_INTERVAL); // set new update time
        }
#endif
#ifdef DEBUG                                                                                                                    // only include functions if DEBUG is defined
        else 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 483	Rev 486
1	/#######################################################################################/	1	/#######################################################################################/
2	/* !!! THIS IS NOT FREE SOFTWARE !!! */	2	/* !!! THIS IS NOT FREE SOFTWARE !!! */
3	/#######################################################################################/	3	/#######################################################################################/
4	// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++	4	// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
5	// + www.MikroKopter.com	5	// + www.MikroKopter.com
6	// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++	6	// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
7	// + Software Nutzungsbedingungen (english version: see below)	7	// + Software Nutzungsbedingungen (english version: see below)
8	// + der Fa. HiSystems GmbH, Flachsmeerstrasse 2, 26802 Moormerland - nachfolgend Lizenzgeber genannt -	8	// + der Fa. HiSystems GmbH, Flachsmeerstrasse 2, 26802 Moormerland - nachfolgend Lizenzgeber genannt -
9	// + Der Lizenzgeber räumt dem Kunden ein nicht-ausschließliches, zeitlich und räumlich* unbeschränktes Recht ein, die im den	9	// + Der Lizenzgeber räumt dem Kunden ein nicht-ausschließliches, zeitlich und räumlich* unbeschränktes Recht ein, die im den
10	// + Mikrocontroller verwendete Firmware für die Hardware Flight-Ctrl, Navi-Ctrl, BL-Ctrl, MK3Mag & PC-Programm MikroKopter-Tool	10	// + Mikrocontroller verwendete Firmware für die Hardware Flight-Ctrl, Navi-Ctrl, BL-Ctrl, MK3Mag & PC-Programm MikroKopter-Tool
11	// + - nachfolgend Software genannt - nur für private Zwecke zu nutzen.	11	// + - nachfolgend Software genannt - nur für private Zwecke zu nutzen.
12	// + Der Einsatz dieser Software ist nur auf oder mit Produkten des Lizenzgebers zulässig.	12	// + Der Einsatz dieser Software ist nur auf oder mit Produkten des Lizenzgebers zulässig.
13	// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++	13	// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
14	// + Die vom Lizenzgeber gelieferte Software ist urheberrechtlich geschützt. Alle Rechte an der Software sowie an sonstigen im	14	// + Die vom Lizenzgeber gelieferte Software ist urheberrechtlich geschützt. Alle Rechte an der Software sowie an sonstigen im
15	// + Rahmen der Vertragsanbahnung und Vertragsdurchführung überlassenen Unterlagen stehen im Verhältnis der Vertragspartner ausschließlich dem Lizenzgeber zu.	15	// + Rahmen der Vertragsanbahnung und Vertragsdurchführung überlassenen Unterlagen stehen im Verhältnis der Vertragspartner ausschließlich dem Lizenzgeber zu.
16	// + Die in der Software enthaltenen Copyright-Vermerke, Markenzeichen, andere Rechtsvorbehalte, Seriennummern sowie	16	// + Die in der Software enthaltenen Copyright-Vermerke, Markenzeichen, andere Rechtsvorbehalte, Seriennummern sowie
17	// + sonstige der Programmidentifikation dienenden Merkmale dürfen vom Kunden nicht verändert oder unkenntlich gemacht werden.	17	// + sonstige der Programmidentifikation dienenden Merkmale dürfen vom Kunden nicht verändert oder unkenntlich gemacht werden.
18	// + Der Kunde trifft angemessene Vorkehrungen für den sicheren Einsatz der Software. Er wird die Software gründlich auf deren	18	// + Der Kunde trifft angemessene Vorkehrungen für den sicheren Einsatz der Software. Er wird die Software gründlich auf deren
19	// + Verwendbarkeit zu dem von ihm beabsichtigten Zweck testen, bevor er diese operativ einsetzt.	19	// + Verwendbarkeit zu dem von ihm beabsichtigten Zweck testen, bevor er diese operativ einsetzt.
20	// + Die Haftung des Lizenzgebers wird - soweit gesetzlich zulässig - begrenzt in Höhe des typischen und vorhersehbaren	20	// + Die Haftung des Lizenzgebers wird - soweit gesetzlich zulässig - begrenzt in Höhe des typischen und vorhersehbaren
21	// + Schadens. Die gesetzliche Haftung bei Personenschäden und nach dem Produkthaftungsgesetz bleibt unberührt. Dem Lizenzgeber steht jedoch der Einwand	21	// + Schadens. Die gesetzliche Haftung bei Personenschäden und nach dem Produkthaftungsgesetz bleibt unberührt. Dem Lizenzgeber steht jedoch der Einwand
22	// + des Mitverschuldens offen.	22	// + des Mitverschuldens offen.
23	// + Der Kunde trifft angemessene Vorkehrungen für den Fall, dass die Software ganz oder teilweise nicht ordnungsgemäß arbeitet.	23	// + Der Kunde trifft angemessene Vorkehrungen für den Fall, dass die Software ganz oder teilweise nicht ordnungsgemäß arbeitet.
24	// + Er wird die Software gründlich auf deren Verwendbarkeit zu dem von ihm beabsichtigten Zweck testen, bevor er diese operativ einsetzt.	24	// + Er wird die Software gründlich auf deren Verwendbarkeit zu dem von ihm beabsichtigten Zweck testen, bevor er diese operativ einsetzt.
25	// + Der Kunde wird er seine Daten vor Einsatz der Software nach dem Stand der Technik sichern.	25	// + Der Kunde wird er seine Daten vor Einsatz der Software nach dem Stand der Technik sichern.
26	// + Der Kunde ist darüber unterrichtet, dass der Lizenzgeber seine Daten im zur Vertragsdurchführung erforderlichen Umfang	26	// + Der Kunde ist darüber unterrichtet, dass der Lizenzgeber seine Daten im zur Vertragsdurchführung erforderlichen Umfang
27	// + und auf Grundlage der Datenschutzvorschriften erhebt, speichert, verarbeitet und, sofern notwendig, an Dritte übermittelt.	27	// + und auf Grundlage der Datenschutzvorschriften erhebt, speichert, verarbeitet und, sofern notwendig, an Dritte übermittelt.
28	// + *) Die räumliche Nutzung bezieht sich nur auf den Einsatzort, nicht auf die Reichweite der programmierten Software.	28	// + *) Die räumliche Nutzung bezieht sich nur auf den Einsatzort, nicht auf die Reichweite der programmierten Software.
29	// + #### ENDE DER NUTZUNGSBEDINGUNGEN ####'	29	// + #### ENDE DER NUTZUNGSBEDINGUNGEN ####'
30	// + Hinweis: Informationen über erweiterte Nutzungsrechte (wie z.B. Nutzung für nicht-private Zwecke) sind auf Anfrage per Email an info(@)hisystems.de verfügbar.	30	// + Hinweis: Informationen über erweiterte Nutzungsrechte (wie z.B. Nutzung für nicht-private Zwecke) sind auf Anfrage per Email an info(@)hisystems.de verfügbar.
31	// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++	31	// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
32	// + Software LICENSING TERMS	32	// + Software LICENSING TERMS
33	// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++	33	// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
34	// + of HiSystems GmbH, Flachsmeerstrasse 2, 26802 Moormerland, Germany - the Licensor -	34	// + of HiSystems GmbH, Flachsmeerstrasse 2, 26802 Moormerland, Germany - the Licensor -
35	// + The Licensor grants the customer a non-exclusive license to use the microcontroller firmware of the Flight-Ctrl, Navi-Ctrl, BL-Ctrl, and MK3Mag hardware	35	// + The Licensor grants the customer a non-exclusive license to use the microcontroller firmware of the Flight-Ctrl, Navi-Ctrl, BL-Ctrl, and MK3Mag hardware
36	// + (the Software) exclusively for private purposes. The License is unrestricted with respect to time and territory*.	36	// + (the Software) exclusively for private purposes. The License is unrestricted with respect to time and territory*.
37	// + The Software may only be used with the Licensor's products.	37	// + The Software may only be used with the Licensor's products.
38	// + The Software provided by the Licensor is protected by copyright. With respect to the relationship between the parties to this	38	// + The Software provided by the Licensor is protected by copyright. With respect to the relationship between the parties to this
39	// + agreement, all rights pertaining to the Software and other documents provided during the preparation and execution of this	39	// + agreement, all rights pertaining to the Software and other documents provided during the preparation and execution of this
40	// + agreement shall be the property of the Licensor.	40	// + agreement shall be the property of the Licensor.
41	// + The information contained in the Software copyright notices, trademarks, other legal reservations, serial numbers and other	41	// + The information contained in the Software copyright notices, trademarks, other legal reservations, serial numbers and other
42	// + features that can be used to identify the program may not be altered or defaced by the customer.	42	// + features that can be used to identify the program may not be altered or defaced by the customer.
43	// + The customer shall be responsible for taking reasonable precautions	43	// + The customer shall be responsible for taking reasonable precautions
44	// + for the safe use of the Software. The customer shall test the Software thoroughly regarding its suitability for the	44	// + for the safe use of the Software. The customer shall test the Software thoroughly regarding its suitability for the
45	// + intended purpose before implementing it for actual operation. The Licensor's liability shall be limited to the extent of typical and	45	// + intended purpose before implementing it for actual operation. The Licensor's liability shall be limited to the extent of typical and
46	// + foreseeable damage to the extent permitted by law, notwithstanding statutory liability for bodily injury and product	46	// + foreseeable damage to the extent permitted by law, notwithstanding statutory liability for bodily injury and product
47	// + liability. However, the Licensor shall be entitled to the defense of contributory negligence.	47	// + liability. However, the Licensor shall be entitled to the defense of contributory negligence.
48	// + The customer will take adequate precautions in the case, that the software is not working properly. The customer will test	48	// + The customer will take adequate precautions in the case, that the software is not working properly. The customer will test
49	// + the software for his purpose before any operational usage. The customer will backup his data before using the software.	49	// + the software for his purpose before any operational usage. The customer will backup his data before using the software.
50	// + The customer understands that the Licensor collects, stores and processes, and, where required, forwards, customer data	50	// + The customer understands that the Licensor collects, stores and processes, and, where required, forwards, customer data
51	// + to third parties to the extent necessary for executing the agreement, subject to applicable data protection and privacy regulations.	51	// + to third parties to the extent necessary for executing the agreement, subject to applicable data protection and privacy regulations.
52	// + *) The territory aspect only refers to the place where the Software is used, not its programmed range.	52	// + *) The territory aspect only refers to the place where the Software is used, not its programmed range.
53	// + #### END OF LICENSING TERMS ####	53	// + #### END OF LICENSING TERMS ####
54	// + Note: For information on license extensions (e.g. commercial use), please contact us at info(@)hisystems.de.	54	// + Note: For information on license extensions (e.g. commercial use), please contact us at info(@)hisystems.de.
55	// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++	55	// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
56	#include <stdio.h>	56	#include <stdio.h>
57	#include <stdlib.h>	57	#include <stdlib.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 "i2c0.h"	66	#include "i2c0.h"
67	#include "i2c1.h"	67	#include "i2c1.h"
68	#include "uart0.h"	68	#include "uart0.h"
69	#include "uart1.h"	69	#include "uart1.h"
70	#include "uart2.h"	70	#include "uart2.h"
71	#include "timer1.h"	71	#include "timer1.h"
72	#include "timer2.h"	72	#include "timer2.h"
73	#include "analog.h"	73	#include "analog.h"
74	#include "compass.h"	74	#include "compass.h"
75	#include "waypoints.h"	75	#include "waypoints.h"
76	#include "mkprotocol.h"	76	#include "mkprotocol.h"
77	#include "params.h"	77	#include "params.h"
78	#include "fifo.h"	78	#include "fifo.h"
79	#include "debug.h"	79	#include "debug.h"
80	#include "spi_slave.h"	80	#include "spi_slave.h"
81	#include "ftphelper.h"	81	#include "ftphelper.h"
82	#include "led.h"	82	#include "led.h"
83	#include "fat16.h"	83	#include "fat16.h"
84		84
85		85
86	#define FALSE 0	86	#define FALSE 0
87	#define TRUE 1	87	#define TRUE 1
88		88
89	#define ABO_TIMEOUT 8000 // disable abo after 8 seconds	89	#define ABO_TIMEOUT 8000 // disable abo after 8 seconds
90	u32 UART1_AboTimeOut = 0;	90	u32 UART1_AboTimeOut = 0;
91		91
92	u8 UART1_Request_VersionInfo = FALSE;	92	u8 UART1_Request_VersionInfo = FALSE;
93	u8 UART1_Request_ExternalControl= FALSE;	93	u8 UART1_Request_ExternalControl= FALSE;
94	u8 UART1_Request_Display = FALSE;	94	u8 UART1_Request_Display = FALSE;
95	u8 UART1_Request_Display1 = FALSE;	95	u8 UART1_Request_Display1 = FALSE;
96	u8 UART1_Request_DebugData = FALSE;	96	u8 UART1_Request_DebugData = FALSE;
97	u8 UART1_Request_DebugLabel = 255;	97	u8 UART1_Request_DebugLabel = 255;
98	u8 UART1_Request_NaviData = FALSE;	98	u8 UART1_Request_NaviData = FALSE;
99	u8 UART1_Request_ErrorMessage = FALSE;	99	u8 UART1_Request_ErrorMessage = FALSE;
100	u8 UART1_Request_WritePoint = 0xFF;	100	u8 UART1_Request_WritePoint = 0xFF;
101	u8 UART1_Request_ReadPoint = 0;	101	u8 UART1_Request_ReadPoint = 0;
102	u8 UART1_Request_Data3D = FALSE;	102	u8 UART1_Request_Data3D = FALSE;
103	u8 UART1_Request_MotorData = FALSE;	103	u8 UART1_Request_MotorData = FALSE;
104	u8 UART1_Request_Echo = FALSE;	104	u8 UART1_Request_Echo = FALSE;
105	u8 UART1_Request_ParameterId = 0;	105	u8 UART1_Request_ParameterId = 0;
106	u8 UART1_Request_Parameter = FALSE;	106	u8 UART1_Request_Parameter = FALSE;
107	u8 UART1_Request_SystemTime = FALSE;	107	u8 UART1_Request_SystemTime = FALSE;
108	u8 UART1_DisplayKeys = 0;	108	u8 UART1_DisplayKeys = 0;
109	u8 UART1_DisplayLine = 0;	109	u8 UART1_DisplayLine = 0;
110	u8 UART1_ConfirmFrame = 0;	110	u8 UART1_ConfirmFrame = 0;
111	u8 UART1_Request_FTP = FALSE;	111	u8 UART1_Request_FTP = FALSE;
112	u8 LastTransmittedFCStatusFlags2 = 0;	112	u8 LastTransmittedFCStatusFlags2 = 0;
113	u8 UART1_ExternalControlConfirmFrame = FALSE;	113	u8 UART1_ExternalControlConfirmFrame = FALSE;
114	u8 Send_NMEA_RMC = FALSE;	114	u8 Send_NMEA_RMC = FALSE;
115		115
116	UART_TypeDef *DebugUART = UART1;	116	UART_TypeDef *DebugUART = UART1;
117		117
118	#ifdef FOLLOW_ME	118	#ifdef FOLLOW_ME
119	#define FOLLOW_ME_INTERVAL 200 // 5 Hz	119	#define FOLLOW_ME_INTERVAL 200 // 5 Hz
120	u32 UART1_FollowMe_Timer = 0;	120	u32 UART1_FollowMe_Timer = 0;
121	Point_t FollowMe;	121	Point_t FollowMe;
122	#endif	122	#endif
123		123
124	// the primary rx fifo	124	// the primary rx fifo
125	#define UART1_RX_FIFO_LEN 1024	125	#define UART1_RX_FIFO_LEN 1024
126	u8 UART1_rxfifobuffer[UART1_RX_FIFO_LEN];	126	u8 UART1_rxfifobuffer[UART1_RX_FIFO_LEN];
127	fifo_t UART1_rx_fifo;	127	fifo_t UART1_rx_fifo;
128		128
129	// the rx buffer	129	// the rx buffer
130	#define UART1_RX_BUFFER_LEN 1024	130	#define UART1_RX_BUFFER_LEN 1024
131	u8 UART1_rbuffer[UART1_RX_BUFFER_LEN];	131	u8 UART1_rbuffer[UART1_RX_BUFFER_LEN];
132	Buffer_t UART1_rx_buffer;	132	Buffer_t UART1_rx_buffer;
133		133
134	// the tx buffer	134	// the tx buffer
135	#define UART1_TX_BUFFER_LEN 1024	135	#define UART1_TX_BUFFER_LEN 1024
136	u8 UART1_tbuffer[UART1_TX_BUFFER_LEN];	136	u8 UART1_tbuffer[UART1_TX_BUFFER_LEN];
137	Buffer_t UART1_tx_buffer;	137	Buffer_t UART1_tx_buffer;
138		138
139	volatile u8 SerialLinkOkay = 0;	139	volatile u8 SerialLinkOkay = 0;
140		140
141	u8 text[200];	141	u8 text[200];
142		142
143	const u8 ANALOG_LABEL[32][16] =	143	const u8 ANALOG_LABEL[32][16] =
144	{	144	{
145	//1234567890123456	145	//1234567890123456
146	"AngleNick ", //0	146	"AngleNick ", //0
147	"AngleRoll ",	147	"AngleRoll ",
148	"AccNick ",	148	"AccNick ",
149	"AccRoll ",	149	"AccRoll ",
150	"OperatingRadius ",	150	"OperatingRadius ",
151	"FC-Flags ", //5	151	"FC-Flags ", //5
152	"NC-Flags ",	152	"NC-Flags ",
153	"Voltage [0,1V] ",	153	"Voltage [0,1V] ",
154	"Current [0,1A] ",	154	"Current [0,1A] ",
155	"GPS Data ",	155	"GPS Data ",
156	"CompassHeading ", //10	156	"CompassHeading ", //10
157	"GyroHeading ",	157	"GyroHeading ",
158	"SPI Error ", // achtung: muss auf 12 bleiben	158	"SPI Error ", // achtung: muss auf 12 bleiben
159	"SPI Okay ",	159	"SPI Okay ",
160	"I2C Error ",	160	"I2C Error ",
161	"I2C Okay ", //15	161	"I2C Okay ", //15
162	"16 ",	162	"16 ",
163	"17 ",	163	"17 ",
164	"18 ",	164	"18 ",
165	"19 ", // SD-Card-time	165	"19 ", // SD-Card-time
166	"EarthMagnet [%] ", //20	166	"EarthMagnet [%] ", //20
167	"Ground Speed ", // "Z_Speed ",	167	"Ground Speed ", // "Z_Speed ",
168	"N_Speed ",	168	"N_Speed ",
169	"E_Speed ",	169	"E_Speed ",
170	"Magnet X ",	170	"Magnet X ",
171	"Magnet Y ", //25	171	"Magnet Y ", //25
172	"Magnet Z ",	172	"Magnet Z ",
173	"Distance N ",	173	"Distance N ",
174	"Distance E ",	174	"Distance E ",
175	"GPS_Nick ",	175	"GPS_Nick ",
176	"GPS_Roll ", //30	176	"GPS_Roll ", //30
177	"Used_Sats "	177	"Used_Sats "
178	};	178	};
179		179
180	DebugOut_t DebugOut;	180	DebugOut_t DebugOut;
181	ExternControl_t ExternControl;	181	ExternControl_t ExternControl;
182	UART_VersionInfo_t UART_VersionInfo;	182	UART_VersionInfo_t UART_VersionInfo;
183	NaviData_t NaviData;	183	NaviData_t NaviData;
184	Data3D_t Data3D;	184	Data3D_t Data3D;
185	u16 Echo; // 2 bytes recieved will be sent back as echo	185	u16 Echo; // 2 bytes recieved will be sent back as echo
186		186
187	u32 UART1_DebugData_Timer = 0;	187	u32 UART1_DebugData_Timer = 0;
188	u32 UART1_DebugData_Interval = 0; // in ms	188	u32 UART1_DebugData_Interval = 0; // in ms
189	u32 UART1_NaviData_Timer = 0;	189	u32 UART1_NaviData_Timer = 0;
190	u32 UART1_NaviData_Interval = 0; // in ms	190	u32 UART1_NaviData_Interval = 0; // in ms
191	u32 UART1_Data3D_Timer = 0;	191	u32 UART1_Data3D_Timer = 0;
192	u32 UART1_Data3D_Interval = 0; // in ms	192	u32 UART1_Data3D_Interval = 0; // in ms
193	u32 UART1_MotorData_Timer = 0;	193	u32 UART1_MotorData_Timer = 0;
194	u32 UART1_MotorData_Interval = 0; // in ms	194	u32 UART1_MotorData_Interval = 0; // in ms
195	u32 UART1_Display_Timer = 0;	195	u32 UART1_Display_Timer = 0;
196	u32 UART1_Display_Interval = 0; // in ms	196	u32 UART1_Display_Interval = 0; // in ms
197	u32 NMEA_Timer = 0;	197	u32 NMEA_Timer = 0;
198	u32 NMEA_Interval = 500;// in ms	198	u32 NMEA_Interval = 500;// in ms
199		199
200	/********************************************************/	200	/********************************************************/
201	/* Initialization the UART1 */	201	/* Initialization the UART1 */
202	/********************************************************/	202	/********************************************************/
203	void UART1_Init (void)	203	void UART1_Init (void)
204	{	204	{
205	GPIO_InitTypeDef GPIO_InitStructure;	205	GPIO_InitTypeDef GPIO_InitStructure;
206	UART_InitTypeDef UART_InitStructure;	206	UART_InitTypeDef UART_InitStructure;
207		207
208	// initialize txd buffer	208	// initialize txd buffer
209	Buffer_Init(&UART1_tx_buffer, UART1_tbuffer, UART1_TX_BUFFER_LEN);	209	Buffer_Init(&UART1_tx_buffer, UART1_tbuffer, UART1_TX_BUFFER_LEN);
210		210
211	// initialize rxd buffer	211	// initialize rxd buffer
212	Buffer_Init(&UART1_rx_buffer, UART1_rbuffer, UART1_RX_BUFFER_LEN);	212	Buffer_Init(&UART1_rx_buffer, UART1_rbuffer, UART1_RX_BUFFER_LEN);
213		213
214	// initialize the rx fifo, block UART IRQ geting a byte from fifo	214	// initialize the rx fifo, block UART IRQ geting a byte from fifo
215	fifo_init(&UART1_rx_fifo, UART1_rxfifobuffer, UART1_RX_FIFO_LEN, NO_ITLine, UART1_ITLine);	215	fifo_init(&UART1_rx_fifo, UART1_rxfifobuffer, UART1_RX_FIFO_LEN, NO_ITLine, UART1_ITLine);
216		216
217	SCU_APBPeriphClockConfig(__UART1, ENABLE); // Enable the UART1 Clock	217	SCU_APBPeriphClockConfig(__UART1, ENABLE); // Enable the UART1 Clock
218	SCU_APBPeriphClockConfig(__GPIO3, ENABLE); // Enable the GPIO3 Clock	218	SCU_APBPeriphClockConfig(__GPIO3, ENABLE); // Enable the GPIO3 Clock
219		219
220	/Configure UART1_Rx pin GPIO3.2/	220	/Configure UART1_Rx pin GPIO3.2/
221	GPIO_StructInit(&GPIO_InitStructure);	221	GPIO_StructInit(&GPIO_InitStructure);
222	GPIO_InitStructure.GPIO_Direction = GPIO_PinInput;	222	GPIO_InitStructure.GPIO_Direction = GPIO_PinInput;
223	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2;	223	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2;
224	GPIO_InitStructure.GPIO_Type = GPIO_Type_PushPull;	224	GPIO_InitStructure.GPIO_Type = GPIO_Type_PushPull;
225	GPIO_InitStructure.GPIO_IPInputConnected = GPIO_IPInputConnected_Enable;	225	GPIO_InitStructure.GPIO_IPInputConnected = GPIO_IPInputConnected_Enable;
226	GPIO_InitStructure.GPIO_Alternate = GPIO_InputAlt1; // UART1_RxD	226	GPIO_InitStructure.GPIO_Alternate = GPIO_InputAlt1; // UART1_RxD
227	GPIO_Init(GPIO3, &GPIO_InitStructure);	227	GPIO_Init(GPIO3, &GPIO_InitStructure);
228		228
229	/Configure UART1_Tx pin GPIO3.3/	229	/Configure UART1_Tx pin GPIO3.3/
230	GPIO_StructInit(&GPIO_InitStructure);	230	GPIO_StructInit(&GPIO_InitStructure);
231	GPIO_InitStructure.GPIO_Direction = GPIO_PinOutput;	231	GPIO_InitStructure.GPIO_Direction = GPIO_PinOutput;
232	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_3;	232	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_3;
233	GPIO_InitStructure.GPIO_Type = GPIO_Type_PushPull;	233	GPIO_InitStructure.GPIO_Type = GPIO_Type_PushPull;
234	GPIO_InitStructure.GPIO_Alternate = GPIO_OutputAlt2; // UART1_TX	234	GPIO_InitStructure.GPIO_Alternate = GPIO_OutputAlt2; // UART1_TX
235	GPIO_Init(GPIO3, &GPIO_InitStructure);	235	GPIO_Init(GPIO3, &GPIO_InitStructure);
236		236
237	/* UART1 configured as follow:	237	/* UART1 configured as follow:
238	- Word Length = 8 Bits	238	- Word Length = 8 Bits
239	- One Stop Bit	239	- One Stop Bit
240	- No parity	240	- No parity
241	- BaudRate = 57600 baud	241	- BaudRate = 57600 baud
242	- Hardware flow control Disabled	242	- Hardware flow control Disabled
243	- Receive and transmit enabled	243	- Receive and transmit enabled
244	- Receive and transmit FIFOs are Disabled	244	- Receive and transmit FIFOs are Disabled
245	*/	245	*/
246	UART_StructInit(&UART_InitStructure);	246	UART_StructInit(&UART_InitStructure);
247	UART_InitStructure.UART_WordLength = UART_WordLength_8D;	247	UART_InitStructure.UART_WordLength = UART_WordLength_8D;
248	UART_InitStructure.UART_StopBits = UART_StopBits_1;	248	UART_InitStructure.UART_StopBits = UART_StopBits_1;
249	UART_InitStructure.UART_Parity = UART_Parity_No ;	249	UART_InitStructure.UART_Parity = UART_Parity_No ;
250	UART_InitStructure.UART_BaudRate = UART1_BAUD_RATE;	250	UART_InitStructure.UART_BaudRate = UART1_BAUD_RATE;
251	UART_InitStructure.UART_HardwareFlowControl = UART_HardwareFlowControl_None;	251	UART_InitStructure.UART_HardwareFlowControl = UART_HardwareFlowControl_None;
252	UART_InitStructure.UART_Mode = UART_Mode_Tx_Rx;	252	UART_InitStructure.UART_Mode = UART_Mode_Tx_Rx;
253	// UART_InitStructure.UART_FIFO = UART_FIFO_Enable;	253	// UART_InitStructure.UART_FIFO = UART_FIFO_Enable;
254	UART_InitStructure.UART_FIFO = UART_FIFO_Disable;	254	UART_InitStructure.UART_FIFO = UART_FIFO_Disable;
255	// UART_InitStructure.UART_TxFIFOLevel = UART_FIFOLevel_1_2;	255	// UART_InitStructure.UART_TxFIFOLevel = UART_FIFOLevel_1_2;
256	UART_InitStructure.UART_TxFIFOLevel = UART_FIFOLevel_1_8; // FIFO size 16 bytes, FIFO level 2 bytes	256	UART_InitStructure.UART_TxFIFOLevel = UART_FIFOLevel_1_8; // FIFO size 16 bytes, FIFO level 2 bytes
257	UART_InitStructure.UART_RxFIFOLevel = UART_FIFOLevel_1_2; // FIFO size 16 bytes, FIFO level 8 bytes	257	UART_InitStructure.UART_RxFIFOLevel = UART_FIFOLevel_1_2; // FIFO size 16 bytes, FIFO level 8 bytes
258		258
259	UART_DeInit(UART1); // reset uart 1 to default	259	UART_DeInit(UART1); // reset uart 1 to default
260	UART_Init(UART1, &UART_InitStructure); // initialize uart 1	260	UART_Init(UART1, &UART_InitStructure); // initialize uart 1
261	// enable uart 1 interrupts selective	261	// enable uart 1 interrupts selective
262	UART_ITConfig(UART1, UART_IT_Receive \| UART_IT_ReceiveTimeOut, ENABLE);	262	UART_ITConfig(UART1, UART_IT_Receive \| UART_IT_ReceiveTimeOut, ENABLE);
263	UART_Cmd(UART1, ENABLE); // enable uart 1	263	UART_Cmd(UART1, ENABLE); // enable uart 1
264	// configure the uart 1 interupt line	264	// configure the uart 1 interupt line
265	VIC_Config(UART1_ITLine, VIC_IRQ, PRIORITY_UART1);	265	VIC_Config(UART1_ITLine, VIC_IRQ, PRIORITY_UART1);
266	// enable the uart 1 IRQ	266	// enable the uart 1 IRQ
267	VIC_ITCmd(UART1_ITLine, ENABLE);	267	VIC_ITCmd(UART1_ITLine, ENABLE);
268		268
269	// initialize the debug timer	269	// initialize the debug timer
270	UART1_DebugData_Timer = SetDelay(UART1_DebugData_Interval);	270	UART1_DebugData_Timer = SetDelay(UART1_DebugData_Interval);
271	UART1_NaviData_Timer = SetDelay(UART1_NaviData_Interval)+500;	271	UART1_NaviData_Timer = SetDelay(UART1_NaviData_Interval)+500;
272	NMEA_Timer = SetDelay(14000);	272	NMEA_Timer = SetDelay(14000);
273		273
274	// Fill Version Info Structure	274	// Fill Version Info Structure
275	UART_VersionInfo.SWMajor = VERSION_MAJOR;	275	UART_VersionInfo.SWMajor = VERSION_MAJOR;
276	UART_VersionInfo.SWMinor = VERSION_MINOR;	276	UART_VersionInfo.SWMinor = VERSION_MINOR;
277	UART_VersionInfo.SWPatch = VERSION_PATCH;	277	UART_VersionInfo.SWPatch = VERSION_PATCH;
278	UART_VersionInfo.ProtoMajor = VERSION_SERIAL_MAJOR;	278	UART_VersionInfo.ProtoMajor = VERSION_SERIAL_MAJOR;
279	UART_VersionInfo.ProtoMinor = VERSION_SERIAL_MINOR;	279	UART_VersionInfo.ProtoMinor = VERSION_SERIAL_MINOR;
280	UART_VersionInfo.HWMajor = Version_HW;	280	UART_VersionInfo.HWMajor = Version_HW & 0x7f;
281	UART_VersionInfo.reserved2 = 0;	281	UART_VersionInfo.reserved2 = 0;
282	UART_VersionInfo.Flags = 0;	282	UART_VersionInfo.Flags = 0;
283	NaviData.Version = NAVIDATA_VERSION;	283	NaviData.Version = NAVIDATA_VERSION;
284		284
285	UART1_PutString("\r\n UART1 init...ok");	285	UART1_PutString("\r\n UART1 init...ok");
286	}	286	}
287		287
288		288
289	/****************************************************************/	289	/****************************************************************/
290	/* USART1 receiver ISR */	290	/* USART1 receiver ISR */
291	/****************************************************************/	291	/****************************************************************/
292	void UART1_IRQHandler(void)	292	void UART1_IRQHandler(void)
293	{	293	{
294	static u8 abortState = 0;	294	static u8 abortState = 0;
295	u8 c;	295	u8 c;
296		296
297	if((UART_GetITStatus(UART1, UART_IT_Receive) != RESET) \|\| (UART_GetITStatus(UART1, UART_IT_ReceiveTimeOut) != RESET) )	297	if((UART_GetITStatus(UART1, UART_IT_Receive) != RESET) \|\| (UART_GetITStatus(UART1, UART_IT_ReceiveTimeOut) != RESET) )
298	{	298	{
299	// clear the pending bits!	299	// clear the pending bits!
300	UART_ClearITPendingBit(UART1, UART_IT_Receive);	300	UART_ClearITPendingBit(UART1, UART_IT_Receive);
301	UART_ClearITPendingBit(UART1, UART_IT_ReceiveTimeOut);	301	UART_ClearITPendingBit(UART1, UART_IT_ReceiveTimeOut);
302	// if debug UART is not UART1	302	// if debug UART is not UART1
303	if (DebugUART != UART1)	303	if (DebugUART != UART1)
304	{ // forward received data to the debug UART tx buffer	304	{ // forward received data to the debug UART tx buffer
305	while(UART_GetFlagStatus(UART1, UART_FLAG_RxFIFOEmpty) != SET)	305	while(UART_GetFlagStatus(UART1, UART_FLAG_RxFIFOEmpty) != SET)
306	{	306	{
307	// move the byte from the rx buffer of UART1 to the tx buffer of DebugUART	307	// move the byte from the rx buffer of UART1 to the tx buffer of DebugUART
308	c = UART_ReceiveData(UART1);	308	c = UART_ReceiveData(UART1);
309		309
310	// check for abort condition (ESC ESC 0x55 0xAA 0x00)	310	// check for abort condition (ESC ESC 0x55 0xAA 0x00)
311	switch (abortState)	311	switch (abortState)
312	{	312	{
313	case 0:	313	case 0:
314	if (c == 27) abortState++;	314	if (c == 27) abortState++;
315	break;	315	break;
316	case 1:	316	case 1:
317	if (c == 27) abortState++;	317	if (c == 27) abortState++;
318	else abortState = 0;	318	else abortState = 0;
319	break;	319	break;
320	case 2:	320	case 2:
321	if (c == 0x55) abortState++;	321	if (c == 0x55) abortState++;
322	else abortState = 0;	322	else abortState = 0;
323	break;	323	break;
324	case 3:	324	case 3:
325	if (c == 0xAA) abortState++;	325	if (c == 0xAA) abortState++;
326	else abortState = 0;	326	else abortState = 0;
327	break;	327	break;
328	case 4:	328	case 4:
329	if (c == 0x00)	329	if (c == 0x00)
330	{	330	{
331	if(DebugUART == UART0)	331	if(DebugUART == UART0)
332	{	332	{
333	UART0_Connect_to_MKGPS(UART0_BAUD_RATE);	333	UART0_Connect_to_MKGPS(UART0_BAUD_RATE);
334	TIMER2_Init(); // enbable servo outputs	334	TIMER2_Init(); // enbable servo outputs
335	fifo_purge(&UART1_rx_fifo); // flush the whole fifo init buffer	335	fifo_purge(&UART1_rx_fifo); // flush the whole fifo init buffer
336	}	336	}
337	DebugUART = UART1;	337	DebugUART = UART1;
338	}	338	}
339	abortState = 0;	339	abortState = 0;
340	break;	340	break;
341	} // end switch abort state	341	} // end switch abort state
342	// if the Debug uart is not UART1, redirect input to the Debug UART	342	// if the Debug uart is not UART1, redirect input to the Debug UART
343	if (DebugUART != UART1)	343	if (DebugUART != UART1)
344	{	344	{
345	// wait for space in the tx buffer of the DebugUART	345	// wait for space in the tx buffer of the DebugUART
346	while(UART_GetFlagStatus(DebugUART, UART_FLAG_TxFIFOFull) == SET) {};	346	while(UART_GetFlagStatus(DebugUART, UART_FLAG_TxFIFOFull) == SET) {};
347	// move byte to the tx fifo of the debug uart	347	// move byte to the tx fifo of the debug uart
348	UART_SendData(DebugUART, c);	348	UART_SendData(DebugUART, c);
349	}	349	}
350	}	350	}
351	}	351	}
352	else // DebugUART == UART1 (normal operation)	352	else // DebugUART == UART1 (normal operation)
353	{	353	{
354	while(UART_GetFlagStatus(UART1, UART_FLAG_RxFIFOEmpty) != SET)	354	while(UART_GetFlagStatus(UART1, UART_FLAG_RxFIFOEmpty) != SET)
355	{ // some byes in the hardware fifo	355	{ // some byes in the hardware fifo
356	// get byte from hardware fifo	356	// get byte from hardware fifo
357	c = UART_ReceiveData(UART1);	357	c = UART_ReceiveData(UART1);
358	// put into the software fifo	358	// put into the software fifo
359	if(!fifo_put(&UART1_rx_fifo, c))	359	if(!fifo_put(&UART1_rx_fifo, c))
360	{ // fifo overflow	360	{ // fifo overflow
361	//fifo_purge(&UART1_rx_fifo); // flush the whole buffer	361	//fifo_purge(&UART1_rx_fifo); // flush the whole buffer
362	}	362	}
363	} // EOF while some byes in the hardware fifo	363	} // EOF while some byes in the hardware fifo
364	} // eof DebugUart = UART1	364	} // eof DebugUart = UART1
365	}	365	}
366		366
367		367
368		368
369	VIC1->VAR = 0xFF; // write any value to VIC1 Vector address register	369	VIC1->VAR = 0xFF; // write any value to VIC1 Vector address register
370	}	370	}
371		371
372	/**************************************************************/	372	/**************************************************************/
373	/* Process incomming data from debug uart */	373	/* Process incomming data from debug uart */
374	/**************************************************************/	374	/**************************************************************/
375	void UART1_ProcessRxData(void)	375	void UART1_ProcessRxData(void)
376	{	376	{
377	// return on forwarding uart or unlocked rx buffer	377	// return on forwarding uart or unlocked rx buffer
378	u8 c;	378	u8 c;
379	if(DebugUART != UART1) return;	379	if(DebugUART != UART1) return;
380	// if rx buffer is not locked	380	// if rx buffer is not locked
381	if(UART1_rx_buffer.Locked == FALSE)	381	if(UART1_rx_buffer.Locked == FALSE)
382	{	382	{
383	//collect data from primary rx fifo	383	//collect data from primary rx fifo
384	while(fifo_get(&UART1_rx_fifo, &c))	384	while(fifo_get(&UART1_rx_fifo, &c))
385	{	385	{
386	// break if complete frame is collected	386	// break if complete frame is collected
387	if(MKProtocol_CollectSerialFrame(&UART1_rx_buffer, c)) break;	387	if(MKProtocol_CollectSerialFrame(&UART1_rx_buffer, c)) break;
388	}	388	}
389	}	389	}
390	if(UART1_rx_buffer.Locked == FALSE) return;	390	if(UART1_rx_buffer.Locked == FALSE) return;
391		391
392	Point_t * pPoint = NULL;	392	Point_t * pPoint = NULL;
393	SerialMsg_t SerialMsg;	393	SerialMsg_t SerialMsg;
394		394
395	// analyze header first	395	// analyze header first
396	MKProtocol_DecodeSerialFrameHeader(&UART1_rx_buffer, &SerialMsg);	396	MKProtocol_DecodeSerialFrameHeader(&UART1_rx_buffer, &SerialMsg);
397	if( SerialMsg.Address == FC_ADDRESS )	397	if( SerialMsg.Address == FC_ADDRESS )
398	{	398	{
399	switch(SerialMsg.CmdID)	399	switch(SerialMsg.CmdID)
400	{	400	{
401	// case 'v': // version	401	// case 'v': // version
402	case 'b': // extern control	402	case 'b': // extern control
403	UART1_ExternalControlConfirmFrame = 1;	403	UART1_ExternalControlConfirmFrame = 1;
404	case 'y': // serial poti values	404	case 'y': // serial poti values
405	Buffer_Copy(&UART1_rx_buffer, &UART2_tx_buffer); //forward to FC	405	Buffer_Copy(&UART1_rx_buffer, &UART2_tx_buffer); //forward to FC
406	Buffer_Clear(&UART1_rx_buffer); // free rc buffer for next frame	406	Buffer_Clear(&UART1_rx_buffer); // free rc buffer for next frame
407	return; //end process rx data	407	return; //end process rx data
408	break;	408	break;
409	}	409	}
410	}	410	}
411		411
412	MKProtocol_DecodeSerialFrameData(&UART1_rx_buffer, &SerialMsg); // decode serial frame in rxd buffer	412	MKProtocol_DecodeSerialFrameData(&UART1_rx_buffer, &SerialMsg); // decode serial frame in rxd buffer
413	if(SerialMsg.CmdID != 'z') SerialLinkOkay = 250; // reset SerialTimeout, but not in case of the "ping"	413	if(SerialMsg.CmdID != 'z') SerialLinkOkay = 250; // reset SerialTimeout, but not in case of the "ping"
414	switch(SerialMsg.Address) // check for Slave Address	414	switch(SerialMsg.Address) // check for Slave Address
415	{	415	{
416	case NC_ADDRESS: // own Slave Address	416	case NC_ADDRESS: // own Slave Address
417	switch(SerialMsg.CmdID)	417	switch(SerialMsg.CmdID)
418	{	418	{
419	case 't': // request for the GPS time	419	case 't': // request for the GPS time
420	UART1_Request_SystemTime = TRUE;	420	UART1_Request_SystemTime = TRUE;
421	break;	421	break;
422		422
423	case 'f': // ftp command	423	case 'f': // ftp command
424	UART1_Request_FTP = SerialMsg.pData[0];	424	UART1_Request_FTP = SerialMsg.pData[0];
425	//if (UART1_Request_FTP == FTP_CMD_SET_CWD \|\| UART1_Request_FTP == FTP_CMD_GET_FILE)	425	//if (UART1_Request_FTP == FTP_CMD_SET_CWD \|\| UART1_Request_FTP == FTP_CMD_GET_FILE)
426	memcpy(&FTP_data, &SerialMsg.pData[1], sizeof(FTP_data)); // copy ftp parameter	426	memcpy(&FTP_data, &SerialMsg.pData[1], sizeof(FTP_data)); // copy ftp parameter
427	break;	427	break;
428		428
429	case 'z': // connection checker	429	case 'z': // connection checker
430	memcpy(&Echo, SerialMsg.pData, sizeof(Echo)); // copy echo pattern	430	memcpy(&Echo, SerialMsg.pData, sizeof(Echo)); // copy echo pattern
431	UART1_Request_Echo = TRUE;	431	UART1_Request_Echo = TRUE;
432	break;	432	break;
433		433
434	case 'e': // request for the text of the error status	434	case 'e': // request for the text of the error status
435	UART1_Request_ErrorMessage = TRUE;	435	UART1_Request_ErrorMessage = TRUE;
436	break;	436	break;
437		437
438	case 's':// new target position	438	case 's':// new target position
439	pPoint = (Point_t*)SerialMsg.pData;	439	pPoint = (Point_t*)SerialMsg.pData;
440	if(pPoint->Position.Status == NEWDATA)	440	if(pPoint->Position.Status == NEWDATA)
441	{	441	{
442	//if(!(FC.StatusFlags & FC_STATUS_FLY)) PointList_Clear(); // flush the list	442	//if(!(FC.StatusFlags & FC_STATUS_FLY)) PointList_Clear(); // flush the list
443	//pPoint->Index = 1; // must be one after empty list	443	//pPoint->Index = 1; // must be one after empty list
444	PointList_SetAt(pPoint);	444	PointList_SetAt(pPoint);
445	if(FC.StatusFlags & FC_STATUS_FLY) PointList_WPActive(TRUE);	445	if(FC.StatusFlags & FC_STATUS_FLY) PointList_WPActive(TRUE);
446	GPS_pWaypoint = PointList_WPBegin(); // updates POI index	446	GPS_pWaypoint = PointList_WPBegin(); // updates POI index
447	if(GPS_pWaypoint != NULL) // if new WP exist	447	if(GPS_pWaypoint != NULL) // if new WP exist
448	{ // update WP hold time stamp immediately!	448	{ // update WP hold time stamp immediately!
449	EnableNewWpHeading();	449	EnableNewWpHeading();
450	/* if(GPS_pWaypoint->Heading > 0 && GPS_pWaypoint->Heading <= 360)	450	/* if(GPS_pWaypoint->Heading > 0 && GPS_pWaypoint->Heading <= 360)
451	{	451	{
452	CAM_Orientation.Azimuth = GPS_pWaypoint->Heading;	452	CAM_Orientation.Azimuth = GPS_pWaypoint->Heading;
453	CAM_Orientation.UpdateMask \|= CAM_UPDATE_AZIMUTH;	453	CAM_Orientation.UpdateMask \|= CAM_UPDATE_AZIMUTH;
454	}	454	}
455	*/	455	*/
456	}	456	}
457	BeepTime = 50;	457	BeepTime = 50;
458	}	458	}
459	break;	459	break;
460		460
461	case 'u': // redirect debug uart	461	case 'u': // redirect debug uart
462	switch(SerialMsg.pData[0])	462	switch(SerialMsg.pData[0])
463	{	463	{
464	case UART_FLIGHTCTRL:	464	case UART_FLIGHTCTRL:
465	UART2_Init(); // initialize UART2 to FC pins	465	UART2_Init(); // initialize UART2 to FC pins
466	fifo_purge(&UART1_rx_fifo);	466	fifo_purge(&UART1_rx_fifo);
467	TIMER2_Deinit(); // reduce irq load	467	TIMER2_Deinit(); // reduce irq load
468	DebugUART = UART2;	468	DebugUART = UART2;
469	break;	469	break;
470	case UART_MK3MAG:	470	case UART_MK3MAG:
471	if(FC.StatusFlags & FC_STATUS_MOTOR_RUN) break; // not if the motors are running	471	if(FC.StatusFlags & FC_STATUS_MOTOR_RUN) break; // not if the motors are running
472	UART0_Connect_to_MK3MAG(); // mux UART0 to MK3MAG pins	472	UART0_Connect_to_MK3MAG(); // mux UART0 to MK3MAG pins
473	GPSData.Status = INVALID;	473	GPSData.Status = INVALID;
474	fifo_purge(&UART1_rx_fifo);	474	fifo_purge(&UART1_rx_fifo);
475	DebugUART = UART0;	475	DebugUART = UART0;
476	break;	476	break;
477	case UART_MKGPS:	477	case UART_MKGPS:
478	if(FC.StatusFlags & FC_STATUS_MOTOR_RUN) break; // not if the motors are running	478	if(FC.StatusFlags & FC_STATUS_MOTOR_RUN) break; // not if the motors are running
479	TIMER2_Deinit(); // disable servo outputs to reduce irq load	479	TIMER2_Deinit(); // disable servo outputs to reduce irq load
480	UART0_Connect_to_MKGPS(UART0_BAUD_RATE); // connect UART0 to MKGPS pins	480	UART0_Connect_to_MKGPS(UART0_BAUD_RATE); // connect UART0 to MKGPS pins
481	GPSData.Status = INVALID;	481	GPSData.Status = INVALID;
482	fifo_purge(&UART1_rx_fifo);	482	fifo_purge(&UART1_rx_fifo);
483	DebugUART = UART0;	483	DebugUART = UART0;
484	break;	484	break;
485	default:	485	default:
486	break;	486	break;
487	}	487	}
488	break;	488	break;
489		489
490	case 'w':// Set point in list at index	490	case 'w':// Set point in list at index
491	{	491	{
492	pPoint = (Point_t*)SerialMsg.pData;	492	pPoint = (Point_t*)SerialMsg.pData;
493		493
494	if((pPoint->Position.Status == INVALID) && (pPoint->Index == 0))	494	if((pPoint->Position.Status == INVALID) && (pPoint->Index == 0))
495	{	495	{
496	PointList_Clear();	496	PointList_Clear();
497	GPS_pWaypoint = PointList_WPBegin();	497	GPS_pWaypoint = PointList_WPBegin();
498	UART1_Request_WritePoint = 0; // return new point count	498	UART1_Request_WritePoint = 0; // return new point count
499	}	499	}
500	else	500	else

Subversion Repositories NaviCtrl

(root)/tags/V2.08a/uart1.c @ 610 - Rev 483 → 486