WebSVN - NaviCtrl - Diff - Rev 151 and 153


/*#######################################################################################*/
/* !!! THIS IS NOT FREE SOFTWARE !!!                                                     */
/*#######################################################################################*/
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// + Copyright (c) 2008 Ingo Busker, Holger Buss
// + Nur für den privaten Gebrauch
// + FOR NON COMMERCIAL USE ONLY
// + www.MikroKopter.com
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// + Es gilt für das gesamte Projekt (Hardware, Software, Binärfiles, Sourcecode und Dokumentation),
// + dass eine Nutzung (auch auszugsweise) nur für den privaten (nicht-kommerziellen) Gebrauch zulässig ist.
// + Sollten direkte oder indirekte kommerzielle Absichten verfolgt werden, ist mit uns (info@mikrokopter.de) Kontakt
// + bzgl. der Nutzungsbedingungen aufzunehmen.
// + Eine kommerzielle Nutzung ist z.B.Verkauf von MikroKoptern, Bestückung und Verkauf von Platinen oder Bausätzen,
// + Verkauf von Luftbildaufnahmen, usw.
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// + Werden Teile des Quellcodes (mit oder ohne Modifikation) weiterverwendet oder veröffentlicht,
// + unterliegen sie auch diesen Nutzungsbedingungen und diese Nutzungsbedingungen incl. Copyright müssen dann beiliegen
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// + Sollte die Software (auch auszugesweise) oder sonstige Informationen des MikroKopter-Projekts
// + auf anderen Webseiten oder sonstigen Medien veröffentlicht werden, muss unsere Webseite "http://www.mikrokopter.de"
// + eindeutig als Ursprung verlinkt werden
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// + Keine Gewähr auf Fehlerfreiheit, Vollständigkeit oder Funktion
// + Benutzung auf eigene Gefahr
// + Wir übernehmen keinerlei Haftung für direkte oder indirekte Personen- oder Sachschäden
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// + Die PORTIERUNG der Software (oder Teile davon) auf andere Systeme (ausser der Hardware von www.mikrokopter.de) ist nur
// + mit unserer Zustimmung zulässig
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// + Die Funktion printf_P() unterliegt ihrer eigenen Lizenz und ist hiervon nicht betroffen
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// + Redistributions of source code (with or without modifications) must retain the above copyright notice,
// + this list of conditions and the following disclaimer.
// +   * Neither the name of the copyright holders nor the names of contributors may be used to endorse or promote products derived
// +     from this software without specific prior written permission.
// +   * The use of this project (hardware, software, binary files, sources and documentation) is only permitted
// +     for non-commercial use (directly or indirectly)
// +     Commercial use (for excample: selling of MikroKopters, selling of PCBs, assembly, ...) is only permitted
// +     with our written permission
// +   * If sources or documentations are redistributet on other webpages, out webpage (http://www.MikroKopter.de) must be
// +     clearly linked as origin
// +   * PORTING this software (or part of it) to systems (other than hardware from www.mikrokopter.de) is NOT allowed
//
// +  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// +  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// +  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// +  ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
// +  LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
// +  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
// +  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
// +  INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
// +  CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
// +  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
// +  POSSIBILITY OF SUCH DAMAGE.
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
#include <stdio.h>
#include <stdarg.h>
#include <string.h>
 
#include "91x_lib.h"
#include "config.h"
#include "menu.h"
#include "printf_P.h"
#include "GPS.h"
#include "i2c.h"
#include "uart0.h"
#include "uart1.h"
#include "uart2.h"
#include "timer1.h"
#include "timer2.h"
#include "analog.h"
#include "main.h"
#include "waypoints.h"
#include "mkprotocol.h"
#include "fifo.h"
 
