Subversion Repositories NaviCtrl

Rev

Rev 196 | Rev 199 | Go to most recent revision | Only display areas with differences | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed

Rev 196 Rev 198
1 
/*#######################################################################################*/
 1 
/*#######################################################################################*/
2 
/* !!! THIS IS NOT FREE SOFTWARE !!!                                                     */
 2 
/* !!! THIS IS NOT FREE SOFTWARE !!!                                                     */
3 
/*#######################################################################################*/
 3 
/*#######################################################################################*/
4 
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 4 
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
5 
// + Copyright (c) 2008 Ingo Busker, Holger Buss
 5 
// + Copyright (c) 2008 Ingo Busker, Holger Buss
6 
// + Nur für den privaten Gebrauch / NON-COMMERCIAL USE ONLY
 6 
// + Nur für den privaten Gebrauch / NON-COMMERCIAL USE ONLY
7 
// + FOR NON COMMERCIAL USE ONLY
 7 
// + FOR NON COMMERCIAL USE ONLY
8 
// + www.MikroKopter.com
 8 
// + www.MikroKopter.com
9 
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 9 
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
10 
// + Es gilt für das gesamte Projekt (Hardware, Software, Binärfiles, Sourcecode und Dokumentation),
 10 
// + Es gilt für das gesamte Projekt (Hardware, Software, Binärfiles, Sourcecode und Dokumentation),
11 
// + dass eine Nutzung (auch auszugsweise) nur für den privaten (nicht-kommerziellen) Gebrauch zulässig ist.
 11 
// + dass eine Nutzung (auch auszugsweise) nur für den privaten (nicht-kommerziellen) Gebrauch zulässig ist.
12 
// + Sollten direkte oder indirekte kommerzielle Absichten verfolgt werden, ist mit uns (info@mikrokopter.de) Kontakt
 12 
// + Sollten direkte oder indirekte kommerzielle Absichten verfolgt werden, ist mit uns (info@mikrokopter.de) Kontakt
13 
// + bzgl. der Nutzungsbedingungen aufzunehmen.
 13 
// + bzgl. der Nutzungsbedingungen aufzunehmen.
14 
// + Eine kommerzielle Nutzung ist z.B.Verkauf von MikroKoptern, Bestückung und Verkauf von Platinen oder Bausätzen,
 14 
// + Eine kommerzielle Nutzung ist z.B.Verkauf von MikroKoptern, Bestückung und Verkauf von Platinen oder Bausätzen,
15 
// + Verkauf von Luftbildaufnahmen, usw.
 15 
// + Verkauf von Luftbildaufnahmen, usw.
16 
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 16 
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
17 
// + Werden Teile des Quellcodes (mit oder ohne Modifikation) weiterverwendet oder veröffentlicht,
 17 
// + Werden Teile des Quellcodes (mit oder ohne Modifikation) weiterverwendet oder veröffentlicht,
18 
// + unterliegen sie auch diesen Nutzungsbedingungen und diese Nutzungsbedingungen incl. Copyright müssen dann beiliegen
 18 
// + unterliegen sie auch diesen Nutzungsbedingungen und diese Nutzungsbedingungen incl. Copyright müssen dann beiliegen
19 
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 19 
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
20 
// + Sollte die Software (auch auszugesweise) oder sonstige Informationen des MikroKopter-Projekts
 20 
// + Sollte die Software (auch auszugesweise) oder sonstige Informationen des MikroKopter-Projekts
21 
// + auf anderen Webseiten oder sonstigen Medien veröffentlicht werden, muss unsere Webseite "http://www.mikrokopter.de"
 21 
// + auf anderen Webseiten oder sonstigen Medien veröffentlicht werden, muss unsere Webseite "http://www.mikrokopter.de"
22 
// + eindeutig als Ursprung verlinkt werden
 22 
// + eindeutig als Ursprung verlinkt werden
23 
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 23 
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
24 
// + Keine Gewähr auf Fehlerfreiheit, Vollständigkeit oder Funktion
 24 
// + Keine Gewähr auf Fehlerfreiheit, Vollständigkeit oder Funktion
25 
// + Benutzung auf eigene Gefahr
 25 
// + Benutzung auf eigene Gefahr
26 
// + Wir übernehmen keinerlei Haftung für direkte oder indirekte Personen- oder Sachschäden
 26 
// + Wir übernehmen keinerlei Haftung für direkte oder indirekte Personen- oder Sachschäden
27 
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 27 
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
28 
// + Die Portierung oder Nutzung der Software (oder Teile davon) auf andere Systeme (ausser der Hardware von www.mikrokopter.de) ist nur
 28 
// + Die Portierung oder Nutzung der Software (oder Teile davon) auf andere Systeme (ausser der Hardware von www.mikrokopter.de) ist nur
29 
// + mit unserer Zustimmung zulässig
 29 
// + mit unserer Zustimmung zulässig
30 
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 30 
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
31 
// + Die Funktion printf_P() unterliegt ihrer eigenen Lizenz und ist hiervon nicht betroffen
 31 
// + Die Funktion printf_P() unterliegt ihrer eigenen Lizenz und ist hiervon nicht betroffen
32 
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 32 
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
33 
// + Redistributions of source code (with or without modifications) must retain the above copyright notice,
 33 
// + Redistributions of source code (with or without modifications) must retain the above copyright notice,
34 
// + this list of conditions and the following disclaimer.
 34 
// + this list of conditions and the following disclaimer.
35 
// +   * Neither the name of the copyright holders nor the names of contributors may be used to endorse or promote products derived
 35 
// +   * Neither the name of the copyright holders nor the names of contributors may be used to endorse or promote products derived
36 
// +     from this software without specific prior written permission.
 36 
// +     from this software without specific prior written permission.
37 
// +   * The use of this project (hardware, software, binary files, sources and documentation) is only permitted
 37 
// +   * The use of this project (hardware, software, binary files, sources and documentation) is only permitted
38 
// +     for non-commercial use (directly or indirectly)
 38 
// +     for non-commercial use (directly or indirectly)
39 
// +     Commercial use (for excample: selling of MikroKopters, selling of PCBs, assembly, ...) is only permitted
 39 
// +     Commercial use (for excample: selling of MikroKopters, selling of PCBs, assembly, ...) is only permitted
40 
// +     with our written permission
 40 
// +     with our written permission
41 
// +   * If sources or documentations are redistributet on other webpages, out webpage (http://www.MikroKopter.de) must be
 41 
// +   * If sources or documentations are redistributet on other webpages, out webpage (http://www.MikroKopter.de) must be
42 
// +     clearly linked as origin
 42 
// +     clearly linked as origin
43 
// +   * porting the sources to other systems or using the software on other systems (except hardware from www.mikrokopter.de) is not allowed
 43 
// +   * porting the sources to other systems or using the software on other systems (except hardware from www.mikrokopter.de) is not allowed
44 
//
 44 
//
45 
// +  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 45 
// +  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
46 
// +  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 46 
// +  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
47 
// +  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 47 
// +  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
48 
// +  ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
 48 
// +  ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
49 
// +  LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 49 
// +  LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
50 
// +  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 50 
// +  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
51 
// +  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 51 
// +  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
52 
// +  INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 52 
// +  INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
53 
// +  CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 53 
// +  CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
54 
// +  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 54 
// +  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
55 
// +  POSSIBILITY OF SUCH DAMAGE.
 55 
// +  POSSIBILITY OF SUCH DAMAGE.
56 
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 56 
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
57 
#include <stdio.h>
 57 
#include <stdio.h>
58 
#include <stdarg.h>
 58 
#include <stdarg.h>
59 
#include <string.h>
 59 
#include <string.h>
60 
 
 60 
 
61 
#include "91x_lib.h"
 61 
#include "91x_lib.h"
62 
#include "config.h"
 62 
#include "config.h"
63 
#include "menu.h"
 63 
#include "menu.h"
64 
#include "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 "params.h"
 76 
#include "params.h"
77 
#include "fifo.h"
 77 
#include "fifo.h"
78 
 
 78 
 
79 
#define FALSE   0
 79 
#define FALSE   0
80 
#define TRUE    1
 80 
#define TRUE    1
- 
 
 81 
 
- 
 
 82 
#define ABO_TIMEOUT 4000 // disable abo after 4 seconds
81 
 
 83 
u32 UART1_AboTimeOut = 0;
82 
 
 84 
 
83 
u8 UART1_Request_VersionInfo    = FALSE;
 85 
u8 UART1_Request_VersionInfo    = FALSE;
84 
u8 UART1_Request_SendFollowMe   = FALSE;
 86 
u8 UART1_Request_SendFollowMe   = FALSE;
85 
u8 UART1_Request_ExternalControl= FALSE;
 87 
u8 UART1_Request_ExternalControl= FALSE;
86 
u8 UART1_Request_Display                = FALSE;
 88 
u8 UART1_Request_Display                = FALSE;
87 
u8 UART1_Request_Display1               = FALSE;
 89 
u8 UART1_Request_Display1               = FALSE;
88 
u8 UART1_Request_DebugData              = FALSE;
 90 
u8 UART1_Request_DebugData              = FALSE;
89 
u8 UART1_Request_DebugLabel             = 255;
 91 
u8 UART1_Request_DebugLabel             = 255;
90 
u8 UART1_Request_NaviData               = FALSE;
 92 
u8 UART1_Request_NaviData               = FALSE;
91 
u8 UART1_Request_ErrorMessage   = FALSE;
 93 
u8 UART1_Request_ErrorMessage   = FALSE;
92 
u8 UART1_Request_NewWaypoint    = FALSE;
 94 
u8 UART1_Request_NewWaypoint    = FALSE;
93 
u8 UART1_Request_ReadWaypoint   = 255;
 95 
u8 UART1_Request_ReadWaypoint   = 255;
94 
u8 UART1_Request_Data3D             = FALSE;
 96 
