WebSVN - NaviCtrl - Diff - Rev 398 and 403


/*#######################################################################################*/
/* !!! 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 <stdarg.h>
#include <string.h>
 
#include "91x_lib.h"
#include "main.h"
#include "config.h"
#include "menu.h"
#include "GPS.h"
#include "i2c.h"
#include "uart0.h"
#include "uart1.h"
#include "uart2.h"
#include "timer1.h"
#include "timer2.h"
#include "analog.h"
#include "compass.h"
#include "waypoints.h"
#include "mkprotocol.h"
#include "params.h"
#include "fifo.h"
#include "debug.h"
#include "spi_slave.h"
#include "ftphelper.h"
#include "led.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_DisplayKeys                    = 0;
u8 UART1_DisplayLine                    = 0;
u8 UART1_ConfirmFrame                   = 0;
u8 UART1_Request_FTP                    = FALSE;
u8 LastTransmittedFCStatusFlags2 = 0;
u8 UART1_ExternalControlConfirmFrame = 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        ",
        "NickServo       ",
        "RollServo       ",
        "GPS Data        ",
        "CompassHeading  ", //10
        "GyroHeading     ",
        "SPI Error       ",
        "SPI Okay        ",
        "I2C Error       ",
        "I2C Okay        ", //15
        "16              ",
        "17              ",
        "18              ",
        "19              ", // SD-Card-time 
        "EarthMagnet [%] ", //20
        "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
 
/********************************************************/
/*            Initialization the UART1                  */
/********************************************************/
void UART1_Init (void)
{
        GPIO_InitTypeDef GPIO_InitStructure;
        UART_InitTypeDef UART_InitStructure;
 
        // initialize txd buffer
        Buffer_Init(&UART1_tx_buffer, UART1_tbuffer, UART1_TX_BUFFER_LEN);
 
        // initialize rxd buffer
        Buffer_Init(&UART1_rx_buffer, UART1_rbuffer, UART1_RX_BUFFER_LEN);
 
        // initialize the rx fifo, block UART IRQ geting a byte from fifo
        fifo_init(&UART1_rx_fifo, UART1_rxfifobuffer, UART1_RX_FIFO_LEN, NO_ITLine, UART1_ITLine);
 
        SCU_APBPeriphClockConfig(__UART1, ENABLE);  // Enable the UART1 Clock
        SCU_APBPeriphClockConfig(__GPIO3, ENABLE);  // Enable the GPIO3 Clock
 
        /*Configure UART1_Rx pin GPIO3.2*/
        GPIO_StructInit(&GPIO_InitStructure);
        GPIO_InitStructure.GPIO_Direction =     GPIO_PinInput;
        GPIO_InitStructure.GPIO_Pin =                   GPIO_Pin_2;
        GPIO_InitStructure.GPIO_Type =                  GPIO_Type_PushPull;
        GPIO_InitStructure.GPIO_IPInputConnected =      GPIO_IPInputConnected_Enable;
        GPIO_InitStructure.GPIO_Alternate =     GPIO_InputAlt1; // UART1_RxD
        GPIO_Init(GPIO3, &GPIO_InitStructure);
 
        /*Configure UART1_Tx pin GPIO3.3*/
        GPIO_StructInit(&GPIO_InitStructure);
        GPIO_InitStructure.GPIO_Direction =     GPIO_PinOutput;
        GPIO_InitStructure.GPIO_Pin =                   GPIO_Pin_3;
        GPIO_InitStructure.GPIO_Type =                  GPIO_Type_PushPull;
        GPIO_InitStructure.GPIO_Alternate =     GPIO_OutputAlt2; // UART1_TX
        GPIO_Init(GPIO3, &GPIO_InitStructure);
 
        /* UART1 configured as follow:
        - Word Length = 8 Bits
        - One Stop Bit
        - No parity
        - BaudRate = 57600 baud
        - Hardware flow control Disabled
        - Receive and transmit enabled
        - Receive and transmit FIFOs are Disabled
        */
        UART_StructInit(&UART_InitStructure);
        UART_InitStructure.UART_WordLength =                    UART_WordLength_8D;
        UART_InitStructure.UART_StopBits =                              UART_StopBits_1;
        UART_InitStructure.UART_Parity =                                UART_Parity_No ;
        UART_InitStructure.UART_BaudRate =                              UART1_BAUD_RATE;
        UART_InitStructure. UART_HardwareFlowControl =  UART_HardwareFlowControl_None;
        UART_InitStructure.UART_Mode =                                  UART_Mode_Tx_Rx;
        UART_InitStructure.UART_FIFO =                                  UART_FIFO_Enable;
        UART_InitStructure.UART_TxFIFOLevel =                   UART_FIFOLevel_1_2;
        UART_InitStructure.UART_RxFIFOLevel =                   UART_FIFOLevel_1_2;
 
        UART_DeInit(UART1); // reset uart 1     to default
        UART_Init(UART1, &UART_InitStructure); // initialize uart 1
        // enable uart 1 interrupts selective
        UART_ITConfig(UART1, UART_IT_Receive | UART_IT_ReceiveTimeOut, ENABLE);
        UART_Cmd(UART1, ENABLE); // enable uart 1
        // configure the uart 1 interupt line
        VIC_Config(UART1_ITLine, VIC_IRQ, PRIORITY_UART1);
        // enable the uart 1 IRQ
        VIC_ITCmd(UART1_ITLine, ENABLE);
 
        // initialize the debug timer
        UART1_DebugData_Timer = SetDelay(UART1_DebugData_Interval);
        UART1_NaviData_Timer = SetDelay(UART1_NaviData_Interval)+500;
 
        // Fill Version Info Structure
        UART_VersionInfo.SWMajor = VERSION_MAJOR;
        UART_VersionInfo.SWMinor = VERSION_MINOR;
        UART_VersionInfo.SWPatch = VERSION_PATCH;
        UART_VersionInfo.ProtoMajor = VERSION_SERIAL_MAJOR;
        UART_VersionInfo.ProtoMinor = VERSION_SERIAL_MINOR;
 
        NaviData.Version = NAVIDATA_VERSION;
 
        UART1_PutString("\r\n UART1 init...ok");
}
 
 
/****************************************************************/
/*               USART1 receiver ISR                            */
/****************************************************************/
void UART1_IRQHandler(void)
{
        static u8 abortState = 0;
        u8 c;
 
        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 '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!
/*                                              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 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 == '\r') || (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
                        }
                }
        }
}
 
 
/**************************************************************/
/* 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))
        {
                CheckFTPCommand(UART1_Request_FTP);
                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(UART1_ConfirmFrame && (UART1_tx_buffer.Locked == FALSE))
        {
                MKProtocol_CreateSerialFrame(&UART1_tx_buffer, 'B', NC_ADDRESS, 1, &UART1_ConfirmFrame, sizeof(UART1_ConfirmFrame));
                UART1_ConfirmFrame = 0;
        }
        */
        /*
        else if(UART1_Request_ExternalControl && (UART1_tx_buffer.Locked == FALSE))
        {
                MKProtocol_CreateSerialFrame(&UART1_tx_buffer, 'G', NC_ADDRESS, 1, (u8 *)&ExternControl, sizeof(ExternControl));
                UART1_Request_ExternalControl = FALSE;
        }
        */
        else if( (( (UART1_Display_Interval > 0) && CheckDelay(UART1_Display_Timer)) || UART1_Request_Display) && (UART1_tx_buffer.Locked == FALSE))
        {
                if(UART1_DisplayLine > 3)
                {
                        Menu_Update(UART1_DisplayKeys);
                        UART1_DisplayKeys = 0;
                        MKProtocol_CreateSerialFrame(&UART1_tx_buffer, 'H', NC_ADDRESS, 1, (u8*)DisplayBuff, sizeof(DisplayBuff));
                }
                else
                {
                        UART1_DisplayLine = 2;
                        sprintf(text,"!!! incompatible !!!");
                        MKProtocol_CreateSerialFrame(&UART1_tx_buffer, 'H', NC_ADDRESS, 2, &UART1_DisplayLine, sizeof(UART1_DisplayLine), (u8*)&text, 20);
                        if(UART1_DisplayLine++ > 3) UART1_DisplayLine = 0;
                }
                UART1_Display_Timer = SetDelay(UART1_Display_Interval);
                UART1_Request_Display = FALSE;
        }
        else if(UART1_Request_Display1 && (UART1_tx_buffer.Locked == FALSE))
        {
                Menu_Update(0);
                MKProtocol_CreateSerialFrame(&UART1_tx_buffer, 'L', NC_ADDRESS, 3, (u8*)&MenuItem, sizeof(MenuItem), (u8*)&MaxMenuItem, sizeof(MaxMenuItem),(u8*)DisplayBuff, sizeof(DisplayBuff));
                UART1_Request_Display1 = FALSE;
        }
        else if(UART1_Request_VersionInfo && (UART1_tx_buffer.Locked == FALSE))
        {
                MKProtocol_CreateSerialFrame(&UART1_tx_buffer, 'V', NC_ADDRESS,1, (u8 *)&UART_VersionInfo, sizeof(UART_VersionInfo));
                UART1_Request_VersionInfo = FALSE;
        }
        else if(UART1_Request_ErrorMessage && (UART1_tx_buffer.Locked == FALSE))
        {
                MKProtocol_CreateSerialFrame(&UART1_tx_buffer, 'E', NC_ADDRESS, 1, (u8 *)&ErrorMSG, sizeof(ErrorMSG));
                UART1_Request_ErrorMessage = FALSE;
        }
#ifdef 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 398	Rev 403
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 <stdarg.h>	57	#include <stdarg.h>
58	#include <string.h>	58	#include <string.h>
59		59
60	#include "91x_lib.h"	60	#include "91x_lib.h"
61	#include "main.h"	61	#include "main.h"
62	#include "config.h"	62	#include "config.h"
63	#include "menu.h"	63	#include "menu.h"
64	#include "GPS.h"	64	#include "GPS.h"
65	#include "i2c.h"	65	#include "i2c.h"
66	#include "uart0.h"	66	#include "uart0.h"
67	#include "uart1.h"	67	#include "uart1.h"
68	#include "uart2.h"	68	#include "uart2.h"
69	#include "timer1.h"	69	#include "timer1.h"
70	#include "timer2.h"	70	#include "timer2.h"
71	#include "analog.h"	71	#include "analog.h"
72	#include "compass.h"	72	#include "compass.h"
73	#include "waypoints.h"	73	#include "waypoints.h"
74	#include "mkprotocol.h"	74	#include "mkprotocol.h"
75	#include "params.h"	75	#include "params.h"
76	#include "fifo.h"	76	#include "fifo.h"
77	#include "debug.h"	77	#include "debug.h"
78	#include "spi_slave.h"	78	#include "spi_slave.h"
79	#include "ftphelper.h"	79	#include "ftphelper.h"
80	#include "led.h"	80	#include "led.h"
81		81
82	#define FALSE 0	82	#define FALSE 0
83	#define TRUE 1	83	#define TRUE 1
84		84
85	#define ABO_TIMEOUT 8000 // disable abo after 8 seconds	85	#define ABO_TIMEOUT 8000 // disable abo after 8 seconds
86	u32 UART1_AboTimeOut = 0;	86	u32 UART1_AboTimeOut = 0;
87		87
88	u8 UART1_Request_VersionInfo = FALSE;	88	u8 UART1_Request_VersionInfo = FALSE;
89	u8 UART1_Request_ExternalControl= FALSE;	89	u8 UART1_Request_ExternalControl= FALSE;
90	u8 UART1_Request_Display = FALSE;	90	u8 UART1_Request_Display = FALSE;
91	u8 UART1_Request_Display1 = FALSE;	91	u8 UART1_Request_Display1 = FALSE;
92	u8 UART1_Request_DebugData = FALSE;	92	u8 UART1_Request_DebugData = FALSE;
93	u8 UART1_Request_DebugLabel = 255;	93	u8 UART1_Request_DebugLabel = 255;
94	u8 UART1_Request_NaviData = FALSE;	94	u8 UART1_Request_NaviData = FALSE;
95	u8 UART1_Request_ErrorMessage = FALSE;	95	u8 UART1_Request_ErrorMessage = FALSE;
96	u8 UART1_Request_WritePoint = 0xFF;	96	u8 UART1_Request_WritePoint = 0xFF;
97	u8 UART1_Request_ReadPoint = 0;	97	u8 UART1_Request_ReadPoint = 0;
98	u8 UART1_Request_Data3D = FALSE;	98	u8 UART1_Request_Data3D = FALSE;
99	u8 UART1_Request_MotorData = FALSE;	99	u8 UART1_Request_MotorData = FALSE;
100	u8 UART1_Request_Echo = FALSE;	100	u8 UART1_Request_Echo = FALSE;
101	u8 UART1_Request_ParameterId = 0;	101	u8 UART1_Request_ParameterId = 0;
102	u8 UART1_Request_Parameter = FALSE;	102	u8 UART1_Request_Parameter = FALSE;
103	u8 UART1_DisplayKeys = 0;	103	u8 UART1_DisplayKeys = 0;
104	u8 UART1_DisplayLine = 0;	104	u8 UART1_DisplayLine = 0;
105	u8 UART1_ConfirmFrame = 0;	105	u8 UART1_ConfirmFrame = 0;
106	u8 UART1_Request_FTP = FALSE;	106	u8 UART1_Request_FTP = FALSE;
107	u8 LastTransmittedFCStatusFlags2 = 0;	107	u8 LastTransmittedFCStatusFlags2 = 0;
108	u8 UART1_ExternalControlConfirmFrame = FALSE;	108	u8 UART1_ExternalControlConfirmFrame = FALSE;
109		109
110	UART_TypeDef *DebugUART = UART1;	110	UART_TypeDef *DebugUART = UART1;
111		111
112	#ifdef FOLLOW_ME	112	#ifdef FOLLOW_ME
113	#define FOLLOW_ME_INTERVAL 200 // 5 Hz	113	#define FOLLOW_ME_INTERVAL 200 // 5 Hz
114	u32 UART1_FollowMe_Timer = 0;	114	u32 UART1_FollowMe_Timer = 0;
115	Point_t FollowMe;	115	Point_t FollowMe;
116	#endif	116	#endif
117		117
118	// the primary rx fifo	118	// the primary rx fifo
119	#define UART1_RX_FIFO_LEN 1024	119	#define UART1_RX_FIFO_LEN 1024
120	u8 UART1_rxfifobuffer[UART1_RX_FIFO_LEN];	120	u8 UART1_rxfifobuffer[UART1_RX_FIFO_LEN];
121	fifo_t UART1_rx_fifo;	121	fifo_t UART1_rx_fifo;
122		122
123	// the rx buffer	123	// the rx buffer
124	#define UART1_RX_BUFFER_LEN 1024	124	#define UART1_RX_BUFFER_LEN 1024
125	u8 UART1_rbuffer[UART1_RX_BUFFER_LEN];	125	u8 UART1_rbuffer[UART1_RX_BUFFER_LEN];
126	Buffer_t UART1_rx_buffer;	126	Buffer_t UART1_rx_buffer;
127		127
128	// the tx buffer	128	// the tx buffer
129	#define UART1_TX_BUFFER_LEN 1024	129	#define UART1_TX_BUFFER_LEN 1024
130	u8 UART1_tbuffer[UART1_TX_BUFFER_LEN];	130	u8 UART1_tbuffer[UART1_TX_BUFFER_LEN];
131	Buffer_t UART1_tx_buffer;	131	Buffer_t UART1_tx_buffer;
132		132
133	volatile u8 SerialLinkOkay = 0;	133	volatile u8 SerialLinkOkay = 0;
134		134
135	u8 text[200];	135	u8 text[200];
136		136
137	const u8 ANALOG_LABEL[32][16] =	137	const u8 ANALOG_LABEL[32][16] =
138	{	138	{
139	//1234567890123456	139	//1234567890123456
140	"AngleNick ", //0	140	"AngleNick ", //0
141	"AngleRoll ",	141	"AngleRoll ",
142	"AccNick ",	142	"AccNick ",
143	"AccRoll ",	143	"AccRoll ",
144	"OperatingRadius ",	144	"OperatingRadius ",
145	"FC-Flags ", //5	145	"FC-Flags ", //5
146	"NC-Flags ",	146	"NC-Flags ",
147	"NickServo ",	147	"NickServo ",
148	"RollServo ",	148	"RollServo ",
149	"GPS Data ",	149	"GPS Data ",
150	"CompassHeading ", //10	150	"CompassHeading ", //10
151	"GyroHeading ",	151	"GyroHeading ",
152	"SPI Error ",	152	"SPI Error ",
153	"SPI Okay ",	153	"SPI Okay ",
154	"I2C Error ",	154	"I2C Error ",
155	"I2C Okay ", //15	155	"I2C Okay ", //15
156	"16 ",	156	"16 ",
157	"17 ",	157	"17 ",
158	"18 ",	158	"18 ",
159	"19 ", // SD-Card-time	159	"19 ", // SD-Card-time
160	"EarthMagnet [%] ", //20	160	"EarthMagnet [%] ", //20
161	"Z_Speed ",	161	"Z_Speed ",
162	"N_Speed ",	162	"N_Speed ",
163	"E_Speed ",	163	"E_Speed ",
164	"Magnet X ",	164	"Magnet X ",
165	"Magnet Y ", //25	165	"Magnet Y ", //25
166	"Magnet Z ",	166	"Magnet Z ",
167	"Distance N ",	167	"Distance N ",
168	"Distance E ",	168	"Distance E ",
169	"GPS_Nick ",	169	"GPS_Nick ",
170	"GPS_Roll ", //30	170	"GPS_Roll ", //30
171	"Used_Sats "	171	"Used_Sats "
172	};	172	};
173		173
174	DebugOut_t DebugOut;	174	DebugOut_t DebugOut;
175	ExternControl_t ExternControl;	175	ExternControl_t ExternControl;
176	UART_VersionInfo_t UART_VersionInfo;	176	UART_VersionInfo_t UART_VersionInfo;
177	NaviData_t NaviData;	177	NaviData_t NaviData;
178	Data3D_t Data3D;	178	Data3D_t Data3D;
179	u16 Echo; // 2 bytes recieved will be sent back as echo	179	u16 Echo; // 2 bytes recieved will be sent back as echo
180		180
181	u32 UART1_DebugData_Timer = 0;	181	u32 UART1_DebugData_Timer = 0;
182	u32 UART1_DebugData_Interval = 0; // in ms	182	u32 UART1_DebugData_Interval = 0; // in ms
183	u32 UART1_NaviData_Timer = 0;	183	u32 UART1_NaviData_Timer = 0;
184	u32 UART1_NaviData_Interval = 0; // in ms	184	u32 UART1_NaviData_Interval = 0; // in ms
185	u32 UART1_Data3D_Timer = 0;	185	u32 UART1_Data3D_Timer = 0;
186	u32 UART1_Data3D_Interval = 0; // in ms	186	u32 UART1_Data3D_Interval = 0; // in ms
187	u32 UART1_MotorData_Timer = 0;	187	u32 UART1_MotorData_Timer = 0;
188	u32 UART1_MotorData_Interval = 0; // in ms	188	u32 UART1_MotorData_Interval = 0; // in ms
189	u32 UART1_Display_Timer = 0;	189	u32 UART1_Display_Timer = 0;
190	u32 UART1_Display_Interval = 0; // in ms	190	u32 UART1_Display_Interval = 0; // in ms
191		191
192	/********************************************************/	192	/********************************************************/
193	/* Initialization the UART1 */	193	/* Initialization the UART1 */
194	/********************************************************/	194	/********************************************************/
195	void UART1_Init (void)	195	void UART1_Init (void)
196	{	196	{
197	GPIO_InitTypeDef GPIO_InitStructure;	197	GPIO_InitTypeDef GPIO_InitStructure;
198	UART_InitTypeDef UART_InitStructure;	198	UART_InitTypeDef UART_InitStructure;
199		199
200	// initialize txd buffer	200	// initialize txd buffer
201	Buffer_Init(&UART1_tx_buffer, UART1_tbuffer, UART1_TX_BUFFER_LEN);	201	Buffer_Init(&UART1_tx_buffer, UART1_tbuffer, UART1_TX_BUFFER_LEN);
202		202
203	// initialize rxd buffer	203	// initialize rxd buffer
204	Buffer_Init(&UART1_rx_buffer, UART1_rbuffer, UART1_RX_BUFFER_LEN);	204	Buffer_Init(&UART1_rx_buffer, UART1_rbuffer, UART1_RX_BUFFER_LEN);
205		205
206	// initialize the rx fifo, block UART IRQ geting a byte from fifo	206	// initialize the rx fifo, block UART IRQ geting a byte from fifo
207	fifo_init(&UART1_rx_fifo, UART1_rxfifobuffer, UART1_RX_FIFO_LEN, NO_ITLine, UART1_ITLine);	207	fifo_init(&UART1_rx_fifo, UART1_rxfifobuffer, UART1_RX_FIFO_LEN, NO_ITLine, UART1_ITLine);
208		208
209	SCU_APBPeriphClockConfig(__UART1, ENABLE); // Enable the UART1 Clock	209	SCU_APBPeriphClockConfig(__UART1, ENABLE); // Enable the UART1 Clock
210	SCU_APBPeriphClockConfig(__GPIO3, ENABLE); // Enable the GPIO3 Clock	210	SCU_APBPeriphClockConfig(__GPIO3, ENABLE); // Enable the GPIO3 Clock
211		211
212	/Configure UART1_Rx pin GPIO3.2/	212	/Configure UART1_Rx pin GPIO3.2/
213	GPIO_StructInit(&GPIO_InitStructure);	213	GPIO_StructInit(&GPIO_InitStructure);
214	GPIO_InitStructure.GPIO_Direction = GPIO_PinInput;	214	GPIO_InitStructure.GPIO_Direction = GPIO_PinInput;
215	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2;	215	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2;
216	GPIO_InitStructure.GPIO_Type = GPIO_Type_PushPull;	216	GPIO_InitStructure.GPIO_Type = GPIO_Type_PushPull;
217	GPIO_InitStructure.GPIO_IPInputConnected = GPIO_IPInputConnected_Enable;	217	GPIO_InitStructure.GPIO_IPInputConnected = GPIO_IPInputConnected_Enable;
218	GPIO_InitStructure.GPIO_Alternate = GPIO_InputAlt1; // UART1_RxD	218	GPIO_InitStructure.GPIO_Alternate = GPIO_InputAlt1; // UART1_RxD
219	GPIO_Init(GPIO3, &GPIO_InitStructure);	219	GPIO_Init(GPIO3, &GPIO_InitStructure);
220		220
221	/Configure UART1_Tx pin GPIO3.3/	221	/Configure UART1_Tx pin GPIO3.3/
222	GPIO_StructInit(&GPIO_InitStructure);	222	GPIO_StructInit(&GPIO_InitStructure);
223	GPIO_InitStructure.GPIO_Direction = GPIO_PinOutput;	223	GPIO_InitStructure.GPIO_Direction = GPIO_PinOutput;
224	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_3;	224	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_3;
225	GPIO_InitStructure.GPIO_Type = GPIO_Type_PushPull;	225	GPIO_InitStructure.GPIO_Type = GPIO_Type_PushPull;
226	GPIO_InitStructure.GPIO_Alternate = GPIO_OutputAlt2; // UART1_TX	226	GPIO_InitStructure.GPIO_Alternate = GPIO_OutputAlt2; // UART1_TX
227	GPIO_Init(GPIO3, &GPIO_InitStructure);	227	GPIO_Init(GPIO3, &GPIO_InitStructure);
228		228
229	/* UART1 configured as follow:	229	/* UART1 configured as follow:
230	- Word Length = 8 Bits	230	- Word Length = 8 Bits
231	- One Stop Bit	231	- One Stop Bit
232	- No parity	232	- No parity
233	- BaudRate = 57600 baud	233	- BaudRate = 57600 baud
234	- Hardware flow control Disabled	234	- Hardware flow control Disabled
235	- Receive and transmit enabled	235	- Receive and transmit enabled
236	- Receive and transmit FIFOs are Disabled	236	- Receive and transmit FIFOs are Disabled
237	*/	237	*/
238	UART_StructInit(&UART_InitStructure);	238	UART_StructInit(&UART_InitStructure);
239	UART_InitStructure.UART_WordLength = UART_WordLength_8D;	239	UART_InitStructure.UART_WordLength = UART_WordLength_8D;
240	UART_InitStructure.UART_StopBits = UART_StopBits_1;	240	UART_InitStructure.UART_StopBits = UART_StopBits_1;
241	UART_InitStructure.UART_Parity = UART_Parity_No ;	241	UART_InitStructure.UART_Parity = UART_Parity_No ;
242	UART_InitStructure.UART_BaudRate = UART1_BAUD_RATE;	242	UART_InitStructure.UART_BaudRate = UART1_BAUD_RATE;
243	UART_InitStructure. UART_HardwareFlowControl = UART_HardwareFlowControl_None;	243	UART_InitStructure. UART_HardwareFlowControl = UART_HardwareFlowControl_None;
244	UART_InitStructure.UART_Mode = UART_Mode_Tx_Rx;	244	UART_InitStructure.UART_Mode = UART_Mode_Tx_Rx;
245	UART_InitStructure.UART_FIFO = UART_FIFO_Enable;	245	UART_InitStructure.UART_FIFO = UART_FIFO_Enable;
246	UART_InitStructure.UART_TxFIFOLevel = UART_FIFOLevel_1_2;	246	UART_InitStructure.UART_TxFIFOLevel = UART_FIFOLevel_1_2;
247	UART_InitStructure.UART_RxFIFOLevel = UART_FIFOLevel_1_2;	247	UART_InitStructure.UART_RxFIFOLevel = UART_FIFOLevel_1_2;
248		248
249	UART_DeInit(UART1); // reset uart 1 to default	249	UART_DeInit(UART1); // reset uart 1 to default
250	UART_Init(UART1, &UART_InitStructure); // initialize uart 1	250	UART_Init(UART1, &UART_InitStructure); // initialize uart 1
251	// enable uart 1 interrupts selective	251	// enable uart 1 interrupts selective
252	UART_ITConfig(UART1, UART_IT_Receive \| UART_IT_ReceiveTimeOut, ENABLE);	252	UART_ITConfig(UART1, UART_IT_Receive \| UART_IT_ReceiveTimeOut, ENABLE);
253	UART_Cmd(UART1, ENABLE); // enable uart 1	253	UART_Cmd(UART1, ENABLE); // enable uart 1
254	// configure the uart 1 interupt line	254	// configure the uart 1 interupt line
255	VIC_Config(UART1_ITLine, VIC_IRQ, PRIORITY_UART1);	255	VIC_Config(UART1_ITLine, VIC_IRQ, PRIORITY_UART1);
256	// enable the uart 1 IRQ	256	// enable the uart 1 IRQ
257	VIC_ITCmd(UART1_ITLine, ENABLE);	257	VIC_ITCmd(UART1_ITLine, ENABLE);
258		258
259	// initialize the debug timer	259	// initialize the debug timer
260	UART1_DebugData_Timer = SetDelay(UART1_DebugData_Interval);	260	UART1_DebugData_Timer = SetDelay(UART1_DebugData_Interval);
261	UART1_NaviData_Timer = SetDelay(UART1_NaviData_Interval)+500;	261	UART1_NaviData_Timer = SetDelay(UART1_NaviData_Interval)+500;
262		262
263	// Fill Version Info Structure	263	// Fill Version Info Structure
264	UART_VersionInfo.SWMajor = VERSION_MAJOR;	264	UART_VersionInfo.SWMajor = VERSION_MAJOR;
265	UART_VersionInfo.SWMinor = VERSION_MINOR;	265	UART_VersionInfo.SWMinor = VERSION_MINOR;
266	UART_VersionInfo.SWPatch = VERSION_PATCH;	266	UART_VersionInfo.SWPatch = VERSION_PATCH;
267	UART_VersionInfo.ProtoMajor = VERSION_SERIAL_MAJOR;	267	UART_VersionInfo.ProtoMajor = VERSION_SERIAL_MAJOR;
268	UART_VersionInfo.ProtoMinor = VERSION_SERIAL_MINOR;	268	UART_VersionInfo.ProtoMinor = VERSION_SERIAL_MINOR;
269		269
270	NaviData.Version = NAVIDATA_VERSION;	270	NaviData.Version = NAVIDATA_VERSION;
271		271
272	UART1_PutString("\r\n UART1 init...ok");	272	UART1_PutString("\r\n UART1 init...ok");
273	}	273	}
274		274
275		275
276	/****************************************************************/	276	/****************************************************************/
277	/* USART1 receiver ISR */	277	/* USART1 receiver ISR */
278	/****************************************************************/	278	/****************************************************************/
279	void UART1_IRQHandler(void)	279	void UART1_IRQHandler(void)
280	{	280	{
281	static u8 abortState = 0;	281	static u8 abortState = 0;
282	u8 c;	282	u8 c;
283		283
284	if((UART_GetITStatus(UART1, UART_IT_Receive) != RESET) \|\| (UART_GetITStatus(UART1, UART_IT_ReceiveTimeOut) != RESET) )	284	if((UART_GetITStatus(UART1, UART_IT_Receive) != RESET) \|\| (UART_GetITStatus(UART1, UART_IT_ReceiveTimeOut) != RESET) )
285	{	285	{
286	// clear the pending bits!	286	// clear the pending bits!
287	UART_ClearITPendingBit(UART1, UART_IT_Receive);	287	UART_ClearITPendingBit(UART1, UART_IT_Receive);
288	UART_ClearITPendingBit(UART1, UART_IT_ReceiveTimeOut);	288	UART_ClearITPendingBit(UART1, UART_IT_ReceiveTimeOut);
289	// if debug UART is not UART1	289	// if debug UART is not UART1
290	if (DebugUART != UART1)	290	if (DebugUART != UART1)
291	{ // forward received data to the debug UART tx buffer	291	{ // forward received data to the debug UART tx buffer
292	while(UART_GetFlagStatus(UART1, UART_FLAG_RxFIFOEmpty) != SET)	292	while(UART_GetFlagStatus(UART1, UART_FLAG_RxFIFOEmpty) != SET)
293	{	293	{
294	// move the byte from the rx buffer of UART1 to the tx buffer of DebugUART	294	// move the byte from the rx buffer of UART1 to the tx buffer of DebugUART
295	c = UART_ReceiveData(UART1);	295	c = UART_ReceiveData(UART1);
296		296
297	// check for abort condition (ESC ESC 0x55 0xAA 0x00)	297	// check for abort condition (ESC ESC 0x55 0xAA 0x00)
298	switch (abortState)	298	switch (abortState)
299	{	299	{
300	case 0:	300	case 0:
301	if (c == 27) abortState++;	301	if (c == 27) abortState++;
302	break;	302	break;
303	case 1:	303	case 1:
304	if (c == 27) abortState++;	304	if (c == 27) abortState++;
305	else abortState = 0;	305	else abortState = 0;
306	break;	306	break;
307	case 2:	307	case 2:
308	if (c == 0x55) abortState++;	308	if (c == 0x55) abortState++;
309	else abortState = 0;	309	else abortState = 0;
310	break;	310	break;
311	case 3:	311	case 3:
312	if (c == 0xAA) abortState++;	312	if (c == 0xAA) abortState++;
313	else abortState = 0;	313	else abortState = 0;
314	break;	314	break;
315	case 4:	315	case 4:
316	if (c == 0x00)	316	if (c == 0x00)
317	{	317	{
318	if(DebugUART == UART0)	318	if(DebugUART == UART0)
319	{	319	{
320	UART0_Connect_to_MKGPS(UART0_BAUD_RATE);	320	UART0_Connect_to_MKGPS(UART0_BAUD_RATE);
321	TIMER2_Init(); // enbable servo outputs	321	TIMER2_Init(); // enbable servo outputs
322	fifo_purge(&UART1_rx_fifo); // flush the whole fifo init buffer	322	fifo_purge(&UART1_rx_fifo); // flush the whole fifo init buffer
323	}	323	}
324	DebugUART = UART1;	324	DebugUART = UART1;
325	}	325	}
326	abortState = 0;	326	abortState = 0;
327	break;	327	break;
328	} // end switch abort state	328	} // end switch abort state
329	// if the Debug uart is not UART1, redirect input to the Debug UART	329	// if the Debug uart is not UART1, redirect input to the Debug UART
330	if (DebugUART != UART1)	330	if (DebugUART != UART1)
331	{	331	{
332	// wait for space in the tx buffer of the DebugUART	332	// wait for space in the tx buffer of the DebugUART
333	while(UART_GetFlagStatus(DebugUART, UART_FLAG_TxFIFOFull) == SET) {};	333	while(UART_GetFlagStatus(DebugUART, UART_FLAG_TxFIFOFull) == SET) {};
334	// move byte to the tx fifo of the debug uart	334	// move byte to the tx fifo of the debug uart
335	UART_SendData(DebugUART, c);	335	UART_SendData(DebugUART, c);
336	}	336	}
337	}	337	}
338	}	338	}
339	else // DebugUART == UART1 (normal operation)	339	else // DebugUART == UART1 (normal operation)
340	{	340	{
341	while(UART_GetFlagStatus(UART1, UART_FLAG_RxFIFOEmpty) != SET)	341	while(UART_GetFlagStatus(UART1, UART_FLAG_RxFIFOEmpty) != SET)
342	{ // some byes in the hardware fifo	342	{ // some byes in the hardware fifo
343	// get byte from hardware fifo	343	// get byte from hardware fifo
344	c = UART_ReceiveData(UART1);	344	c = UART_ReceiveData(UART1);
345	// put into the software fifo	345	// put into the software fifo
346	if(!fifo_put(&UART1_rx_fifo, c))	346	if(!fifo_put(&UART1_rx_fifo, c))
347	{ // fifo overflow	347	{ // fifo overflow
348	//fifo_purge(&UART1_rx_fifo); // flush the whole buffer	348	//fifo_purge(&UART1_rx_fifo); // flush the whole buffer
349	}	349	}
350	} // EOF while some byes in the hardware fifo	350	} // EOF while some byes in the hardware fifo
351	} // eof DebugUart = UART1	351	} // eof DebugUart = UART1
352	}	352	}
353		353
354		354
355		355
356	VIC1->VAR = 0xFF; // write any value to VIC1 Vector address register	356	VIC1->VAR = 0xFF; // write any value to VIC1 Vector address register
357	}	357	}
358		358
359	/**************************************************************/	359	/**************************************************************/
360	/* Process incomming data from debug uart */	360	/* Process incomming data from debug uart */
361	/**************************************************************/	361	/**************************************************************/
362	void UART1_ProcessRxData(void)	362	void UART1_ProcessRxData(void)
363	{	363	{
364	// return on forwarding uart or unlocked rx buffer	364	// return on forwarding uart or unlocked rx buffer
365	u8 c;	365	u8 c;
366	if(DebugUART != UART1) return;	366	if(DebugUART != UART1) return;
367	// if rx buffer is not locked	367	// if rx buffer is not locked
368	if(UART1_rx_buffer.Locked == FALSE)	368	if(UART1_rx_buffer.Locked == FALSE)
369	{	369	{
370	//collect data from primary rx fifo	370	//collect data from primary rx fifo
371	while(fifo_get(&UART1_rx_fifo, &c))	371	while(fifo_get(&UART1_rx_fifo, &c))
372	{	372	{
373	// break if complete frame is collected	373	// break if complete frame is collected
374	if(MKProtocol_CollectSerialFrame(&UART1_rx_buffer, c)) break;	374	if(MKProtocol_CollectSerialFrame(&UART1_rx_buffer, c)) break;
375	}	375	}
376	}	376	}
377	if(UART1_rx_buffer.Locked == FALSE) return;	377	if(UART1_rx_buffer.Locked == FALSE) return;
378		378
379	Point_t * pPoint = NULL;	379	Point_t * pPoint = NULL;
380	SerialMsg_t SerialMsg;	380	SerialMsg_t SerialMsg;
381		381
382	// analyze header first	382	// analyze header first
383	MKProtocol_DecodeSerialFrameHeader(&UART1_rx_buffer, &SerialMsg);	383	MKProtocol_DecodeSerialFrameHeader(&UART1_rx_buffer, &SerialMsg);
384	if( SerialMsg.Address == FC_ADDRESS )	384	if( SerialMsg.Address == FC_ADDRESS )
385	{	385	{
386	switch(SerialMsg.CmdID)	386	switch(SerialMsg.CmdID)
387	{	387	{
388	// case 'v': // version	388	// case 'v': // version
389	case 'b': // extern control	389	case 'b': // extern control
390	UART1_ExternalControlConfirmFrame = 1;	390	UART1_ExternalControlConfirmFrame = 1;
391	case 'y': // serial poti values	391	case 'y': // serial poti values
392	Buffer_Copy(&UART1_rx_buffer, &UART2_tx_buffer); //forward to FC	392	Buffer_Copy(&UART1_rx_buffer, &UART2_tx_buffer); //forward to FC
393	Buffer_Clear(&UART1_rx_buffer); // free rc buffer for next frame	393	Buffer_Clear(&UART1_rx_buffer); // free rc buffer for next frame
394	return; //end process rx data	394	return; //end process rx data
395	break;	395	break;
396	}	396	}
397	}	397	}
398		398
399	MKProtocol_DecodeSerialFrameData(&UART1_rx_buffer, &SerialMsg); // decode serial frame in rxd buffer	399	MKProtocol_DecodeSerialFrameData(&UART1_rx_buffer, &SerialMsg); // decode serial frame in rxd buffer
400	if(SerialMsg.CmdID != 'z') SerialLinkOkay = 250; // reset SerialTimeout, but not in case of the "ping"	400	if(SerialMsg.CmdID != 'z') SerialLinkOkay = 250; // reset SerialTimeout, but not in case of the "ping"
401	switch(SerialMsg.Address) // check for Slave Address	401	switch(SerialMsg.Address) // check for Slave Address
402	{	402	{
403	case NC_ADDRESS: // own Slave Address	403	case NC_ADDRESS: // own Slave Address
404	switch(SerialMsg.CmdID)	404	switch(SerialMsg.CmdID)
405	{	405	{
406		406
407	case 'f': // ftp command	407	case 'f': // ftp command
408	UART1_Request_FTP = SerialMsg.pData[0];	408	UART1_Request_FTP = SerialMsg.pData[0];
409		409
410	//if (UART1_Request_FTP == FTP_CMD_SET_CWD \|\| UART1_Request_FTP == FTP_CMD_GET_FILE)	410	//if (UART1_Request_FTP == FTP_CMD_SET_CWD \|\| UART1_Request_FTP == FTP_CMD_GET_FILE)
411	memcpy(&FTP_data, &SerialMsg.pData[1], sizeof(FTP_data)); // copy ftp parameter	411	memcpy(&FTP_data, &SerialMsg.pData[1], sizeof(FTP_data)); // copy ftp parameter
412	break;	412	break;
413		413
414	case 'z': // connection checker	414	case 'z': // connection checker
415	memcpy(&Echo, SerialMsg.pData, sizeof(Echo)); // copy echo pattern	415	memcpy(&Echo, SerialMsg.pData, sizeof(Echo)); // copy echo pattern
416	UART1_Request_Echo = TRUE;	416	UART1_Request_Echo = TRUE;
417	break;	417	break;
418		418
419	case 'e': // request for the text of the error status	419	case 'e': // request for the text of the error status
420	UART1_Request_ErrorMessage = TRUE;	420	UART1_Request_ErrorMessage = TRUE;
421	break;	421	break;
422		422
423	case 's':// new target position	423	case 's':// new target position
424	pPoint = (Point_t*)SerialMsg.pData;	424	pPoint = (Point_t*)SerialMsg.pData;
425	if(pPoint->Position.Status == NEWDATA)	425	if(pPoint->Position.Status == NEWDATA)
426	{	426	{
427	//if(!(FC.StatusFlags & FC_STATUS_FLY)) PointList_Clear(); // flush the list	427	//if(!(FC.StatusFlags & FC_STATUS_FLY)) PointList_Clear(); // flush the list
428	//pPoint->Index = 1; // must be one after empty list	428	//pPoint->Index = 1; // must be one after empty list
429	PointList_SetAt(pPoint);	429	PointList_SetAt(pPoint);
430	if(FC.StatusFlags & FC_STATUS_FLY) PointList_WPActive(TRUE);	430	if(FC.StatusFlags & FC_STATUS_FLY) PointList_WPActive(TRUE);
431	GPS_pWaypoint = PointList_WPBegin(); // updates POI index	431	GPS_pWaypoint = PointList_WPBegin(); // updates POI index
432	if(GPS_pWaypoint != NULL) // if new WP exist	432	if(GPS_pWaypoint != NULL) // if new WP exist
433	{ // update WP hold time stamp immediately!	433	{ // update WP hold time stamp immediately!
434	/* if(GPS_pWaypoint->Heading > 0 && GPS_pWaypoint->Heading <= 360)	434	/* if(GPS_pWaypoint->Heading > 0 && GPS_pWaypoint->Heading <= 360)
435	{	435	{
436	CAM_Orientation.Azimuth = GPS_pWaypoint->Heading;	436	CAM_Orientation.Azimuth = GPS_pWaypoint->Heading;
437	CAM_Orientation.UpdateMask \|= CAM_UPDATE_AZIMUTH;	437	CAM_Orientation.UpdateMask \|= CAM_UPDATE_AZIMUTH;
438	}	438	}
439	*/	439	*/
440	}	440	}
441	BeepTime = 50;	441	BeepTime = 50;
442	}	442	}
443	break;	443	break;
444		444
445	case 'u': // redirect debug uart	445	case 'u': // redirect debug uart
446	switch(SerialMsg.pData[0])	446	switch(SerialMsg.pData[0])
447	{	447	{
448	case UART_FLIGHTCTRL:	448	case UART_FLIGHTCTRL:
449	UART2_Init(); // initialize UART2 to FC pins	449	UART2_Init(); // initialize UART2 to FC pins
450	fifo_purge(&UART1_rx_fifo);	450	fifo_purge(&UART1_rx_fifo);
451	TIMER2_Deinit(); // reduce irq load	451	TIMER2_Deinit(); // reduce irq load
452	DebugUART = UART2;	452	DebugUART = UART2;
453	break;	453	break;
454	case UART_MK3MAG:	454	case UART_MK3MAG:
455	if(FC.StatusFlags & FC_STATUS_MOTOR_RUN) break; // not if the motors are running	455	if(FC.StatusFlags & FC_STATUS_MOTOR_RUN) break; // not if the motors are running
456	UART0_Connect_to_MK3MAG(); // mux UART0 to MK3MAG pins	456	UART0_Connect_to_MK3MAG(); // mux UART0 to MK3MAG pins
457	GPSData.Status = INVALID;	457	GPSData.Status = INVALID;
458	fifo_purge(&UART1_rx_fifo);	458	fifo_purge(&UART1_rx_fifo);
459	DebugUART = UART0;	459	DebugUART = UART0;
460	break;	460	break;
461	case UART_MKGPS:	461	case UART_MKGPS:
462	if(FC.StatusFlags & FC_STATUS_MOTOR_RUN) break; // not if the motors are running	462	if(FC.StatusFlags & FC_STATUS_MOTOR_RUN) break; // not if the motors are running
463	TIMER2_Deinit(); // disable servo outputs to reduce irq load	463	TIMER2_Deinit(); // disable servo outputs to reduce irq load
464	UART0_Connect_to_MKGPS(UART0_BAUD_RATE); // connect UART0 to MKGPS pins	464	UART0_Connect_to_MKGPS(UART0_BAUD_RATE); // connect UART0 to MKGPS pins
465	GPSData.Status = INVALID;	465	GPSData.Status = INVALID;
466	fifo_purge(&UART1_rx_fifo);	466	fifo_purge(&UART1_rx_fifo);
467	DebugUART = UART0;	467	DebugUART = UART0;
468	break;	468	break;
469	default:	469	default:
470	break;	470	break;
471	}	471	}
472	break;	472	break;
473		473
474	case 'w':// Set point in list at index	474	case 'w':// Set point in list at index
475	{	475	{
476	pPoint = (Point_t*)SerialMsg.pData;	476	pPoint = (Point_t*)SerialMsg.pData;
477		477
478	if((pPoint->Position.Status == INVALID) && (pPoint->Index == 0))	478	if((pPoint->Position.Status == INVALID) && (pPoint->Index == 0))
479	{	479	{
480	PointList_Clear();	480	PointList_Clear();
481	GPS_pWaypoint = PointList_WPBegin();	481	GPS_pWaypoint = PointList_WPBegin();
482	UART1_Request_WritePoint = 0; // return new point count	482	UART1_Request_WritePoint = 0; // return new point count
483	}	483	}
484	else	484	else
485	{ // update WP in list at index	485	{ // update WP in list at index
486	if(pPoint->Index > MaxNumberOfWaypoints)	486	if(pPoint->Index > MaxNumberOfWaypoints)
487	{	487	{
488	UART1_Request_WritePoint = 254;	488	UART1_Request_WritePoint = 254;
489	pPoint->Index = MaxNumberOfWaypoints;	489	pPoint->Index = MaxNumberOfWaypoints;
490	}	490	}
491	else	491	else
492	UART1_Request_WritePoint = PointList_SetAt(pPoint);	492	UART1_Request_WritePoint = PointList_SetAt(pPoint);
493	if(FC.StatusFlags & FC_STATUS_FLY) PointList_WPActive(TRUE);	493	if(FC.StatusFlags & FC_STATUS_FLY) PointList_WPActive(TRUE);
494	if(UART1_Request_WritePoint == pPoint->Index)	494	if(UART1_Request_WritePoint == pPoint->Index)
495	{	495	{
496	BeepTime = 500;	496	BeepTime = 500;
497	}	497	}
498	}	498	}
499	}	499	}
500	break;	500	break;

Subversion Repositories NaviCtrl

(root)/tags/V2.07b_Beta/uart1.c @ 622 - Rev 398 → 403