#define FALSE   0
#define TRUE    1
 
 
u8 UART1_Request_VersionInfo    = FALSE;
u8 UART1_Request_SendFollowMe   = FALSE;
u8 UART1_Request_ExternalControl= FALSE;
u8 UART1_Request_Display                = FALSE;
u8 UART1_Request_Display1               = FALSE;
u8 UART1_Request_DebugData              = FALSE;
u8 UART1_Request_DebugLabel             = 255;
u8 UART1_Request_NaviData               = FALSE;
u8 UART1_Request_ErrorMessage   = FALSE;
u8 UART1_Request_NewWaypoint    = FALSE;
u8 UART1_Request_ReadWaypoint   = 255;
u8 UART1_Request_Data3D             = FALSE;
u8 UART1_Request_Echo               = FALSE;
u8 UART1_DisplayLine                    = 0;
u8 UART1_ConfirmFrame                   = 0;
 
UART_TypeDef *DebugUART = UART1;
 
// the primary rx fifo
#define UART1_RX_FIFO_LEN 512
u8 UART1_rxfifobuffer[UART1_RX_FIFO_LEN];
fifo_t UART1_rx_fifo;
 
// the rx buffer
#define UART1_RX_BUFFER_LEN  150
u8 UART1_rbuffer[UART1_RX_BUFFER_LEN];
Buffer_t UART1_rx_buffer;
 
// the tx buffer
#define UART1_TX_BUFFER_LEN  150
u8 UART1_tbuffer[UART1_TX_BUFFER_LEN];
Buffer_t UART1_tx_buffer;
 
 
 
volatile u8 SerialLinkOkay = 0;
 
u8 text[200];
 
const u8 ANALOG_LABEL[32][16] =
{
   //1234567890123456
        "AngleNick       ", //0
        "AngleRoll       ",
        "AccNick         ",
        "AccRoll         ",
        "                ",
        "MK-Flags        ", //5
        "NC-Flags        ",
        "NickServo       ",
        "RollServo       ",
        "GPS Data        ",
        "CompassHeading  ", //10
        "GyroHeading     ",
        "SPI Error       ",
        "SPI Okay        ",
        "I2C Error       ",
        "I2C Okay        ", //15
        "                ",//    "Kalman_K        ",
        "ACC_Speed_N     ",
        "ACC_Speed_E     ",
        "Speed_z         ",//    "GPS ACC         ",
        "                ",//    "MAXDrift        ", //20
        "N_Speed         ",
        "E_Speed         ",
        "P-Part          ",
        "I-Part          ",
        "D-Part          ",//25
        "PID-Part        ",
        "Distance N      ",
        "Distance E      ",
        "GPS_Nick        ",
        "GPS_Roll        ", //30
        "Used_Sats       "
};
 
DebugOut_t DebugOut;
ExternControl_t ExternControl;
UART_VersionInfo_t UART_VersionInfo;
NaviData_t NaviData;
Waypoint_t FollowMe;
Data3D_t Data3D;
u16 Echo; // 2 bytes recieved will be sent back as echo
 
u32 UART1_DebugData_Timer;
u32 UART1_DebugData_Interval = 5000;    // in ms
u32 UART1_NaviData_Timer;
u32 UART1_NaviData_Interval = 5000;     // in ms
u32 UART1_Data3D_Timer = 0;                     // in ms
u32 UART1_Data3D_Interval = 0;
 
/********************************************************/
/*            Initialization the UART1                  */
/********************************************************/
void UART1_Init (void)
{
        GPIO_InitTypeDef GPIO_InitStructure;
        UART_InitTypeDef UART_InitStructure;
 
        // initialize txd buffer
        Buffer_Init(&UART1_tx_buffer, UART1_tbuffer, UART1_TX_BUFFER_LEN);
       
        // initialize rxd buffer
        Buffer_Init(&UART1_rx_buffer, UART1_rbuffer, UART1_RX_BUFFER_LEN);
 
        // initialize the rx fifo
        fifo_init(&UART1_rx_fifo, UART1_rxfifobuffer, UART1_RX_FIFO_LEN);
 
        SCU_APBPeriphClockConfig(__UART1, ENABLE);  // Enable the UART1 Clock
        SCU_APBPeriphClockConfig(__GPIO3, ENABLE);  // Enable the GPIO3 Clock
 
        /*Configure UART1_Rx pin GPIO3.2*/
        GPIO_StructInit(&GPIO_InitStructure);
        GPIO_InitStructure.GPIO_Direction =     GPIO_PinInput;
        GPIO_InitStructure.GPIO_Pin =                   GPIO_Pin_2;
        GPIO_InitStructure.GPIO_Type =                  GPIO_Type_PushPull;
        GPIO_InitStructure.GPIO_IPConnected =   GPIO_IPConnected_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\nUART1 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();
                                                                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 fifo and rxd buffer not locked
                            // 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
                                }
                        } // some byes in the fifo and rxd buffer not locked
                } // eof DebugUart = UART1
        }
}
 