u8 UART1_Request_Data3D             = FALSE;
95 
u8 UART1_Request_Echo               = FALSE;
 97 
u8 UART1_Request_Echo               = FALSE;
96 
u8 UART1_Request_ParameterId    = 0;
 98 
u8 UART1_Request_ParameterId    = 0;
97 
u8 UART1_Request_Parameter              = FALSE;
 99 
u8 UART1_Request_Parameter              = FALSE;
98 
u8 UART1_DisplayLine                    = 0;
 100 
u8 UART1_DisplayLine                    = 0;
99 
u8 UART1_ConfirmFrame                   = 0;
 101 
u8 UART1_ConfirmFrame                   = 0;
100 
 
 102 
 
101 
UART_TypeDef *DebugUART = UART1;
 103 
UART_TypeDef *DebugUART = UART1;
102 
 
 104 
 
103 
// the primary rx fifo
 105 
// the primary rx fifo
104 
#define UART1_RX_FIFO_LEN 1024
 106 
#define UART1_RX_FIFO_LEN 1024
105 
u8 UART1_rxfifobuffer[UART1_RX_FIFO_LEN];
 107 
u8 UART1_rxfifobuffer[UART1_RX_FIFO_LEN];
106 
fifo_t UART1_rx_fifo;
 108 
fifo_t UART1_rx_fifo;
107 
 
 109 
 
108 
// the rx buffer
 110 
// the rx buffer
109 
#define UART1_RX_BUFFER_LEN  150
 111 
#define UART1_RX_BUFFER_LEN  150
110 
u8 UART1_rbuffer[UART1_RX_BUFFER_LEN];
 112 
u8 UART1_rbuffer[UART1_RX_BUFFER_LEN];
111 
Buffer_t UART1_rx_buffer;
 113 
Buffer_t UART1_rx_buffer;
112 
 
 114 
 
113 
// the tx buffer
 115 
// the tx buffer
114 
#define UART1_TX_BUFFER_LEN  150
 116 
#define UART1_TX_BUFFER_LEN  150
115 
u8 UART1_tbuffer[UART1_TX_BUFFER_LEN];
 117 
u8 UART1_tbuffer[UART1_TX_BUFFER_LEN];
116 
Buffer_t UART1_tx_buffer;
 118 
Buffer_t UART1_tx_buffer;
117 
 
 119 
 
118 
 
 120 
 
119 
 
 121 
 
120 
volatile u8 SerialLinkOkay = 0;
 122 
volatile u8 SerialLinkOkay = 0;
121 
 
 123 
 
122 
u8 text[200];
 124 
u8 text[200];
123 
 
 125 
 
124 
const u8 ANALOG_LABEL[32][16] =
 126 
const u8 ANALOG_LABEL[32][16] =
125 
{
 127 
{
126 
   //1234567890123456
 128 
   //1234567890123456
127 
        "AngleNick       ", //0
 129 
        "AngleNick       ", //0
128 
        "AngleRoll       ",
 130 
        "AngleRoll       ",
129 
        "AccNick         ",
 131 
        "AccNick         ",
130 
        "AccRoll         ",
 132 
        "AccRoll         ",
131 
        "                ",
 133 
        "                ",
132 
        "MK-Flags        ", //5
 134 
        "MK-Flags        ", //5
133 
        "NC-Flags        ",
 135 
        "NC-Flags        ",
134 
        "NickServo       ",
 136 
        "NickServo       ",
135 
        "RollServo       ",
 137 
        "RollServo       ",
136 
        "GPS Data        ",
 138 
        "GPS Data        ",
137 
        "CompassHeading  ", //10
 139 
        "CompassHeading  ", //10
138 
        "GyroHeading     ",
 140 
        "GyroHeading     ",
139 
        "SPI Error       ",
 141 
        "SPI Error       ",
140 
        "SPI Okay        ",
 142 
        "SPI Okay        ",
141 
        "I2C Error       ",
 143 
        "I2C Error       ",
142 
        "I2C Okay        ", //15
 144 
        "I2C Okay        ", //15
143 
        "                ",//    "Kalman_K        ",
 145 
        "                ",//    "Kalman_K        ",
144 
        "ACC_Speed_N     ",
 146 
        "ACC_Speed_N     ",
145 
        "ACC_Speed_E     ",
 147 
        "ACC_Speed_E     ",
146 
        "Speed_z         ",//    "GPS ACC         ",
 148 
        "Speed_z         ",//    "GPS ACC         ",
147 
        "                ",//    "MAXDrift        ", //20
 149 
        "                ",//    "MAXDrift        ", //20
148 
        "N_Speed         ",
 150 
        "N_Speed         ",
149 
        "E_Speed         ",
 151 
        "E_Speed         ",
150 
        "P-Part          ",
 152 
        "P-Part          ",
151 
        "I-Part          ",
 153 
        "I-Part          ",
152 
        "D-Part          ",//25
 154 
        "D-Part          ",//25
153 
        "PID-Part        ",
 155 
        "PID-Part        ",
154 
        "Distance N      ",
 156 
        "Distance N      ",
155 
        "Distance E      ",
 157 
        "Distance E      ",
156 
        "GPS_Nick        ",
 158 
        "GPS_Nick        ",
157 
        "GPS_Roll        ", //30
 159 
        "GPS_Roll        ", //30
158 
        "Used_Sats       "
 160 
        "Used_Sats       "
159 
};
 161 
};
160 
 
 162 
 
161 
DebugOut_t DebugOut;
 163 
DebugOut_t DebugOut;
162 
ExternControl_t ExternControl;
 164 
ExternControl_t ExternControl;
163 
UART_VersionInfo_t UART_VersionInfo;
 165 
UART_VersionInfo_t UART_VersionInfo;
164 
NaviData_t NaviData;
 166 
NaviData_t NaviData;
165 
Waypoint_t FollowMe;
 167 
Waypoint_t FollowMe;
166 
Data3D_t Data3D;
 168 
Data3D_t Data3D;
167 
u16 Echo; // 2 bytes recieved will be sent back as echo
 169 
u16 Echo; // 2 bytes recieved will be sent back as echo
168 
 
 170 
 
169 
u32 UART1_DebugData_Timer = 0;
 171 
u32 UART1_DebugData_Timer = 0;
170 
u32 UART1_DebugData_Interval = 5000;    // in ms
 172 
u32 UART1_DebugData_Interval = 0;       // in ms
171 
u32 UART1_NaviData_Timer = 0;
 173 
u32 UART1_NaviData_Timer = 0;
172 
u32 UART1_NaviData_Interval = 5000;             // in ms
 174 
u32 UART1_NaviData_Interval = 0;        // in ms
173 
u32 UART1_Data3D_Timer = 0;                             // in ms
 175 
u32 UART1_Data3D_Timer = 0;
174 
u32 UART1_Data3D_Interval = 0;
 176 
u32 UART1_Data3D_Interval = 0;          // in ms
175 
u32 UART1_Display_Timer = 0;
 177 
u32 UART1_Display_Timer = 0;
176 
u32 UART1_Display_Interval = 0;
 178 
u32 UART1_Display_Interval = 0;
177 
 
 179 
 
178 
/********************************************************/
 180 
/********************************************************/
179 
/*            Initialization the UART1                  */
 181 
/*            Initialization the UART1                  */
180 
/********************************************************/
 182 
/********************************************************/
181 
void UART1_Init (void)
 183 