/**************************************************************/
/* Process incomming data from debug uart                     */
/**************************************************************/
void UART1_ProcessRxData(void)
{
        u8 c;
 
        // return on forwarding uart
        if(DebugUART != UART1) return;
       
        // 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 data in the rxd buffer are not locked immediately return
        if(UART1_rx_buffer.Locked == FALSE) return;
       
        Waypoint_t * pWaypoint = NULL;
        SerialMsg_t SerialMsg;
 
        MKProtocol_DecodeSerialFrame(&UART1_rx_buffer, &SerialMsg); // decode serial frame in rxd buffer
    if(*(SerialMsg.pCmdID) != 'z') SerialLinkOkay = 250;          // reset SerialTimeout, but not in case of the "ping"
        switch(*(SerialMsg.pAddress)) // check for Slave Address
        {
                case NC_ADDRESS:  // own Slave Address
                switch(*(SerialMsg.pCmdID))
                {
                        case 'z': // connection checker
                                memcpy(&Echo, SerialMsg.pData, sizeof(Echo)); // copy echo pattern
                                UART1_Request_Echo = TRUE;
                                break;
 
                        case 'e': // request for the text of the error status
                                UART1_Request_ErrorMessage = TRUE;
                                break;
 
                        case 's'://  new target position
                                pWaypoint = (Waypoint_t*)SerialMsg.pData;
                                BeepTime = 300;
                                if(pWaypoint->Position.Status == NEWDATA)
                                {
                                        WPList_Clear(); // empty WPList
                                        WPList_Append(pWaypoint);
                                        GPS_pWaypoint = WPList_Begin();
                                }
                                break;
 
                        case 'u': // redirect debug uart
                                switch(SerialMsg.pData[0])
                                {
                                        case UART_FLIGHTCTRL:
                                                UART2_Init();                           // initialize UART2 to FC pins
                                                fifo_purge(&UART1_rx_fifo);
                                                DebugUART = UART2;
                                                break;
                                        case UART_MK3MAG:
                                                if(FC.MKFlags & MKFLAG_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.MKFlags & MKFLAG_MOTOR_RUN) break; // not if the motors are running
                                                TIMER2_Deinit();
                                                UART0_Connect_to_MKGPS();       // connect UART0 to MKGPS pins
                                                GPSData.Status = INVALID;
                                                fifo_purge(&UART1_rx_fifo);
                                                DebugUART = UART0;
                                                break;
                                        default:
                                                break;
                                }
                                break;
 
                        case 'w'://  Append Waypoint to List
                                pWaypoint = (Waypoint_t*)SerialMsg.pData;
                                if(pWaypoint->Position.Status == INVALID)
                                {  // clear WP List
                                        WPList_Clear();
                                        GPS_pWaypoint = WPList_Begin();
                                        //UART1_PutString("\r\nClear WP List\r\n");
                                }
                                else if (pWaypoint->Position.Status == NEWDATA)
                                {  // app current WP to the list
                                        WPList_Append(pWaypoint);
                                        BeepTime = 500;
                                        //UART1_PutString("\r\nAdd WP to List\r\n");
                                }
                                UART1_Request_NewWaypoint = TRUE;
                                break;
 
                        case 'x'://  Read Waypoint from List
                                UART1_Request_ReadWaypoint = SerialMsg.pData[0];
                                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.pCmdID)) // 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;
                                break;
 
                        case 'c': // request for 3D data;
                                UART1_Data3D_Interval = (u32) SerialMsg.pData[0] * 10;
                                if(UART1_Data3D_Interval > 0) UART1_Request_Data3D = TRUE;
                                break;
 
                        case 'g':// request for external control data
                                UART1_Request_ExternalControl = TRUE;
                                break;
 
                        case 'h':// reqest for display line
                                RemoteKeys |= SerialMsg.pData[0];
                                if(RemoteKeys != 0) UART1_DisplayLine = 0;
                                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;
                                break;
 
                        case 'v': // request for version info
                                UART1_Request_VersionInfo = TRUE;
                                break;
                        default:
                                // unsupported command recieved
                                break;
                }
                break; // default:
        }
        Buffer_Clear(&UART1_rx_buffer); // free rc buffer for next frame
}
 
 
/*****************************************************/
/*                   Send a character                */
/*****************************************************/
s16 UART1_Putchar(char c)
{
        if (c == '\n') UART1_Putchar('\r');
        // wait until txd fifo is not full
        while (UART_GetFlagStatus(UART1, UART_FLAG_TxFIFOFull) != RESET);
        // transmit byte
        UART_SendData(UART1, c);
        return (0);
}
 