void UART1_Init (void)
182 
{
 184 
{
183 
        GPIO_InitTypeDef GPIO_InitStructure;
 185 
        GPIO_InitTypeDef GPIO_InitStructure;
184 
        UART_InitTypeDef UART_InitStructure;
 186 
        UART_InitTypeDef UART_InitStructure;
185 
 
 187 
 
186 
        // initialize txd buffer
 188 
        // initialize txd buffer
187 
        Buffer_Init(&UART1_tx_buffer, UART1_tbuffer, UART1_TX_BUFFER_LEN);
 189 
        Buffer_Init(&UART1_tx_buffer, UART1_tbuffer, UART1_TX_BUFFER_LEN);
188 
 
 190 
 
189 
        // initialize rxd buffer
 191 
        // initialize rxd buffer
190 
        Buffer_Init(&UART1_rx_buffer, UART1_rbuffer, UART1_RX_BUFFER_LEN);
 192 
        Buffer_Init(&UART1_rx_buffer, UART1_rbuffer, UART1_RX_BUFFER_LEN);
191 
 
 193 
 
192 
        // initialize the rx fifo
 194 
        // initialize the rx fifo
193 
        fifo_init(&UART1_rx_fifo, UART1_rxfifobuffer, UART1_RX_FIFO_LEN);
 195 
        fifo_init(&UART1_rx_fifo, UART1_rxfifobuffer, UART1_RX_FIFO_LEN);
194 
 
 196 
 
195 
        SCU_APBPeriphClockConfig(__UART1, ENABLE);  // Enable the UART1 Clock
 197 
        SCU_APBPeriphClockConfig(__UART1, ENABLE);  // Enable the UART1 Clock
196 
        SCU_APBPeriphClockConfig(__GPIO3, ENABLE);  // Enable the GPIO3 Clock
 198 
        SCU_APBPeriphClockConfig(__GPIO3, ENABLE);  // Enable the GPIO3 Clock
197 
 
 199 
 
198 
        /*Configure UART1_Rx pin GPIO3.2*/
 200 
        /*Configure UART1_Rx pin GPIO3.2*/
199 
        GPIO_StructInit(&GPIO_InitStructure);
 201 
        GPIO_StructInit(&GPIO_InitStructure);
200 
        GPIO_InitStructure.GPIO_Direction =     GPIO_PinInput;
 202 
        GPIO_InitStructure.GPIO_Direction =     GPIO_PinInput;
201 
        GPIO_InitStructure.GPIO_Pin =                   GPIO_Pin_2;
 203 
        GPIO_InitStructure.GPIO_Pin =                   GPIO_Pin_2;
202 
        GPIO_InitStructure.GPIO_Type =                  GPIO_Type_PushPull;
 204 
        GPIO_InitStructure.GPIO_Type =                  GPIO_Type_PushPull;
203 
        GPIO_InitStructure.GPIO_IPInputConnected =      GPIO_IPInputConnected_Enable;
 205 
        GPIO_InitStructure.GPIO_IPInputConnected =      GPIO_IPInputConnected_Enable;
204 
        GPIO_InitStructure.GPIO_Alternate =     GPIO_InputAlt1; // UART1_RxD
 206 
        GPIO_InitStructure.GPIO_Alternate =     GPIO_InputAlt1; // UART1_RxD
205 
        GPIO_Init(GPIO3, &GPIO_InitStructure);
 207 
        GPIO_Init(GPIO3, &GPIO_InitStructure);
206 
 
 208 
 
207 
        /*Configure UART1_Tx pin GPIO3.3*/
 209 
        /*Configure UART1_Tx pin GPIO3.3*/
208 
        GPIO_StructInit(&GPIO_InitStructure);
 210 
        GPIO_StructInit(&GPIO_InitStructure);
209 
        GPIO_InitStructure.GPIO_Direction =     GPIO_PinOutput;
 211 
        GPIO_InitStructure.GPIO_Direction =     GPIO_PinOutput;
210 
        GPIO_InitStructure.GPIO_Pin =                   GPIO_Pin_3;
 212 
        GPIO_InitStructure.GPIO_Pin =                   GPIO_Pin_3;
211 
        GPIO_InitStructure.GPIO_Type =                  GPIO_Type_PushPull;
 213 
        GPIO_InitStructure.GPIO_Type =                  GPIO_Type_PushPull;
212 
        GPIO_InitStructure.GPIO_Alternate =     GPIO_OutputAlt2; // UART1_TX
 214 
        GPIO_InitStructure.GPIO_Alternate =     GPIO_OutputAlt2; // UART1_TX
213 
        GPIO_Init(GPIO3, &GPIO_InitStructure);
 215 
        GPIO_Init(GPIO3, &GPIO_InitStructure);
214 
 
 216 
 
215 
        /* UART1 configured as follow:
 217 
        /* UART1 configured as follow:
216 
        - Word Length = 8 Bits
 218 
        - Word Length = 8 Bits
217 
        - One Stop Bit
 219 
        - One Stop Bit
218 
        - No parity
 220 
        - No parity
219 
        - BaudRate = 57600 baud
 221 
        - BaudRate = 57600 baud
220 
        - Hardware flow control Disabled
 222 
        - Hardware flow control Disabled
221 
        - Receive and transmit enabled
 223 
        - Receive and transmit enabled
222 
        - Receive and transmit FIFOs are Disabled
 224 
        - Receive and transmit FIFOs are Disabled
223 
        */
 225 
        */
224 
        UART_StructInit(&UART_InitStructure);
 226 
        UART_StructInit(&UART_InitStructure);
225 
        UART_InitStructure.UART_WordLength =                    UART_WordLength_8D;
 227 
        UART_InitStructure.UART_WordLength =                    UART_WordLength_8D;
226 
        UART_InitStructure.UART_StopBits =                              UART_StopBits_1;
 228 
        UART_InitStructure.UART_StopBits =                              UART_StopBits_1;
227 
        UART_InitStructure.UART_Parity =                                UART_Parity_No ;
 229 
        UART_InitStructure.UART_Parity =                                UART_Parity_No ;
228 
        UART_InitStructure.UART_BaudRate =                              UART1_BAUD_RATE;
 230 
        UART_InitStructure.UART_BaudRate =                              UART1_BAUD_RATE;
229 
        UART_InitStructure. UART_HardwareFlowControl =  UART_HardwareFlowControl_None;
 231 
        UART_InitStructure. UART_HardwareFlowControl =  UART_HardwareFlowControl_None;
230 
        UART_InitStructure.UART_Mode =                                  UART_Mode_Tx_Rx;
 232 
        UART_InitStructure.UART_Mode =                                  UART_Mode_Tx_Rx;
231 
        UART_InitStructure.UART_FIFO =                                  UART_FIFO_Enable;
 233 
        UART_InitStructure.UART_FIFO =                                  UART_FIFO_Enable;
232 
        UART_InitStructure.UART_TxFIFOLevel =                   UART_FIFOLevel_1_2;
 234 
        UART_InitStructure.UART_TxFIFOLevel =                   UART_FIFOLevel_1_2;
233 
        UART_InitStructure.UART_RxFIFOLevel =                   UART_FIFOLevel_1_2;
 235 
        UART_InitStructure.UART_RxFIFOLevel =                   UART_FIFOLevel_1_2;
234 
 
 236 
 
235 
        UART_DeInit(UART1); // reset uart 1     to default
 237 
        UART_DeInit(UART1); // reset uart 1     to default
236 
        UART_Init(UART1, &UART_InitStructure); // initialize uart 1
 238 
        UART_Init(UART1, &UART_InitStructure); // initialize uart 1
237 
        // enable uart 1 interrupts selective
 239 
        // enable uart 1 interrupts selective
238 
        UART_ITConfig(UART1, UART_IT_Receive | UART_IT_ReceiveTimeOut, ENABLE);
 240 
        UART_ITConfig(UART1, UART_IT_Receive | UART_IT_ReceiveTimeOut, ENABLE);
239 
        UART_Cmd(UART1, ENABLE); // enable uart 1
 241 
        UART_Cmd(UART1, ENABLE); // enable uart 1
240 
        // configure the uart 1 interupt line
 242 
        // configure the uart 1 interupt line
241 
        VIC_Config(UART1_ITLine, VIC_IRQ, PRIORITY_UART1);
 243 
        VIC_Config(UART1_ITLine, VIC_IRQ, PRIORITY_UART1);
242 
                // enable the uart 1 IRQ
 244 
                // enable the uart 1 IRQ
243 
        VIC_ITCmd(UART1_ITLine, ENABLE);
 245 
        VIC_ITCmd(UART1_ITLine, ENABLE);
244 
 
 246 
 
245 
        // initialize the debug timer
 247 
        // initialize the debug timer
246 
        UART1_DebugData_Timer = SetDelay(UART1_DebugData_Interval);
 248 
        UART1_DebugData_Timer = SetDelay(UART1_DebugData_Interval);
247 
        UART1_NaviData_Timer = SetDelay(UART1_NaviData_Interval)+500;
 249 
        UART1_NaviData_Timer = SetDelay(UART1_NaviData_Interval)+500;
248 
 
 250 
 
249 
        // Fill Version Info Structure
 251 
        // Fill Version Info Structure
250 
        UART_VersionInfo.SWMajor = VERSION_MAJOR;
 252 
        UART_VersionInfo.SWMajor = VERSION_MAJOR;
251 
        UART_VersionInfo.SWMinor = VERSION_MINOR;
 253 
        UART_VersionInfo.SWMinor = VERSION_MINOR;
252 
        UART_VersionInfo.SWPatch = VERSION_PATCH;
 254 
        UART_VersionInfo.SWPatch = VERSION_PATCH;
253 
        UART_VersionInfo.ProtoMajor = VERSION_SERIAL_MAJOR;
 255 
        UART_VersionInfo.ProtoMajor = VERSION_SERIAL_MAJOR;
254 
        UART_VersionInfo.ProtoMinor = VERSION_SERIAL_MINOR;
 256 
        UART_VersionInfo.ProtoMinor = VERSION_SERIAL_MINOR;
255 
 
 257 
 
256 
        NaviData.Version = NAVIDATA_VERSION;
 258 
        NaviData.Version = NAVIDATA_VERSION;
257 
 
 259 
 
258 
        UART1_PutString("\r\nUART1 init...ok");
 260 
        UART1_PutString("\r\nUART1 init...ok");
259 
}
 261 
}
260 
 
 262 
 
261 
 
 263 
 
262 
/****************************************************************/
 264 
/****************************************************************/
263 
/*               USART1 receiver ISR                            */
 265 
/*               USART1 receiver ISR                            */
264 
/****************************************************************/
 266 
/****************************************************************/
265 
void UART1_IRQHandler(void)
 267 