/*****************************************************/
/*       Send a string to the debug uart              */
/*****************************************************/
void UART1_PutString(u8 *s)
{
        if(s == NULL) return;
        while (*s != '\0' && DebugUART == UART1)
        {
                UART1_Putchar(*s);
                s ++;
        }
}
 
 
/**************************************************************/
/*         Transmit tx buffer via debug uart                  */
/**************************************************************/
void UART1_Transmit(void)
{
        u8 tmp_tx;
        if(DebugUART != UART1) return;
        // if something has to be send and the txd fifo is not full
        if(UART1_tx_buffer.Locked == TRUE)
        {
                // while there is some space in the tx fifo
                while(UART_GetFlagStatus(UART1, UART_FLAG_TxFIFOFull) != SET)
                {
                        tmp_tx = UART1_tx_buffer.pData[UART1_tx_buffer.Position++]; // read next byte from txd buffer
                        UART_SendData(UART1, tmp_tx); // put character to txd fifo
                        // if terminating character or end of txd buffer reached
                        if((tmp_tx == '\r') || (UART1_tx_buffer.Position == UART1_tx_buffer.DataBytes))
                        {
                                Buffer_Clear(&UART1_tx_buffer); // clear txd buffer
                                break; // end while loop
                        }
                }
        }
}
 