void UART1_IRQHandler(void)
266 
{
 268 
{
267 
        static u8 abortState = 0;
 269 
        static u8 abortState = 0;
268 
        u8 c;
 270 
        u8 c;
269 
 
 271 
 
270 
        IENABLE;
 272 
        IENABLE;
271 
 
 273 
 
272 
        if((UART_GetITStatus(UART1, UART_IT_Receive) != RESET) || (UART_GetITStatus(UART1, UART_IT_ReceiveTimeOut) != RESET) )
 274 
        if((UART_GetITStatus(UART1, UART_IT_Receive) != RESET) || (UART_GetITStatus(UART1, UART_IT_ReceiveTimeOut) != RESET) )
273 
        {
 275 
        {
274 
                // clear the pending bits!
 276 
                // clear the pending bits!
275 
                UART_ClearITPendingBit(UART1, UART_IT_Receive);
 277 
                UART_ClearITPendingBit(UART1, UART_IT_Receive);
276 
                UART_ClearITPendingBit(UART1, UART_IT_ReceiveTimeOut);
 278 
                UART_ClearITPendingBit(UART1, UART_IT_ReceiveTimeOut);
277 
                // if debug UART is not UART1
 279 
                // if debug UART is not UART1
278 
                if (DebugUART != UART1)
 280 
                if (DebugUART != UART1)
279 
                {       // forward received data to the debug UART tx buffer
 281 
                {       // forward received data to the debug UART tx buffer
280 
                        while(UART_GetFlagStatus(UART1, UART_FLAG_RxFIFOEmpty) != SET)
 282 
                        while(UART_GetFlagStatus(UART1, UART_FLAG_RxFIFOEmpty) != SET)
281 
                        {
 283 
                        {
282 
                                // move the byte from the rx buffer of UART1 to the tx buffer of DebugUART
 284 
                                // move the byte from the rx buffer of UART1 to the tx buffer of DebugUART
283 
                                c = UART_ReceiveData(UART1);
 285 
                                c = UART_ReceiveData(UART1);
284 
 
 286 
 
285 
                                // check for abort condition (ESC ESC 0x55 0xAA 0x00)
 287 
                                // check for abort condition (ESC ESC 0x55 0xAA 0x00)
286 
                                switch (abortState)
 288 
                                switch (abortState)
287 
                                {
 289 
                                {
288 
                                        case 0:
 290 
                                        case 0:
289 
                                                if (c == 27) abortState++;
 291 
                                                if (c == 27) abortState++;
290 
                                                break;
 292 
                                                break;
291 
                                        case 1:
 293 
                                        case 1:
292 
                                                if (c == 27) abortState++;
 294 
                                                if (c == 27) abortState++;
293 
                                                else abortState = 0;
 295 
                                                else abortState = 0;
294 
                                        break;
 296 
                                        break;
295 
                                        case 2:
 297 
                                        case 2:
296 
                                                if (c == 0x55) abortState++;
 298 
                                                if (c == 0x55) abortState++;
297 
                                                else abortState = 0;
 299 
                                                else abortState = 0;
298 
                                                break;
 300 
                                                break;
299 
                                        case 3:
 301 
                                        case 3:
300 
                                                if (c == 0xAA) abortState++;
 302 
                                                if (c == 0xAA) abortState++;
301 
                                                else abortState = 0;
 303 
                                                else abortState = 0;
302 
                                                break;
 304 
                                                break;
303 
                                        case 4:
 305 
                                        case 4:
304 
                                                if (c == 0x00)
 306 
                                                if (c == 0x00)
305 
                                                {
 307 
                                                {
306 
                                                        if(DebugUART == UART0)
 308 
                                                        if(DebugUART == UART0)
307 
                                                        {
 309 
                                                        {
308 
                                                                UART0_Connect_to_MKGPS();
 310 
                                                                UART0_Connect_to_MKGPS();
309 
                                                                TIMER2_Init(); // enbable servo outputs
 311 
                                                                TIMER2_Init(); // enbable servo outputs
310 
                                                                fifo_purge(&UART1_rx_fifo); // flush the whole fifo init buffer
 312 
                                                                fifo_purge(&UART1_rx_fifo); // flush the whole fifo init buffer
311 
                                                        }
 313 
                                                        }
312 
                                                        DebugUART = UART1;
 314 
                                                        DebugUART = UART1;
313 
                                                }
 315 
                                                }
314 
                                                abortState = 0;
 316 
                                                abortState = 0;
315 
                                                break;
 317 
                                                break;
316 
                                } // end switch abort state
 318 
                                } // end switch abort state
317 
                                // if the Debug uart is not UART1, redirect input to the Debug UART
 319 
                                // if the Debug uart is not UART1, redirect input to the Debug UART
318 
                                if (DebugUART != UART1)
 320 
                                if (DebugUART != UART1)
319 
                                {
 321 
                                {
320 
                                        // wait for space in the tx buffer of the DebugUART
 322 
                                        // wait for space in the tx buffer of the DebugUART
321 
                                        while(UART_GetFlagStatus(DebugUART, UART_FLAG_TxFIFOFull) == SET) {};
 323 
                                        while(UART_GetFlagStatus(DebugUART, UART_FLAG_TxFIFOFull) == SET) {};
322 
                                        // move byte to the tx fifo of the debug uart
 324 
                                        // move byte to the tx fifo of the debug uart
323 
                                        UART_SendData(DebugUART, c);
 325 
                                        UART_SendData(DebugUART, c);
324 
                                }
 326 
                                }
325 
                        }
 327 
                        }
326 
                }
 328 
                }
327 
                else  // DebugUART == UART1 (normal operation)
 329 
                else  // DebugUART == UART1 (normal operation)
328 
                {
 330 
                {
329 
                        while(UART_GetFlagStatus(UART1, UART_FLAG_RxFIFOEmpty) != SET)
 331 
                        while(UART_GetFlagStatus(UART1, UART_FLAG_RxFIFOEmpty) != SET)
330 
                        { // some byes in the hardware fifo
 332 
                        { // some byes in the hardware fifo
331 
                            // get byte from hardware fifo
 333 
                            // get byte from hardware fifo
332 
                        c = UART_ReceiveData(UART1);
 334 
                        c = UART_ReceiveData(UART1);
333 
                                // put into the software fifo
 335 
                                // put into the software fifo
334 
                                if(!fifo_put(&UART1_rx_fifo, c))
 336 
                                if(!fifo_put(&UART1_rx_fifo, c))
335 
                                {       // fifo overflow
 337 
                                {       // fifo overflow
336 
                                        //fifo_purge(&UART1_rx_fifo); // flush the whole buffer
 338 
                                        //fifo_purge(&UART1_rx_fifo); // flush the whole buffer
337 
                                }
 339 
                                }
338 
                        } // EOF while some byes in the hardware fifo
 340 
                        } // EOF while some byes in the hardware fifo
339 
                } // eof DebugUart = UART1
 341 
                } // eof DebugUart = UART1
340 
        }
 342 
        }
341 
 
 343 
 
342 
        IDISABLE;
 344 
        IDISABLE;
343 
}
 345 
}
344 
 
 346 
 
345 
/**************************************************************/
 347 
/**************************************************************/
346 
/* Process incomming data from debug uart                     */
 348 
/* Process incomming data from debug uart                     */
347 
/**************************************************************/
 349 
/**************************************************************/
348 
void UART1_ProcessRxData(void)
 350 
void UART1_ProcessRxData(void)
349 
{
 351 
{
350 
        // return on forwarding uart  or unlocked rx buffer
 352 
        // return on forwarding uart  or unlocked rx buffer
351 
        if(DebugUART != UART1) return;
 353 
        if(DebugUART != UART1) return;
352 
 
 354 
 
353 
        u8 c;
 355 
        u8 c;
354 
        // if rx buffer is not locked
 356 
        // if rx buffer is not locked
355 
        if(UART1_rx_buffer.Locked == FALSE)
 357 
        if(UART1_rx_buffer.Locked == FALSE)
356 
        {   //collect data from primary rx fifo
 358 
        {   //collect data from primary rx fifo
357 
                while(fifo_get(&UART1_rx_fifo, &c))
 359 
                while(fifo_get(&UART1_rx_fifo, &c))
358 
                {       // break if complete frame is collected
 360 
                {       // break if complete frame is collected
359 
                        if(MKProtocol_CollectSerialFrame(&UART1_rx_buffer, c)) break;
 361 
                        if(MKProtocol_CollectSerialFrame(&UART1_rx_buffer, c)) break;
360 
                }
 362 
                }
361 
        }
 363 
        }
362 
        if(UART1_rx_buffer.Locked == FALSE) return;
 364 
        if(UART1_rx_buffer.Locked == FALSE) return;
363 
 
 365 
 
364 
        Waypoint_t * pWaypoint = NULL;
 366 
        Waypoint_t * pWaypoint = NULL;
365 
        SerialMsg_t SerialMsg;
 367 
        SerialMsg_t SerialMsg;
366 
 
 368 
 
367 
        // analyze header first
 369 
        // analyze header first
368 
        MKProtocol_DecodeSerialFrameHeader(&UART1_rx_buffer, &SerialMsg);
 370 
        MKProtocol_DecodeSerialFrameHeader(&UART1_rx_buffer, &SerialMsg);
369 
        if( SerialMsg.Address == FC_ADDRESS )
 371 
        if( SerialMsg.Address == FC_ADDRESS )
370 
        {
 372 
        {
371 
                switch(SerialMsg.CmdID)
 373 
                switch(SerialMsg.CmdID)
372 
                {
 374 
                {
373 
                        case 'y': // serial poti values
 375 
                        case 'y': // serial poti values
374 
                        case 'b': // extern control
 376 
                        case 'b': // extern control
375 
                                Buffer_Copy(&UART1_rx_buffer, &UART2_tx_buffer); //forward to FC
 377 
                                Buffer_Copy(&UART1_rx_buffer, &UART2_tx_buffer); //forward to FC
376 
                                Buffer_Clear(&UART1_rx_buffer); // free rc buffer for next frame
 378 
                                Buffer_Clear(&UART1_rx_buffer); // free rc buffer for next frame
377 
                                return; //end process rx data
 379 
                                return; //end process rx data
378 
                        break;
 380 
                        break;
379 
                }
 381 
                }
380 
        }
 382 
        }
381 
 
 383 
 
382 
        MKProtocol_DecodeSerialFrameData(&UART1_rx_buffer, &SerialMsg); // decode serial frame in rxd buffer
 384 
        MKProtocol_DecodeSerialFrameData(&UART1_rx_buffer, &SerialMsg); // decode serial frame in rxd buffer
383 
    if(SerialMsg.CmdID != 'z') SerialLinkOkay = 250;      // reset SerialTimeout, but not in case of the "ping"
 385 
    if(SerialMsg.CmdID != 'z') SerialLinkOkay = 250;      // reset SerialTimeout, but not in case of the "ping"
384 
        switch(SerialMsg.Address) // check for Slave Address
 386 
        switch(SerialMsg.Address) // check for Slave Address
385 
        {
 387 
        {
386 
                case NC_ADDRESS:  // own Slave Address
 388 
                case NC_ADDRESS:  // own Slave Address
387 
                switch(SerialMsg.CmdID)
 389 
                switch(SerialMsg.CmdID)
388 
                {
 390 
                {
389 
                        case 'z': // connection checker
 391 
                        case 'z': // connection checker
390 
                                memcpy(&Echo, SerialMsg.pData, sizeof(Echo)); // copy echo pattern
 392 
                                memcpy(&Echo, SerialMsg.pData, sizeof(Echo)); // copy echo pattern
391 
                                UART1_Request_Echo = TRUE;
 393 
                                UART1_Request_Echo = TRUE;
392 
                                break;
 394 
                                break;
393 
 
 395 
 
394 
                        case 'e': // request for the text of the error status
 396 
                        case 'e': // request for the text of the error status
395 
                                UART1_Request_ErrorMessage = TRUE;
 397 
                                UART1_Request_ErrorMessage = TRUE;
396 
                                break;
 398 
                                break;
397 
 
 399 
 
398 
                        case 's'://  new target position
 400 
                        case 's'://  new target position
399 
                                pWaypoint = (Waypoint_t*)SerialMsg.pData;
 401 
                                pWaypoint = (Waypoint_t*)SerialMsg.pData;
400 
                                BeepTime = 300;
 402 
                                BeepTime = 300;
401 
                                if(pWaypoint->Position.Status == NEWDATA)
 403 
                                if(pWaypoint->Position.Status == NEWDATA)
402 
                                {
 404 
                                {
403 
                                        WPList_Clear(); // empty WPList
 405 
                                        WPList_Clear(); // empty WPList
404 
                                        WPList_Append(pWaypoint);
 406 
                                        WPList_Append(pWaypoint);
405 
                                        GPS_pWaypoint = WPList_Begin();
 407 
                                        GPS_pWaypoint = WPList_Begin();
406 
                                }
 408 
                                }
407 
                                break;
 409 
                                break;
408 
 
 410 
 
409 
                        case 'u': // redirect debug uart
 411 
                        case 'u': // redirect debug uart
410 
                                switch(SerialMsg.pData[0])
 412 
                                switch(SerialMsg.pData[0])
411 
                                {
 413 
                                {
412 
                                        case UART_FLIGHTCTRL:
 414 
                                        case UART_FLIGHTCTRL:
413 
                                                UART2_Init();                           // initialize UART2 to FC pins
 415 
                                                UART2_Init();                           // initialize UART2 to FC pins
414 
                                                fifo_purge(&UART1_rx_fifo);
 416 
                                                fifo_purge(&UART1_rx_fifo);
415 
                                                TIMER2_Deinit();                        // reduce irq load
 417 
                                                TIMER2_Deinit();                        // reduce irq load
416 
                                                DebugUART = UART2;
 418 
                                                DebugUART = UART2;
417 
                                                break;
 419 
                                                break;
418 
                                        case UART_MK3MAG:
 420 
                                        case UART_MK3MAG:
419 
                                                if(FC.MKFlags & MKFLAG_MOTOR_RUN) break; // not if the motors are running
 421 
                                                if(FC.MKFlags & MKFLAG_MOTOR_RUN) break; // not if the motors are running
420 
                                                UART0_Connect_to_MK3MAG();      // mux UART0 to MK3MAG pins
 422 
                                                UART0_Connect_to_MK3MAG();      // mux UART0 to MK3MAG pins
421 
                                                GPSData.Status = INVALID;
 423 
                                                GPSData.Status = INVALID;
422 
                                                fifo_purge(&UART1_rx_fifo);
 424 
                                                fifo_purge(&UART1_rx_fifo);
423 
                                                DebugUART = UART0;
 425 
                                                DebugUART = UART0;
424 
                                                break;
 426 
                                                break;
425 
                                        case UART_MKGPS:
 427 
                                        case UART_MKGPS:
426 
                                                if(FC.MKFlags & MKFLAG_MOTOR_RUN) break; // not if the motors are running
 428 
                                                if(FC.MKFlags & MKFLAG_MOTOR_RUN) break; // not if the motors are running
427 
                                                TIMER2_Deinit();                        // disable servo outputs to reduce irq load
 429 
                                                TIMER2_Deinit();                        // disable servo outputs to reduce irq load
428 
                                                UART0_Connect_to_MKGPS();       // connect UART0 to MKGPS pins
 430 
                                                UART0_Connect_to_MKGPS();       // connect UART0 to MKGPS pins
429 
                                                GPSData.Status = INVALID;
 431 
                                                GPSData.Status = INVALID;
430 
                                                fifo_purge(&UART1_rx_fifo);
 432 
                                                fifo_purge(&UART1_rx_fifo);
431 
                                                DebugUART = UART0;
 433 
                                                DebugUART = UART0;
432 
                                                break;
 434 
                                                break;
433 
                                        default:
 435 
                                        default:
434 
                                                break;
 436 
                                                break;
435 
                                }
 437 
                                }
436 
                                break;
 438 
                                break;
437 
 
 439 
 
438 
                        case 'w'://  Append Waypoint to List
 440 
                        case 'w'://  Append Waypoint to List
439 
                                {
 441 
                                {
440 
                                        static u8 oldIndex = 0x00;
 442 
                                        static u8 oldIndex = 0x00;
441 
 
 443 
 
442 
                                        pWaypoint = (Waypoint_t*)SerialMsg.pData;
 444 
                                        pWaypoint = (Waypoint_t*)SerialMsg.pData;
443 
                                        if(pWaypoint->Position.Status == INVALID)
 445 
                                        if(pWaypoint->Position.Status == INVALID)
444 
                                        {  // clear WP List
 446 
                                        {  // clear WP List
445 
                                                WPList_Clear();
 447 
                                                WPList_Clear();
446 
                                                oldIndex = 0x00;
 448 
                                                oldIndex = 0x00;
447 
                                                GPS_pWaypoint = WPList_Begin();
 449 
                                                GPS_pWaypoint = WPList_Begin();
448 
                                                UART1_Request_NewWaypoint = TRUE;
 450 
                                                UART1_Request_NewWaypoint = TRUE;
449 
                                        }
 451 
                                        }
450 
                                        else if (pWaypoint->Position.Status == NEWDATA)
 452 
                                        else if (pWaypoint->Position.Status == NEWDATA)
451 
                                        {  // app current WP to the list
 453 
                                        {  // app current WP to the list
452 
                                                 if (pWaypoint->Index == oldIndex + 1)
 454 
                                                 if (pWaypoint->Index == oldIndex + 1)
453 
                                                {
 455 
                                                {
454 
                                                        WPList_Append(pWaypoint);
 456 
                                                        WPList_Append(pWaypoint);
455 
                                                        BeepTime = 500;
 457 
                                                        BeepTime = 500;
456 
                                                        oldIndex = pWaypoint->Index;
 458 
                                                        oldIndex = pWaypoint->Index;
457 
                                                        UART1_Request_NewWaypoint = TRUE;
 459 
                                                        UART1_Request_NewWaypoint = TRUE;
458 
                                                }
 460 
                                                }
459 
                                        }
 461 
                                        }
460 
                                }
 462 
                                }
461 
                                break;
 463 
                                break;
462 
 
 464 
 
463 
                        case 'x'://  Read Waypoint from List
 465 
                        case 'x'://  Read Waypoint from List
464 
                                UART1_Request_ReadWaypoint = SerialMsg.pData[0];
 466 
                                UART1_Request_ReadWaypoint = SerialMsg.pData[0];
465 
                                break;
 467 
                                break;
466 
 
 468 
 
467 
                        case 'j':// Set/Get NC-Parameter
 469 
                        case 'j':// Set/Get NC-Parameter
468 
                                switch(SerialMsg.pData[0])
 470 
                                switch(SerialMsg.pData[0])
469 
                                {
 471 
                                {
470 
                                        case 0: // get
 472 
                                        case 0: // get
471 
                                        break;
 473 
                                        break;
472 
 
 474 
 
473 
                                        case 1: // set
 475 
                                        case 1: // set
474 
                                        {
 476 
                                        {
475 
                                                s16 value;
 477 
                                                s16 value;
476 
                                                value = SerialMsg.pData[2] + (s16)SerialMsg.pData[3] * 0x0100;
 478 
                                                value = SerialMsg.pData[2] + (s16)SerialMsg.pData[3] * 0x0100;
477 
                                                NCParams_SetValue(SerialMsg.pData[1], &value);
 479 
                                                NCParams_SetValue(SerialMsg.pData[1], &value);
478 
                                        }
 480 
                                        }
479 
                                        break;
 481 
                                        break;
480 
 
 482 
 
481 
                                        default:
 483 
                                        default:
482 
                                        break;
 484 
                                        break;
483 
                                }
 485 
                                }
484 
                                UART1_Request_ParameterId = SerialMsg.pData[1];
 486 
                                UART1_Request_ParameterId = SerialMsg.pData[1];
485 
                                UART1_Request_Parameter = TRUE;
 487 
                                UART1_Request_Parameter = TRUE;
486 
                                break;
 488 
                                break;
487 
                        default:
 489 
                        default:
488 
                                // unsupported command recieved
 490 
                                // unsupported command recieved
489 
                                break;
 491 
                                break;
490 
                } // case NC_ADDRESS
 492 
                } // case NC_ADDRESS
491 
                // "break;" is missing here to fall thru to the common commands
 493 
                // "break;" is missing here to fall thru to the common commands
492 
 
 494 
 
493 
                default:  // and any other Slave Address
 495 
                default:  // and any other Slave Address
494 
 
 496 
 
495 
                switch(SerialMsg.CmdID) // check CmdID
 497 
                switch(SerialMsg.CmdID) // check CmdID
496 
                {
 498 
                {
497 
                        case 'a':// request for the labels of the analog debug outputs
 499 
                        case 'a':// request for the labels of the analog debug outputs
498 
                                UART1_Request_DebugLabel = SerialMsg.pData[0];
 500 
                                UART1_Request_DebugLabel = SerialMsg.pData[0];
499 
                                if(UART1_Request_DebugLabel > 31) UART1_Request_DebugLabel = 31;
 501 
                                if(UART1_Request_DebugLabel > 31) UART1_Request_DebugLabel = 31;
500 
                                break;
 502 
                                break;
501 
                        /*
 503 
                        /*
502 
                        case 'b': // submit extern control
 504 
                        case 'b': // submit extern control
503 
                                memcpy(&ExternControl, SerialMsg.pData, sizeof(ExternControl));
 505 
                                memcpy(&ExternControl, SerialMsg.pData, sizeof(ExternControl));
504 
                                UART1_ConfirmFrame = ExternControl.Frame;
 506 
                                UART1_ConfirmFrame = ExternControl.Frame;
505 
                                break;
 507 
                                break;
506 
                        */
 508 
                        */
507 
                        case 'd': // request for debug data;
 509 
                        case 'd': // request for debug data;
508 
                                UART1_DebugData_Interval = (u32) SerialMsg.pData[0] * 10;
 510 
                                UART1_DebugData_Interval = (u32) SerialMsg.pData[0] * 10;
509 
                                if(UART1_DebugData_Interval > 0) UART1_Request_DebugData = TRUE;
 511 
                                if(UART1_DebugData_Interval > 0) UART1_Request_DebugData = TRUE;
- 
 
 512 
                                UART1_AboTimeOut = SetDelay(ABO_TIMEOUT);
510 
                                break;
 513 
                                break;
511 
 
 514 
 
512 
                        case 'c': // request for 3D data;
 515 
                        case 'c': // request for 3D data;
513 
                                UART1_Data3D_Interval = (u32) SerialMsg.pData[0] * 10;
 516 
                                UART1_Data3D_Interval = (u32) SerialMsg.pData[0] * 10;
514 
                                if(UART1_Data3D_Interval > 0) UART1_Request_Data3D = TRUE;
 517 
                                if(UART1_Data3D_Interval > 0) UART1_Request_Data3D = TRUE;
- 
 
 518 
                                UART1_AboTimeOut = SetDelay(ABO_TIMEOUT);
515 
                                break;
 519 
                                break;
516 
                        /*
 520 
                        /*
517 
                        case 'g':// request for external control data
 521 
                        case 'g':// request for external control data
518 
                                UART1_Request_ExternalControl = TRUE;
 522 
                                UART1_Request_ExternalControl = TRUE;
519 
                                break;
 523 
                                break;
520 
                        */
 524 
                        */
521 
                        case 'h':// reqest for display line
 525 
                        case 'h':// reqest for display line
522 
                                if((SerialMsg.pData[0]& 0x80) == 0x00)// old format
 526 
                                if((SerialMsg.pData[0]& 0x80) == 0x00)// old format
523 
                                {
 527 
                                {
524 
                                        UART1_DisplayLine = 2;
 528 
                                        UART1_DisplayLine = 2;
525 
                                        UART1_Display_Interval = 0;
 529 
                                        UART1_Display_Interval = 0;
526 
                                }
 530 
                                }
527 
                                else
 531 
                                else
528 
                                {
 532 
                                {
529 
                                        RemoteKeys |= ~SerialMsg.pData[0];
 533 
                                        RemoteKeys |= ~SerialMsg.pData[0];
530 
                                        UART1_Display_Interval = (u32) SerialMsg.pData[1] * 10;
 534 
                                        UART1_Display_Interval = (u32) SerialMsg.pData[1] * 10;
531 
                                        UART1_DisplayLine = 4;
 535 
                                        UART1_DisplayLine = 4;
- 
 
 536 
                                        UART1_AboTimeOut = SetDelay(ABO_TIMEOUT);
532 
                                }
 537 
                                }
533 
                                UART1_Request_Display = TRUE;
 538 
                                UART1_Request_Display = TRUE;
534 
                                break;
 539 
                                break;
535 
 
 540 
 
536 
                        case 'l':// reqest for display columns
 541 
                        case 'l':// reqest for display columns
537 
                                MenuItem = SerialMsg.pData[0];
 542 
                                MenuItem = SerialMsg.pData[0];
538 
                                UART1_Request_Display1 = TRUE;
 543 
                                UART1_Request_Display1 = TRUE;
539 
                                break;
 544 
                                break;
540 
 
 545 
 
541 
                        case 'o': // request for navigation information
 546 
                        case 'o': // request for navigation information
542 
                                UART1_NaviData_Interval = (u32) SerialMsg.pData[0] * 10;
 547 
                                UART1_NaviData_Interval = (u32) SerialMsg.pData[0] * 10;
543 
                                if(UART1_NaviData_Interval > 0) UART1_Request_NaviData = TRUE;
 548 
                                if(UART1_NaviData_Interval > 0) UART1_Request_NaviData = TRUE;
- 
 
 549 
                                UART1_AboTimeOut = SetDelay(ABO_TIMEOUT);
544 
                                break;
 550 
                                break;
545 
 
 551 
 
546 
                        case 'v': // request for version info
 552 
                        case 'v': // request for version info
547 
                                UART1_Request_VersionInfo = TRUE;
 553 
                                UART1_Request_VersionInfo = TRUE;
548 
                                break;
 554 
                                break;
549 
                        default:
 555 
                        default:
550 
                                // unsupported command recieved
 556 
                                // unsupported command recieved
551 
                                break;
 557 
                                break;
552 
                }
 558 
                }
553 
                break; // default:
 559 
                break; // default:
554 
        }
 560 
        }
555 
        Buffer_Clear(&UART1_rx_buffer); // free rc buffer for next frame
 561 
        Buffer_Clear(&UART1_rx_buffer); // free rc buffer for next frame
556 
}
 562 
}
557 
 
 563 
 