/**************************************************************/
/* Send the answers to incomming commands at the debug uart   */
/**************************************************************/
void UART1_TransmitTxData(void)
{
        if(DebugUART != UART1) return;
        UART1_Transmit(); // output pending bytes in tx buffer
        if((UART1_tx_buffer.Locked == TRUE)) return;
 
        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_NaviData_Interval > 0) && CheckDelay(UART1_NaviData_Timer) ) || UART1_Request_NaviData) && (UART1_tx_buffer.Locked == FALSE))
        {
                NaviData.Errorcode = ErrorCode;
                MKProtocol_CreateSerialFrame(&UART1_tx_buffer, 'O', NC_ADDRESS,1, (u8 *)&NaviData, sizeof(NaviData));
                UART1_NaviData_Timer = SetDelay(UART1_NaviData_Interval);
                UART1_Request_NaviData = FALSE;
        }
        else if( (( (UART1_DebugData_Interval > 0) && CheckDelay(UART1_DebugData_Timer)) || UART1_Request_DebugData) && (UART1_tx_buffer.Locked == FALSE))
        {
                MKProtocol_CreateSerialFrame(&UART1_tx_buffer, 'D', NC_ADDRESS, 1,(u8 *)&DebugOut, sizeof(DebugOut));
                UART1_DebugData_Timer = SetDelay(UART1_DebugData_Interval);
                UART1_Request_DebugData = FALSE;
        }
        else if((( (UART1_Data3D_Interval > 0) && CheckDelay(UART1_Data3D_Timer) ) || UART1_Request_Data3D) && (UART1_tx_buffer.Locked == FALSE))
        {
                MKProtocol_CreateSerialFrame(&UART1_tx_buffer, 'C', NC_ADDRESS, 1,(u8 *)&Data3D, sizeof(Data3D));
                UART1_Data3D_Timer = SetDelay(UART1_Data3D_Interval);
                UART1_Request_Data3D = FALSE;
        }
        else if((UART1_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_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_Request_Display && (UART1_tx_buffer.Locked == FALSE))
        {
                LCD_PrintMenu();
                MKProtocol_CreateSerialFrame(&UART1_tx_buffer, 'H', NC_ADDRESS, 2, &UART1_DisplayLine, sizeof(UART1_DisplayLine), (u8*)&DisplayBuff[UART1_DisplayLine * 20], 20);
                UART1_DisplayLine++;
                if(UART1_DisplayLine >= 4) UART1_DisplayLine = 0;
                UART1_Request_Display = FALSE;
        }
        else if(UART1_Request_Display1 && (UART1_tx_buffer.Locked == FALSE))
        {
                LCD_PrintMenu();
                MKProtocol_CreateSerialFrame(&UART1_tx_buffer, 'L', NC_ADDRESS, 3, (u8*)&MenuItem, sizeof(MenuItem), (u8*)&MaxMenuItem, sizeof(MaxMenuItem),(u8*)DisplayBuff, sizeof(DisplayBuff));
                UART1_Request_Display1 = FALSE;
        }
        else if(UART1_Request_VersionInfo && (UART1_tx_buffer.Locked == FALSE))
        {
                MKProtocol_CreateSerialFrame(&UART1_tx_buffer, 'V', NC_ADDRESS,1, (u8 *)&UART_VersionInfo, sizeof(UART_VersionInfo));
                UART1_Request_VersionInfo = FALSE;
        }
        else if(UART1_Request_ErrorMessage && (UART1_tx_buffer.Locked == FALSE))
        {
                MKProtocol_CreateSerialFrame(&UART1_tx_buffer, 'E', NC_ADDRESS, 1, (u8 *)&ErrorMSG, sizeof(ErrorMSG));
                UART1_Request_ErrorMessage = FALSE;
        }
        else if(UART1_Request_SendFollowMe && (UART1_tx_buffer.Locked == FALSE) && (GPSData.NumOfSats >= 4))              // sending for "Follow me"
        {
                GPS_CopyPosition(&(GPSData.Position),&(FollowMe.Position));
                FollowMe.Position.Status = NEWDATA;
                FollowMe.Heading = -1;
                FollowMe.ToleranceRadius = 1;
                FollowMe.HoldTime = 60;
                FollowMe.Event_Flag = 0;
                FollowMe.reserve[0] = 0;                // reserve
                FollowMe.reserve[1] = 0;                // reserve
                FollowMe.reserve[2] = 0;                // reserve
                FollowMe.reserve[3] = 0;                // reserve
                MKProtocol_CreateSerialFrame(&UART1_tx_buffer, 's', NC_ADDRESS, 1, (u8 *)&FollowMe, sizeof(FollowMe));
                UART1_Request_SendFollowMe = FALSE;
        }
        else if(UART1_Request_NewWaypoint && (UART1_tx_buffer.Locked == FALSE))
        {
                u8 WPNumber = WPList_GetCount();
                MKProtocol_CreateSerialFrame(&UART1_tx_buffer, 'W', NC_ADDRESS, 1, &WPNumber, sizeof(WPNumber));
                UART1_Request_NewWaypoint = FALSE;
        }
        else if((UART1_Request_ReadWaypoint != 0xFF) && (UART1_tx_buffer.Locked == FALSE))
        {
                u8 WPNumber = WPList_GetCount();
                if (UART1_Request_ReadWaypoint < WPNumber)
                {
                        MKProtocol_CreateSerialFrame(&UART1_tx_buffer, 'X', NC_ADDRESS, 3, &WPNumber, 1, &UART1_Request_ReadWaypoint, 1, WPList_GetAt(UART1_Request_ReadWaypoint), sizeof(Waypoint_t));
                }
                else
                {
                        MKProtocol_CreateSerialFrame(&UART1_tx_buffer,'X', NC_ADDRESS, 1, &WPNumber, sizeof(WPNumber));
                }
                UART1_Request_ReadWaypoint = 0xFF;
        }
        UART1_Transmit(); // output pending bytes in tx buffer
}
 
 

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

Subversion Repositories NaviCtrl

(root)/tags/V0.28h/uart1.c @ 655 - Rev 151 → 153