558 
 
 564 
 
559 
/*****************************************************/
 565 
/*****************************************************/
560 
/*                   Send a character                */
 566 
/*                   Send a character                */
561 
/*****************************************************/
 567 
/*****************************************************/
562 
s16 UART1_Putchar(char c)
 568 
s16 UART1_Putchar(char c)
563 
{
 569 
{
564 
        if (c == '\n') UART1_Putchar('\r');
 570 
        if (c == '\n') UART1_Putchar('\r');
565 
        // wait until txd fifo is not full
 571 
        // wait until txd fifo is not full
566 
        while (UART_GetFlagStatus(UART1, UART_FLAG_TxFIFOFull) != RESET);
 572 
        while (UART_GetFlagStatus(UART1, UART_FLAG_TxFIFOFull) != RESET);
567 
        // transmit byte
 573 
        // transmit byte
568 
        UART_SendData(UART1, c);
 574 
        UART_SendData(UART1, c);
569 
        return (0);
 575 
        return (0);
570 
}
 576 
}
571 
 
 577 
 
572 
/*****************************************************/
 578 
/*****************************************************/
573 
/*       Send a string to the debug uart              */
 579 
/*       Send a string to the debug uart              */
574 
/*****************************************************/
 580 
/*****************************************************/
575 
void UART1_PutString(u8 *s)
 581 
void UART1_PutString(u8 *s)
576 
{
 582 
{
577 
        if(s == NULL) return;
 583 
        if(s == NULL) return;
578 
        while (*s != '\0' && DebugUART == UART1)
 584 
        while (*s != '\0' && DebugUART == UART1)
579 
        {
 585 
        {
580 
                UART1_Putchar(*s);
 586 
                UART1_Putchar(*s);
581 
                s ++;
 587 
                s ++;
582 
        }
 588 
        }
583 
}
 589 
}
584 
 
 590 
 
585 
 
 591 
 
586 
/**************************************************************/
 592 
/**************************************************************/
587 
/*         Transmit tx buffer via debug uart                  */
 593 
/*         Transmit tx buffer via debug uart                  */
588 
/**************************************************************/
 594 
/**************************************************************/
589 
void UART1_Transmit(void)
 595 
void UART1_Transmit(void)
590 
{
 596 
{
591 
        u8 tmp_tx;
 597 
        u8 tmp_tx;
592 
        if(DebugUART != UART1) return;
 598 
        if(DebugUART != UART1) return;
593 
        // if something has to be send and the txd fifo is not full
 599 
        // if something has to be send and the txd fifo is not full
594 
        if(UART1_tx_buffer.Locked == TRUE)
 600 
        if(UART1_tx_buffer.Locked == TRUE)
595 
        {
 601 
        {
596 
                // while there is some space in the tx fifo
 602 
                // while there is some space in the tx fifo
597 
                while(UART_GetFlagStatus(UART1, UART_FLAG_TxFIFOFull) != SET)
 603 
                while(UART_GetFlagStatus(UART1, UART_FLAG_TxFIFOFull) != SET)
598 
                {
 604 
                {
599 
                        tmp_tx = UART1_tx_buffer.pData[UART1_tx_buffer.Position++]; // read next byte from txd buffer
 605 
                        tmp_tx = UART1_tx_buffer.pData[UART1_tx_buffer.Position++]; // read next byte from txd buffer
600 
                        UART_SendData(UART1, tmp_tx); // put character to txd fifo
 606 
                        UART_SendData(UART1, tmp_tx); // put character to txd fifo
601 
                        // if terminating character or end of txd buffer reached
 607 
                        // if terminating character or end of txd buffer reached
602 
                        if((tmp_tx == '\r') || (UART1_tx_buffer.Position == UART1_tx_buffer.DataBytes))
 608 
                        if((tmp_tx == '\r') || (UART1_tx_buffer.Position == UART1_tx_buffer.DataBytes))
603 
                        {
 609 
                        {
604 
                                Buffer_Clear(&UART1_tx_buffer); // clear txd buffer
 610 
                                Buffer_Clear(&UART1_tx_buffer); // clear txd buffer
605 
                                break; // end while loop
 611 
                                break; // end while loop
606 
                        }
 612 
                        }
607 
                }
 613 
                }
608 
        }
 614 
        }
609 
}
 615 
}
610 
 
 616 
 
611 
/**************************************************************/
 617 
/**************************************************************/
612 
/* Send the answers to incomming commands at the debug uart   */
 618 
/* Send the answers to incomming commands at the debug uart   */
613 
/**************************************************************/
 619 
/**************************************************************/
614 
void UART1_TransmitTxData(void)
 620 
void UART1_TransmitTxData(void)
615 
{
 621 
{
616 
        if(DebugUART != UART1) return;
 622 
        if(DebugUART != UART1) return;
- 
 
 623 
 
- 
 
 624 
        if(CheckDelay(UART1_AboTimeOut))
- 
 
 625 
        {
- 
 
 626 
                UART1_DebugData_Interval = 0;
- 
 
 627 
                UART1_NaviData_Interval = 0;
- 
 
 628 
                UART1_Data3D_Interval = 0;
- 
 
 629 
                UART1_Display_Interval = 0;
- 
 
 630 
        }
- 
 
 631 
 
617 
        UART1_Transmit(); // output pending bytes in tx buffer
 632 
        UART1_Transmit(); // output pending bytes in tx buffer
618 
        if((UART1_tx_buffer.Locked == TRUE)) return;
 633 
        if((UART1_tx_buffer.Locked == TRUE)) return;
619 
 
 634 
 
620 
        if(UART1_Request_Parameter && (UART1_tx_buffer.Locked == FALSE))
 635 
        if(UART1_Request_Parameter && (UART1_tx_buffer.Locked == FALSE))
621 
        {
 636 
        {
622 
                s16 ParamValue;
 637 
                s16 ParamValue;
623 
                NCParams_GetValue(UART1_Request_ParameterId, &ParamValue);
 638 
                NCParams_GetValue(UART1_Request_ParameterId, &ParamValue);
624 
                //sprintf(text, "\r\nId=%d, value = %d\r\n", UART1_Request_ParameterId, ParamValue);
 639 
                //sprintf(text, "\r\nId=%d, value = %d\r\n", UART1_Request_ParameterId, ParamValue);
625 
                //UART1_PutString(text);
 640 
                //UART1_PutString(text);
626 
                MKProtocol_CreateSerialFrame(&UART1_tx_buffer, 'J', NC_ADDRESS, 2, &UART1_Request_ParameterId, sizeof(UART1_Request_ParameterId), &ParamValue, sizeof(ParamValue)); // answer the param request
 641 
                MKProtocol_CreateSerialFrame(&UART1_tx_buffer, 'J', NC_ADDRESS, 2, &UART1_Request_ParameterId, sizeof(UART1_Request_ParameterId), &ParamValue, sizeof(ParamValue)); // answer the param request
627 
                UART1_Request_Parameter = FALSE;
 642 
                UART1_Request_Parameter = FALSE;
628 
        }
 643 
        }
629 
        else if(UART1_Request_Echo && (UART1_tx_buffer.Locked == FALSE))
 644 
        else if(UART1_Request_Echo && (UART1_tx_buffer.Locked == FALSE))
630 
        {
 645 
        {
631 
                MKProtocol_CreateSerialFrame(&UART1_tx_buffer, 'Z', NC_ADDRESS, 1, &Echo, sizeof(Echo)); // answer the echo request
 646 
                MKProtocol_CreateSerialFrame(&UART1_tx_buffer, 'Z', NC_ADDRESS, 1, &Echo, sizeof(Echo)); // answer the echo request
632 
                Echo = 0; // reset echo value
 647 
                Echo = 0; // reset echo value
633 
                UART1_Request_Echo = FALSE;
 648 
                UART1_Request_Echo = FALSE;
634 
        }
 649 
        }
635 
        else if(UART1_Request_NewWaypoint && (UART1_tx_buffer.Locked == FALSE))
 650 
        else if(UART1_Request_NewWaypoint && (UART1_tx_buffer.Locked == FALSE))
636 
        {
 651 
        {
637 
                u8 WPNumber = WPList_GetCount();
 652 
                u8 WPNumber = WPList_GetCount();
638 
                MKProtocol_CreateSerialFrame(&UART1_tx_buffer, 'W', NC_ADDRESS, 1, &WPNumber, sizeof(WPNumber));
 653 
                MKProtocol_CreateSerialFrame(&UART1_tx_buffer, 'W', NC_ADDRESS, 1, &WPNumber, sizeof(WPNumber));
639 
                UART1_Request_NewWaypoint = FALSE;
 654 
                UART1_Request_NewWaypoint = FALSE;
640 
        }
 655 
        }
641 
        else if((UART1_Request_ReadWaypoint != 0xFF) && (UART1_tx_buffer.Locked == FALSE))
 656 
        else if((UART1_Request_ReadWaypoint != 0xFF) && (UART1_tx_buffer.Locked == FALSE))
642 
        {
 657 
        {
643 
                u8 WPNumber = WPList_GetCount();
 658 
                u8 WPNumber = WPList_GetCount();
644 
                if (UART1_Request_ReadWaypoint < WPNumber)
 659 
                if (UART1_Request_ReadWaypoint < WPNumber)
645 
                {
 660 
                {
646 
                        MKProtocol_CreateSerialFrame(&UART1_tx_buffer, 'X', NC_ADDRESS, 3, &WPNumber, 1, &UART1_Request_ReadWaypoint, 1, WPList_GetAt(UART1_Request_ReadWaypoint), sizeof(Waypoint_t));
 661 
                        MKProtocol_CreateSerialFrame(&UART1_tx_buffer, 'X', NC_ADDRESS, 3, &WPNumber, 1, &UART1_Request_ReadWaypoint, 1, WPList_GetAt(UART1_Request_ReadWaypoint), sizeof(Waypoint_t));
647 
                }
 662 
                }
648 
                else
 663 
                else
649 
                {
 664 
                {
650 
                        MKProtocol_CreateSerialFrame(&UART1_tx_buffer,'X', NC_ADDRESS, 1, &WPNumber, sizeof(WPNumber));
 665 
                        MKProtocol_CreateSerialFrame(&UART1_tx_buffer,'X', NC_ADDRESS, 1, &WPNumber, sizeof(WPNumber));
651 
                }
 666 
                }
652 
                UART1_Request_ReadWaypoint = 0xFF;
 667 
                UART1_Request_ReadWaypoint = 0xFF;
653 
        }
 668 
        }
654 
        else if((UART1_Request_DebugLabel != 0xFF) && (UART1_tx_buffer.Locked == FALSE))
 669 
        else if((UART1_Request_DebugLabel != 0xFF) && (UART1_tx_buffer.Locked == FALSE))
655 
        {
 670 
        {
656 
                MKProtocol_CreateSerialFrame(&UART1_tx_buffer, 'A', NC_ADDRESS, 2, &UART1_Request_DebugLabel, sizeof(UART1_Request_DebugLabel), (u8 *) ANALOG_LABEL[UART1_Request_DebugLabel], 16);
 671 
                MKProtocol_CreateSerialFrame(&UART1_tx_buffer, 'A', NC_ADDRESS, 2, &UART1_Request_DebugLabel, sizeof(UART1_Request_DebugLabel), (u8 *) ANALOG_LABEL[UART1_Request_DebugLabel], 16);
657 
                UART1_Request_DebugLabel = 0xFF;
 672 
                UART1_Request_DebugLabel = 0xFF;
658 
        }
 673 
        }
659 
        else if(( ((UART1_NaviData_Interval > 0) && CheckDelay(UART1_NaviData_Timer) ) || UART1_Request_NaviData) && (UART1_tx_buffer.Locked == FALSE))
 674 
        else if(( ((UART1_NaviData_Interval > 0) && CheckDelay(UART1_NaviData_Timer) ) || UART1_Request_NaviData) && (UART1_tx_buffer.Locked == FALSE))
660 
        {
 675 
        {
661 
                NaviData.Errorcode = ErrorCode;
 676 
                NaviData.Errorcode = ErrorCode;
662 
                MKProtocol_CreateSerialFrame(&UART1_tx_buffer, 'O', NC_ADDRESS,1, (u8 *)&NaviData, sizeof(NaviData));
 677 
                MKProtocol_CreateSerialFrame(&UART1_tx_buffer, 'O', NC_ADDRESS,1, (u8 *)&NaviData, sizeof(NaviData));
663 
                UART1_NaviData_Timer = SetDelay(UART1_NaviData_Interval);
 678 
                UART1_NaviData_Timer = SetDelay(UART1_NaviData_Interval);
664 
                UART1_Request_NaviData = FALSE;
 679 
                UART1_Request_NaviData = FALSE;
665 
        }
 680 
        }
666 
        else if( (( (UART1_DebugData_Interval > 0) && CheckDelay(UART1_DebugData_Timer)) || UART1_Request_DebugData) && (UART1_tx_buffer.Locked == FALSE))
 681 
        else if( (( (UART1_DebugData_Interval > 0) && CheckDelay(UART1_DebugData_Timer)) || UART1_Request_DebugData) && (UART1_tx_buffer.Locked == FALSE))
667 
        {
 682 
        {
668 
                MKProtocol_CreateSerialFrame(&UART1_tx_buffer, 'D', NC_ADDRESS, 1,(u8 *)&DebugOut, sizeof(DebugOut));
 683 
                MKProtocol_CreateSerialFrame(&UART1_tx_buffer, 'D', NC_ADDRESS, 1,(u8 *)&DebugOut, sizeof(DebugOut));
669 
                UART1_DebugData_Timer = SetDelay(UART1_DebugData_Interval);
 684 
                UART1_DebugData_Timer = SetDelay(UART1_DebugData_Interval);
670 
                UART1_Request_DebugData = FALSE;
 685 
                UART1_Request_DebugData = FALSE;
671 
        }
 686 
        }
672 
        else if((( (UART1_Data3D_Interval > 0) && CheckDelay(UART1_Data3D_Timer) ) || UART1_Request_Data3D) && (UART1_tx_buffer.Locked == FALSE))
 687 
        else if((( (UART1_Data3D_Interval > 0) && CheckDelay(UART1_Data3D_Timer) ) || UART1_Request_Data3D) && (UART1_tx_buffer.Locked == FALSE))
673 
        {
 688 
        {
674 
                MKProtocol_CreateSerialFrame(&UART1_tx_buffer, 'C', NC_ADDRESS, 1,(u8 *)&Data3D, sizeof(Data3D));
 689 
                MKProtocol_CreateSerialFrame(&UART1_tx_buffer, 'C', NC_ADDRESS, 1,(u8 *)&Data3D, sizeof(Data3D));
675 
                UART1_Data3D_Timer = SetDelay(UART1_Data3D_Interval);
 690 
                UART1_Data3D_Timer = SetDelay(UART1_Data3D_Interval);
676 
                UART1_Request_Data3D = FALSE;
 691 
                UART1_Request_Data3D = FALSE;
677 
        }
 692 
        }
678 
        /*
 693 
        /*
679 
        else if(UART1_ConfirmFrame && (UART1_tx_buffer.Locked == FALSE))
 694 
        else if(UART1_ConfirmFrame && (UART1_tx_buffer.Locked == FALSE))
680 
        {
 695 
        {
681 
                MKProtocol_CreateSerialFrame(&UART1_tx_buffer, 'B', NC_ADDRESS, 1, &UART1_ConfirmFrame, sizeof(UART1_ConfirmFrame));
 696 
                MKProtocol_CreateSerialFrame(&UART1_tx_buffer, 'B', NC_ADDRESS, 1, &UART1_ConfirmFrame, sizeof(UART1_ConfirmFrame));
682 
                UART1_ConfirmFrame = 0;
 697 
                UART1_ConfirmFrame = 0;
683 
        }
 698 
        }
684 
        */
 699 
        */
685 
        /*
 700 
        /*
686 
        else if(UART1_Request_ExternalControl && (UART1_tx_buffer.Locked == FALSE))
 701 
        else if(UART1_Request_ExternalControl && (UART1_tx_buffer.Locked == FALSE))
687 
        {
 702 
        {
688 
                MKProtocol_CreateSerialFrame(&UART1_tx_buffer, 'G', NC_ADDRESS, 1, (u8 *)&ExternControl, sizeof(ExternControl));
 703 
                MKProtocol_CreateSerialFrame(&UART1_tx_buffer, 'G', NC_ADDRESS, 1, (u8 *)&ExternControl, sizeof(ExternControl));
689 
                UART1_Request_ExternalControl = FALSE;
 704 
                UART1_Request_ExternalControl = FALSE;
690 
        }
 705 
        }
691 
        */
 706 
        */
692 
        else if( (( (UART1_Display_Interval > 0) && CheckDelay(UART1_Display_Timer)) || UART1_Request_Display) && (UART1_tx_buffer.Locked == FALSE))
 707 
        else if( (( (UART1_Display_Interval > 0) && CheckDelay(UART1_Display_Timer)) || UART1_Request_Display) && (UART1_tx_buffer.Locked == FALSE))
693 
        {
 708 
        {
694 
                if(UART1_DisplayLine > 3)
 709 
                if(UART1_DisplayLine > 3)
695 
                {
 710 
                {
696 
                        LCD_PrintMenu();
 711 
                        LCD_PrintMenu();
697 
                        MKProtocol_CreateSerialFrame(&UART1_tx_buffer, 'H', NC_ADDRESS, 1, (u8*)DisplayBuff, sizeof(DisplayBuff));
 712 
                        MKProtocol_CreateSerialFrame(&UART1_tx_buffer, 'H', NC_ADDRESS, 1, (u8*)DisplayBuff, sizeof(DisplayBuff));
698 
                }
 713 
                }
699 
                else
 714 
                else
700 
                {
 715 
                {
701 
                        UART1_DisplayLine = 2;
 716 
                        UART1_DisplayLine = 2;
702 
                        sprintf(text,"!!! incompatible !!!");
 717 
                        sprintf(text,"!!! incompatible !!!");
703 
                        MKProtocol_CreateSerialFrame(&UART1_tx_buffer, 'H', NC_ADDRESS, 2, &UART1_DisplayLine, sizeof(UART1_DisplayLine), (u8*)&text, 20);
 718 
                        MKProtocol_CreateSerialFrame(&UART1_tx_buffer, 'H', NC_ADDRESS, 2, &UART1_DisplayLine, sizeof(UART1_DisplayLine), (u8*)&text, 20);
704 
                        if(UART1_DisplayLine++ > 3) UART1_DisplayLine = 0;
 719 
                        if(UART1_DisplayLine++ > 3) UART1_DisplayLine = 0;
705 
                }
 720 
                }
706 
                UART1_Display_Timer = SetDelay(UART1_Display_Interval);
 721 
                UART1_Display_Timer = SetDelay(UART1_Display_Interval);
707 
                UART1_Request_Display = FALSE;
 722 
                UART1_Request_Display = FALSE;
708 
        }
 723 
        }
709 
        else if(UART1_Request_Display1 && (UART1_tx_buffer.Locked == FALSE))
 724 
        else if(UART1_Request_Display1 && (UART1_tx_buffer.Locked == FALSE))
710 
        {
 725 
        {
711 
                LCD_PrintMenu();
 726 
                LCD_PrintMenu();
712 
                MKProtocol_CreateSerialFrame(&UART1_tx_buffer, 'L', NC_ADDRESS, 3, (u8*)&MenuItem, sizeof(MenuItem), (u8*)&MaxMenuItem, sizeof(MaxMenuItem),(u8*)DisplayBuff, sizeof(DisplayBuff));
 727 
                MKProtocol_CreateSerialFrame(&UART1_tx_buffer, 'L', NC_ADDRESS, 3, (u8*)&MenuItem, sizeof(MenuItem), (u8*)&MaxMenuItem, sizeof(MaxMenuItem),(u8*)DisplayBuff, sizeof(DisplayBuff));
713 
                UART1_Request_Display1 = FALSE;
 728 
                UART1_Request_Display1 = FALSE;
714 
        }
 729 
        }
715 
        else if(UART1_Request_VersionInfo && (UART1_tx_buffer.Locked == FALSE))
 730 
        else if(UART1_Request_VersionInfo && (UART1_tx_buffer.Locked == FALSE))
716 
        {
 731 
        {
717 
                MKProtocol_CreateSerialFrame(&UART1_tx_buffer, 'V', NC_ADDRESS,1, (u8 *)&UART_VersionInfo, sizeof(UART_VersionInfo));
 732 
                MKProtocol_CreateSerialFrame(&UART1_tx_buffer, 'V', NC_ADDRESS,1, (u8 *)&UART_VersionInfo, sizeof(UART_VersionInfo));
718 
                UART1_Request_VersionInfo = FALSE;
 733 
                UART1_Request_VersionInfo = FALSE;
719 
        }
 734 
        }
720 
        else if(UART1_Request_ErrorMessage && (UART1_tx_buffer.Locked == FALSE))
 735 
        else if(UART1_Request_ErrorMessage && (UART1_tx_buffer.Locked == FALSE))
721 
        {
 736 
        {
722 
                MKProtocol_CreateSerialFrame(&UART1_tx_buffer, 'E', NC_ADDRESS, 1, (u8 *)&ErrorMSG, sizeof(ErrorMSG));
 737 
                MKProtocol_CreateSerialFrame(&UART1_tx_buffer, 'E', NC_ADDRESS, 1, (u8 *)&ErrorMSG, sizeof(ErrorMSG));
723 
                UART1_Request_ErrorMessage = FALSE;
 738 
                UART1_Request_ErrorMessage = FALSE;
724 
        }
 739 
        }
725 
        else if(UART1_Request_SendFollowMe && (UART1_tx_buffer.Locked == FALSE) && (GPSData.NumOfSats >= 4))              // sending for "Follow me"
 740 
        else if(UART1_Request_SendFollowMe && (UART1_tx_buffer.Locked == FALSE) && (GPSData.NumOfSats >= 4))              // sending for "Follow me"
726 
        {
 741 
        {
727 
                GPS_CopyPosition(&(GPSData.Position),&(FollowMe.Position));
 742 
                GPS_CopyPosition(&(GPSData.Position),&(FollowMe.Position));
728 
                FollowMe.Position.Status = NEWDATA;
 743 
                FollowMe.Position.Status = NEWDATA;
729 
                FollowMe.Heading = -1;
 744 
                FollowMe.Heading = -1;
730 
                FollowMe.ToleranceRadius = 1;
 745 
                FollowMe.ToleranceRadius = 1;
731 
                FollowMe.HoldTime = 60;
 746 
                FollowMe.HoldTime = 60;
732 
                FollowMe.Event_Flag = 0;
 747 
                FollowMe.Event_Flag = 0;
733 
                FollowMe.Index = 1;
 748 
                FollowMe.Index = 1;
734 
                FollowMe.reserve[0] = 0;                // reserve
 749 
                FollowMe.reserve[0] = 0;                // reserve
735 
                FollowMe.reserve[1] = 0;                // reserve
 750 
                FollowMe.reserve[1] = 0;                // reserve
736 
                FollowMe.reserve[2] = 0;                // reserve
 751 
                FollowMe.reserve[2] = 0;                // reserve
737 
                FollowMe.reserve[3] = 0;                // reserve
 752 
                FollowMe.reserve[3] = 0;                // reserve
738 
                MKProtocol_CreateSerialFrame(&UART1_tx_buffer, 's', NC_ADDRESS, 1, (u8 *)&FollowMe, sizeof(FollowMe));
 753 
                MKProtocol_CreateSerialFrame(&UART1_tx_buffer, 's', NC_ADDRESS, 1, (u8 *)&FollowMe, sizeof(FollowMe));
739 
                UART1_Request_SendFollowMe = FALSE;
 754 
                UART1_Request_SendFollowMe = FALSE;
740 
        }
 755 
        }
741 
        UART1_Transmit(); // output pending bytes in tx buffer
 756 
        UART1_Transmit(); // output pending bytes in tx buffer
742 
}
 757 
}
743 
 
 758 
 
744 
 
 759