WebSVN - Projects - Blame - Rev 1934 - /Transportables_Koptertool/branch/PKT/branch/GPL_PKT_V3_6_7f

Rev	Author	Line No.	Line
1932	-	1	/*****************************************************************************
		2	* Copyright (C) 2008 Thomas Kaiser, thomas@ft-fanpage.de *
		3	* Copyright (C) 2009 Peter "woggle" Mack, mac@denich.net *
		4	* Copyright (C) 2011 Christian "Cebra" Brandtner, brandtner@brandtner.net *
		5	* Copyright (C) 2011 Harald Bongartz *
		6	* *
		7	* This program is free software; you can redistribute it and/or modify *
		8	* it under the terms of the GNU General Public License as published by *
		9	* the Free Software Foundation; either version 2 of the License. *
		10	* *
		11	* This program is distributed in the hope that it will be useful, *
		12	* but WITHOUT ANY WARRANTY; without even the implied warranty of *
		13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
		14	* GNU General Public License for more details. *
		15	* *
		16	* You should have received a copy of the GNU General Public License *
		17	* along with this program; if not, write to the *
		18	* Free Software Foundation, Inc., *
		19	* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
		20	* *
		21	* *
		22	* Credits to: *
		23	* Holger Buss & Ingo Busker from mikrokopter.de for the MK project + SVN *
		24	* http://www.mikrokopter.de *
		25	* Gregor "killagreg" Stobrawa for his version of the MK code *
		26	* Thomas Kaiser "thkais" for the original project. See *
		27	* http://www.ft-fanpage.de/mikrokopter/ *
		28	* http://forum.mikrokopter.de/topic-4061-1.html *
		29	* Claas Anders "CaScAdE" Rathje for providing the font and his C-OSD code *
		30	* http://www.mylifesucks.de/oss/c-osd/ *
		31	* Harald Bongartz "HaraldB" for providing his Ideas and Code for usibility*
		32	*****************************************************************************/
		33
		34	//############################################################################
		35	//# HISTORY osd.c
		36	//#
		37	//# 10.03.2013 OG
		38	//# - fix: doppelte Degree-Anzeige in OSD_Element_CompassDegree()
		39	//# - add: neuer Screen "MK-Status"
		40	//# - add: 7 neue OSD-Flags
		41	//# - chg: Screen-Refresh Zeit via timer2 (einstellbar durch define OSD_REFRESH_TIME)
		42	//# - chg: mit define OSD_DEBUG_SCREEN kann ein zusaetzlicher Screen verwendet werden zum testen/entwickeln
		43	//# - del: entfernt CFG2_HEIGHT_LIMIT in OSD_Element_AltitudeControl() (bis bessere Loesung gefunden ist)
		44	//#
		45	//# 08.03.2013 OG
		46	//# - del: OSD_Screen_Element() und cleanup in osd.h
		47	//# - add: OSD_Element_UpDown() (steigend/sinken via Pfeilen)
		48	//# - chg: OSD_Element_UpDown() in Screen "General" und "Navigation" hinzugefuegt (rechts neben der Hoehenanzeige)
		49	//# - chg: Screen "General" die Sat-Warnung wurde auf OSD_Element_Flag(OSD_FLAG_S0) geaendert
		50	//# - chg: Anzeige von Flag 'nicht genug GPS-Sateliten' (OSD_FLAG_S0) auf "S!" ge�ndert
		51	//#
		52	//# 07.03.2013 OG
		53	//# - Hinweis bzgl. LowBatt-Anzeige in den Screens "General" und "Navigation":
		54	//# Es gibt zwei unabh�ngige LowBatt-Warnungen.
		55	//# 1. die PKT LowBatt-Warnung: sie arbeitet mit der im PKT hinterlegten
		56	//# LowBatt Spannung und stellt den Spannungswert inkl. der Einheit "V"
		57	//# invers dar wenn der Warnwert erreicht wurde (inkl. lautem PKT-Peepen)
		58	//# 2. die MK-LowBatt Warnung: hierbeit wird das Flag "BA" angezeigt wenn
		59	//# der MK eine LowBatt Warnung sendet
		60	//# Dadurch hat man nun zwei verschiedene LowBatt Warnungen die man auf Wunsch
		61	//# verschieden einstellen kann. Bei mir ist die PKT-LowBatt etwas niedriger
		62	//# eingestellt als die MK-Warnung und bedeutet "es ist aller hoechste Zeit zu landen".
		63	//# Die Spannung der MK-LowBat ist ein wenig hoeher eingestellt und
		64	//# zeigt mir "es ist bald Zeit zu landen".
		65	//# - del: Kommunikation zu FC - siehe Kommentare in osd()
		66	//# - chg: Kommunikation zu NC - siehe Kommentare in osd()
		67	//# - add: neuer Screen "Navigation"
		68	//# - chg: Layout Screen "Statistics" - Einheiten um zwei Pixel nach rechts verschoben
		69	//# - chg: Layout von Screen "General" modifiziert (u.a. xoffs,yoffs Pixelverschiebungen)
		70	//# - add: OSD_FLAG_BA in Screen "General"
		71	//# - add: die OSD_Element_xyz() Funktionen in osd.h aufgenommen
		72	//# - chg: an verschiedenen Stellen die Char-Drawmode defines MNORMAL, MINVERS, usw. eingebaut
		73	//# - del: Kompatibilitaetscode fuer "3D-Lage" ueber Hauptmenue entfernt
		74	//# - chg: die Funktionen OSD_Element_Switch() und OSD_Element_SwitchLabel() heissen
		75	//# nun OSD_Element_Flag() und OSD_Element_Flag_Label()
		76	//# - chg: die defines OSD_SWITCH_xy heissen jetzt OSD_FLAG_xy
		77	//# - fix: letzte GPS-Koordinaten werden jetzt permanent Config.LastLatitude, Config.LastLongitude gespeichert
		78	//#
		79	//# 03.03.2013 OG
		80	//# - add: delay in Mainloop von osd() um springende Werte abzudaempfen (TEST)
		81	//# - add: Startverzoegerung der Screens bis NaviData sich etwas stabilisiert hat (TEST)
		82	//# - add: OSD Startup Message "connecting MK..."
		83	//# - add: 'Emergency Landing' (EL) Anzeige in Screen "General"
		84	//# - del: OUT1/OUT2 Anzeige in Screen "General"
		85	//# - add: RC-Quality in Screen "General"
		86	//# - add: func: draw_symbol_rc() (alternative RC-Quality Symbol)
		87	//# - fix: Hoehenanzeige fuer Screens "OSD0" und "OSD1"
		88	//# - fix: OSD_Element_SwitchLabel() angepasst fuer x=0 und y=0
		89	//# - add: OSD_Element_Switch/Label() erweitert um OSD_SWITCH_FS
		90	//# - fix: Screen-Redraw nach OSD_Timeout() und anderen Fehlermeldungen
		91	//# - chg: messages.c: STATS_ITEM_0 bis STATS_ITEM_6 angepasst (1 char kuerzer)
		92	//# - chg: Layout von OSD_Info() - mehr background-clear und etwas kleiner
		93	//#
		94	//# 02.03.2013 OG
		95	//# - chg: keine internal func in Screen's wegen warnings bei anderen
		96	//# - del: Screen "OSD3"
		97	//# - fix: Hoehenanzeige in Screen "General" (Minuszeichen)
		98	//# - add: MK LowBat Warning in Screen "General"
		99	//# - add: neues Degree Symbol (als func) in Screen General (kleiner als das Char 0x1E)
		100	//# - add: weitere Flags in OSD_Element_Flag()
		101	//#
		102	//# 01.03.2013 OG
		103	//# - Reskrukturierung Code (+ neuer OSD-Screens und einiges mehr)
		104	//############################################################################
		105
		106
		107	//############################################################################
		108	//# HINWEISE:
		109	//#
		110	//# 1. define: OSD_DEMO
		111	//# mit define OSD_DEMO wird ein Demo-Modus bei den neuen Screens einge-
		112	//# schaltet - damit werden u.a. alle Flag's angezeigt fuer Scree-Fotos
		113	//#
		114	//# 2. define: OSD_DEBUG_SCREEN
		115	//# mit diesem define wird ein zusaetzlicher Screen "Debug" einkompiliert
		116	//# fuer Test / Experimente / Debug von OSD-Elementen
		117	//#
		118	//# 3. Informationen zum Display
		119	//# DOG: 128 x 64 Pixel with 6x8 Font => 21 x 8
		120	//############################################################################
		121
		122
		123	#include "../cpu.h"
		124	#include <avr/io.h>
		125	#include <inttypes.h>
		126	#include <stdlib.h>
		127	#include <avr/pgmspace.h>
		128	#include <util/delay.h>
		129
		130	#include "../main.h"
		131	#include "../osd/osd.h"
		132	#include "../lcd/lcd.h"
		133	#include "../timer/timer.h"
		134	#include "../uart/usart.h"
		135	#include "../eeprom/eeprom.h"
		136	#include "../messages.h"
		137	#include "../parameter.h"
		138	#include "../sound/pwmsine8bit.h"
		139	#include "../mk-data-structs.h"
		140
		141
		142	//#define OSD_DEMO // zeigt Demo-Daten in den OSD-Screens (sofern vom Screen unterstuetzt)
		143	//#define OSD_DEBUG_SCREEN // zusaetzlichen Debug-Screen aktivieren
		144
		145	#define OSD_REFRESH_TIME 45 // Screen Refresh; ein Wert von 100 entspricht ca. 1 Sekunde (Steuerung via timer2)
		146
		147	#define COSD_WASFLYING 4
		148	#define TIMEOUT 200 // 2 sec
		149
		150
		151	// Hier H�henanzeigefehler Korrigieren
		152	#define AltimeterAdjust 1.5
		153
		154
		155	// global definitions and global vars
		156	NaviData_t *naviData;
		157	mk_param_struct_t *mk_param_struct;
		158	uint8_t Flags_ExtraConfig;
		159	uint8_t Flags_GlobalConfig;
		160	uint8_t Flags_GlobalConfig3;
		161	unsigned char Element;
		162	uint16_t heading_home;
		163	uint8_t drawmode;
		164
		165	// flags from last round to check for changes
		166	uint8_t old_FCFlags = 0;
		167	uint8_t old_AngleNick = 0;
		168	uint8_t old_AngleRoll = 0;
		169	uint16_t old_hh = 0;
		170
		171	// stats for after flight
		172	int16_t max_Altimeter = 0;
		173	uint16_t max_GroundSpeed = 0;
		174	int16_t max_Distance = 0;
		175	uint8_t min_UBat = 255;
		176	uint16_t max_FlyingTime = 0;
		177	uint16_t max_Current = 0;
		178	uint16_t max_Capacity = 0;
		179
		180	// cache old vars for blinking attribute, checkup is faster than full
		181	// attribute write each time
		182	volatile uint8_t last_UBat = 255;
		183	volatile uint8_t last_RC_Quality = 255;
		184
		185	volatile uint16_t ftimer = 0;
		186	volatile uint8_t OSD_active;
		187
		188	uint8_t Vario_Beep_Up = 0;
		189	uint8_t Vario_Beep_Down = 0;
		190	uint8_t Vario_Beep_Up_Interval = 9;
		191	uint8_t Vario_Beep_Down_Interval = 6;
		192	uint8_t Vario_Threshold = 0;
		193	uint8_t Vario_Threshold_Value = 7;
		194	uint8_t OldWP = 0;
		195	uint8_t NextWP = 0;
		196
		197
		198
		199	//char* rose = "-+-N-+-O-+-S-+-W-+-N-+-O-+-S-+-W-+-N-+-O-+-S-+-W";
		200	const char rose[48] PROGMEM = {
		201	0x0e, 0x0f, 0x0e, 'N', 0x0e, 0x0f, 0x0e, 'O', 0x0e, 0x0f, 0x0e, 'S',
		202	0x0e, 0x0f, 0x0e, 'W', 0x0e, 0x0f, 0x0e, 'N', 0x0e, 0x0f, 0x0e, 'O',
		203	0x0e, 0x0f, 0x0e, 'S', 0x0e, 0x0f, 0x0e, 'W', 0x0e, 0x0f, 0x0e, 'N',
		204	0x0e, 0x0f, 0x0e, 'O', 0x0e, 0x0f, 0x0e, 'S', 0x0e, 0x0f, 0x0e, 'W',
		205	};
		206
		207	// the center is char 19 (north), we add the current heading in 8th
		208	// which would be 22.5 degrees, but float would bloat up the code
		209	// and *10 / 225 would take ages... so we take the uncorrect way
		210
		211	const char str_NE[] PROGMEM = "NE";
		212	const char str_E[] PROGMEM = "E ";
		213	const char str_SE[] PROGMEM = "SE";
		214	const char str_S[] PROGMEM = "S ";
		215	const char str_SW[] PROGMEM = "SW";
		216	const char str_W[] PROGMEM = "W ";
		217	const char str_NW[] PROGMEM = "NW";
		218	const char str_N[] PROGMEM = "N ";
		219	const char *directions_p[8] PROGMEM = {
		220	str_NE,
		221	str_E,
		222	str_SE,
		223	str_S,
		224	str_SW,
		225	str_W,
		226	str_NW,
		227	str_N
		228	};
		229
		230
		231	#define MAX_CELL_VOLTAGE 43 // max cell voltage for LiPO
		232	#define MIN_CELL_VOLTAGE 32 // min cell voltage for LiPO
		233
		234	// Flags
		235	GPS_Pos_t last5pos[7];
		236	uint8_t COSD_FLAGS2 = 0;
		237	volatile uint8_t error = 0;
		238	uint8_t cells = 0;
		239	uint8_t BattLowVoltageWarning = 0;
		240	uint8_t CellIsChecked = 0;
		241	uint8_t AkkuWarnThreshold = 0;
		242	uint16_t duration = 0;
		243
		244
		245
		246	//###########################################################
		247	//###########################################################
		248
		249	//--------------------------------------------------------------
		250	//--------------------------------------------------------------
		251	void variobeep(int16_t vario)
		252	{
		253	{ //start Beep
		254
		255	if (vario >0 ) // MK steigt
		256	{
		257	Vario_Beep_Down = 0; // Down Beep freischalten
		258	Vario_Threshold++;
		259
		260	if ((Vario_Beep_Up == 0) && (Vario_Threshold >= Vario_Threshold_Value))
		261	{
		262	// set_beep ( 100, 0xffff, BeepNormal);
		263	duration = 52 -vario;
		264	// if (duration =0); duration = 1;
		265
		266	// write_ndigit_number_u (0,6,duration,5,0);
		267
		268	playTone(300+vario*2,duration,Config.Volume);
		269	// playTone(300,duration,volume);
		270	Vario_Threshold = Vario_Threshold_Value; // auf Maximalwert begrenzen
		271	}
		272	Vario_Beep_Up++; // Interval hochz�hlen in dem nicht gepiept wird
		273	if (Vario_Beep_Up == Vario_Beep_Up_Interval) Vario_Beep_Up = 0;
		274	}
		275
		276	if (vario <0) // MK f�llt
		277	{
		278	Vario_Beep_Up = 0; // Up Beep freischalten
		279	Vario_Threshold++;
		280	if ((Vario_Beep_Down == 0) && (Vario_Threshold >= Vario_Threshold_Value))
		281	{
		282	duration = 50 -vario;
		283	// write_ndigit_number_u (0,7,duration,5,0);
		284	// if (duration < vario) ; duration = 0;
		285	// playTone(300,50,volume);
		286
		287
		288	playTone(300+vario*2,duration,Config.Volume);
		289	Vario_Threshold = Vario_Threshold_Value; // auf Maximalwert begrenzen
		290	}
		291	Vario_Beep_Down++; // Interval hochz�hlen in dem nicht gepiept wird
		292	if (Vario_Beep_Down == Vario_Beep_Down_Interval) Vario_Beep_Down = 0;
		293	}
		294
		295	if (vario == 0) Vario_Threshold = 0; //Startverz�gerung l�schen
		296	} // end Beep
		297
		298	}
		299
		300
		301	//--------------------------------------------------------------
		302	// Diese Funktion Beept unabhaengig von der Einstellung Config.OSD_VarioBeep
		303	// Aufruf ggf. mit: if( Config.OSD_VarioBeep ) Beep_Vario();
		304	//
		305	// Ansonten:
		306	// -> hier noch aufr�umen in Zusammenhang mit func variobeep()
		307	//--------------------------------------------------------------
		308	void Beep_Vario(void)
		309	{
		310	if ( (naviData->FCStatusFlags & FC_STATUS_MOTOR_RUN) && (naviData->FCStatusFlags2 & FC_STATUS2_ALTITUDE_CONTROL))
		311	{ //start Beep
		312	if (naviData->Variometer <0) // MK f�llt
		313	{
		314	Vario_Beep_Up = 0; // Up Beep freischalten
		315	Vario_Threshold++;
		316	if ((Vario_Beep_Down == 0) && (Vario_Threshold >= Vario_Threshold_Value))
		317	{
		318
		319	if (!Config.HWSound) set_beep ( 300, 0xffff, BeepNormal);
		320	else variobeep(naviData->Variometer);
		321
		322	Vario_Threshold = Vario_Threshold_Value; // auf Maximalwert begrenzen
		323	}
		324	Vario_Beep_Down++; // Interval hochz�hlen in dem nicht gepiept wird
		325	if (Vario_Beep_Down == Vario_Beep_Down_Interval) Vario_Beep_Down = 0;
		326	}
		327
		328	if (naviData->Variometer == 0) Vario_Threshold = 0; //Startverz�gerung l�schen
		329
		330	if (naviData->Variometer >0 ) // MK steigt
		331	{
		332	Vario_Beep_Down = 0; // Down Beep freischalten
		333	Vario_Threshold++;
		334
		335	if ((Vario_Beep_Up == 0) && (Vario_Threshold >= Vario_Threshold_Value))
		336	{
		337	if (!Config.HWSound) set_beep ( 100, 0xffff, BeepNormal);
		338	else variobeep(naviData->Variometer);
		339	Vario_Threshold = Vario_Threshold_Value; // auf Maximalwert begrenzen
		340	}
		341	Vario_Beep_Up++; // Interval hochz�hlen in dem nicht gepiept wird
		342	if (Vario_Beep_Up == Vario_Beep_Up_Interval) Vario_Beep_Up = 0;
		343	}
		344	} // end Beep
		345	}
		346
		347
		348
		349	//--------------------------------------------------------------
		350	// Quelle Mikrokopter FC-Software Holger + Ingo
		351	//--------------------------------------------------------------
		352	void CheckMKLipo(void)
		353	{
		354	if(Config.MK_LowBat < 50) // automatische Zellenerkennung
		355	{
		356	if (CellIsChecked <= 2) //Nur beim Start 1x pr�fen
		357	{
		358	// up to 6s LiPo, less than 2s is technical impossible
		359	for(cells = 2; cells < 7; cells++)
		360	{
		361	if(naviData->UBat < cells * MAX_CELL_VOLTAGE) break;
		362	}
		363	BattLowVoltageWarning = cells * Config.MK_LowBat;
		364	CellIsChecked++;
		365	}
		366	}
		367	else BattLowVoltageWarning = Config.MK_LowBat;
		368
		369	if (naviData->UBat < BattLowVoltageWarning)
		370	{
		371	if (AkkuWarnThreshold <= 4) AkkuWarnThreshold++;
		372	else
		373	{ //Beeper ein
		374	set_beep ( 1000, 0x0020, BeepSevere);
		375	// BeepTime = 3000;
		376	// BeepMuster = 0x0020;
		377	}
		378	}
		379	}
		380
		381
		382	//--------------------------------------------------------------
		383	// convert the <heading> gotton from NC into an index
		384	uint8_t heading_conv (uint16_t heading)
		385	{
		386	if (heading > 23 && heading < 68)
		387	return 0; //direction = "NE";
		388	else if (heading > 67 && heading < 113)
		389	return 1; //direction = "E ";
		390	else if (heading > 112 && heading < 158)
		391	return 2; //direction = "SE";
		392	else if (heading > 157 && heading < 203)
		393	return 3; //direction = "S ";
		394	else if (heading > 202 && heading < 248)
		395	return 4; //direction = "SW";
		396	else if (heading > 247 && heading < 293)
		397	return 5; //direction = "W ";
		398	else if (heading > 292 && heading < 338)
		399	return 6; //direction = "NW";
		400
		401	return 7; //direction = "N ";
		402	}
		403
		404
		405	//--------------------------------------------------------------
		406	// draw a compass rose at <x>/<y> for <heading>
		407	void draw_compass (uint8_t x, uint8_t y, uint16_t heading)
		408	{
		409	uint8_t front = 19 + (heading / 22);
		410	for (uint8_t i = 0; i < 9; i++)
		411	lcd_putc (x++, y, pgm_read_byte(&rose[front - 4 + i]), 0);
		412	}
		413
		414
		415	//--------------------------------------------------------------
		416	// variometer
		417	// x, y in Pixel!
		418	//--------------------------------------------------------------
		419	void draw_variometer (uint8_t x, uint8_t y, uint8_t width, uint8_t hight, int16_t variometer)
		420	{
		421	lcd_rect (x, y - ((hight) / 2), width, hight, 1);
		422	lcd_frect (x + 1, y - ((hight) / 2) + 1, width - 2, hight - 2, 0);
		423	lcd_line (x, y, x + width, y, 1);
		424
		425	if (variometer > 0) // steigend
		426	{
		427	switch (variometer / 5)
		428	{
		429	case 0:
		430	lcd_line (x + 4, y - 1, x + 6, y - 1, 1); // 1 > 4
		431	break;
		432
		433	case 1:
		434	lcd_line (x + 4, y - 1, x + 6, y - 1, 1); // 1 > 4
		435	lcd_frect (x + 3, y - 3, 4, 1, 1); // 5 > 9
		436	break;
		437
		438	case 2:
		439	lcd_line (x + 4, y - 1, x + 6, y - 1, 1); // 1 > 4
		440	lcd_frect (x + 3, y - 3, 4, 1, 1); // 5 > 9
		441	lcd_frect (x + 2, y - 5, 6, 1, 1); // 10 > 14
		442	break;
		443
		444	default:
		445	lcd_line (x + 4, y - 1, x + 6, y - 1, 1); // 1 > 4
		446	lcd_frect (x + 3, y - 3, 4, 1, 1); // 5 > 9
		447	lcd_frect (x + 2, y - 5, 6, 1, 1); // 10 > 14
		448	lcd_frect (x + 1, y - 6, 8, 1, 1); // 15 >
		449	break;
		450	}
		451	}
		452	else if (variometer < 0) // fallend
		453	{
		454	switch ((variometer) / -5)
		455	{
		456	case 0:
		457	lcd_line (x + 4, y + 1, x + 6, y + 1, 1); // - 1 > - 4
		458	break;
		459
		460	case 1:
		461	lcd_line (x + 4, y + 1, x + 6, y + 1, 1); // - 1 > - 4
		462	lcd_frect (x + 3, y + 2, 4, 1, 1); // - 5 > - 9
		463	break;
		464
		465	case 2:
		466	lcd_line (x + 4, y + 1, x + 6, y + 1, 1); // - 1 > - 4
		467	lcd_frect (x + 3, y + 2, 4, 1, 1); // - 5 > - 9
		468	lcd_frect (x + 2, y + 4, 6, 1, 1); // -10 > -14
		469	break;
		470
		471	default:
		472	lcd_line (x + 4, y + 1, x + 6, y + 1, 1); // - 1 > - 4
		473	lcd_frect (x + 3, y + 2, 4, 1, 1); // - 5 > - 9
		474	lcd_frect (x + 2, y + 4, 6, 1, 1); // -10 > -14
		475	lcd_frect (x + 1, y + 5, 8, 1, 1); // -15 >
		476	break;
		477	}
		478	}
		479	}
		480
		481
		482	//--------------------------------------------------------------
		483	// variometer 2
		484	//
		485	// x, y in Pixel
		486	// x, y top, left
		487	//--------------------------------------------------------------
		488	/*
		489	void draw_variometer2( uint8_t x, uint8_t y, uint8_t width, uint8_t hight, int16_t variometer)
		490	{
		491	uint8_t max = 5; // max: 5 m/sec == 100%
		492
		493	lcd_rect (x, y, width, hight, 1);
		494	lcd_frect(x + 1, y + 1, width - 2, hight - 2, 0);
		495	lcd_line (x, y + ((hight) / 2), x + width, y + ((hight) / 2), 1);
		496
		497	}
		498	*/
		499
		500
		501	//--------------------------------------------------------------
		502	// Home symbol
		503	// draw Homesymbol at <x>/<y>
		504	//--------------------------------------------------------------
		505	void draw_homesymbol (uint8_t x, uint8_t y)
		506	{
		507	x *= 6;
		508	y *= 8;
		509	y += 7;
		510
		511	lcd_plot (x,y-4,1);
		512	lcd_line (x+1,y-1,x+1,y-5,1);
		513	lcd_plot (x+2,y-6,1);
		514	lcd_plot (x+3,y-7,1);
		515	lcd_plot (x+4,y-6,1);
		516	lcd_line (x+5,y-1,x+5,y-5,1);
		517	lcd_plot (x+6,y-4,1);
		518	lcd_plot (x+3,y-1,1);
		519	lcd_plot (x+3,y-2,1);
		520	lcd_line (x+1,y,x+5,y,1);
		521
		522	}
		523
		524	//--------------------------------------------------------------
		525	// Target symbol
		526	// draw Targetsymbol at <x>/<y>
		527	//--------------------------------------------------------------
		528	void draw_targetsymbol (uint8_t x, uint8_t y)
		529	{
		530	x *= 6;
		531	y *= 8;
		532	y += 7;
		533
		534	lcd_circle (x+3, y-3, 4, 1);
		535	lcd_line (x,y-3,x+6,y-3,1);
		536	lcd_line (x+3,y,x+3,y-6,1);
		537	lcd_circle (x+3, y-3, 2, 1);
		538	}
		539
		540
		541	//--------------------------------------------------------------
		542	// Degree symbol
		543	// draw Degreesymbol at <x>/<y>
		544	//
		545	// Ein etwas kleineres Degeree als Char 0x1E
		546	//--------------------------------------------------------------
		547	void draw_symbol_degree (uint8_t x, uint8_t y, int8_t xoffs, int8_t yoffs)
		548	{
		549	x *= 6;
		550	y *= 8;
		551	lcd_rect (x+1+xoffs, y+yoffs, 2, 2, 1);
		552	}
		553
		554
		555	//--------------------------------------------------------------
		556	// RC symbol
		557	// alternatives Symbol fuer RC-Quality
		558	//--------------------------------------------------------------
		559	void draw_symbol_rc (uint8_t x, uint8_t y)
		560	{
		561	x *= 6;
		562	y *= 8;
		563	y += 1;
		564	x += 1;
		565
		566	lcd_plot ( x+3, y+4, 1);
		567	lcd_line ( x+2, y+2, x+4, y+2, 1);
		568	lcd_line ( x+1, y+0, x+5, y+0, 1);
		569	}
		570
		571
		572	//--------------------------------------------------------------
		573	void print_position (void)
		574	{
		575	lcd_cls ();
		576	lcd_puts_at(0, 0, strGet(START_LASTPOS1), 2); // Breitengr L�ngengr
		577	lcd_puts_at(12, 7, strGet(ENDE), 0);
		578	uint8_t ij =0;
		579
		580	for(ij=0;ij<6;ij++)
		581	{
		582	uint32_t lon = last5pos[ij].Latitude;
		583	write_ndigit_number_u (1, ij+1, (uint16_t)(lon/10000000), 2, 0,0);
		584	lcd_printp_at (3, ij+1, PSTR("."), 0);
		585	write_ndigit_number_u (4, ij+1, (uint16_t)((lon/1000) % 10000), 4, 1,0);
		586	write_ndigit_number_u (8, ij+1, (uint16_t)((lon/10) % 100), 2, 1,0);
		587
		588	uint32_t lat = last5pos[ij].Longitude;
		589	write_ndigit_number_u (12, ij+1, (uint16_t)(lat/10000000), 2, 0,0);
		590	lcd_printp_at (14, ij+1, PSTR("."), 0);
		591	write_ndigit_number_u (15, ij+1, (uint16_t)((lat/1000) % 10000), 4, 1,0);
		592	write_ndigit_number_u (19, ij+1, (uint16_t)((lat/10) % 100), 2, 1,0);
		593	}
		594
		595	while (!get_key_press (1 << KEY_ESC))
		596	timer = TIMEOUT;
		597
		598	get_key_press(KEY_ALL);
		599	lcd_cls();
		600	}
		601
		602
		603	//--------------------------------------------------------------
		604	void Show_LastPosition(void)
		605	{
		606	lcd_puts_at(0, 2, strGet(OSD_POS1), 0);
		607	lcd_puts_at(0, 3, strGet(OSD_POS2), 0);
		608	lcd_puts_at(0, 5, strGet(START_LASTPOS1), 0);
		609	uint32_t lon = last5pos[0].Latitude;
		610	write_ndigit_number_u (1, 6, (uint16_t)(lon/10000000), 2, 0,0);
		611	lcd_printp_at (3, 6, PSTR("."), 0);
		612	write_ndigit_number_u (4, 6, (uint16_t)((lon/1000) % 10000), 4, 1,0);
		613	write_ndigit_number_u (8, 6, (uint16_t)((lon/10) % 100), 2, 1,0);
		614
		615	uint32_t lat = last5pos[0].Longitude;
		616	write_ndigit_number_u (12, 6, (uint16_t)(lat/10000000), 2, 0,0);
		617	lcd_printp_at (14, 6, PSTR("."), 0);
		618	write_ndigit_number_u (15, 6, (uint16_t)((lat/1000) % 10000), 4, 1,0);
		619	write_ndigit_number_u (19, 6, (uint16_t)((lat/10) % 100), 2, 1,0);
		620
		621	}
		622
		623
		624	//--------------------------------------------------------------
		625	void OSD_Timeout(uint8_t flag)
		626	{
		627
		628	// uint8_t flag;
		629	uint8_t tmp_dat;
		630	// flag = 0;
		631	timer = TIMEOUT;
		632	// disable OSD Data from NC
		633	// RS232_request_mk_data (1, 'o', 0);
		634	// tmp_dat = 0;
		635	// SendOutData ('o', ADDRESS_NC, 1, &tmp_dat, 1);
		636
		637	mode = 0;
		638	rxd_buffer_locked = FALSE;
		639
		640
		641	// Bei Verbindungsverlusst werden hier die letzten bekannten Koordinaten ausgegeben!!!
		642	if( flag )
		643	{
		644	// Falls Spannungswarnung an war Beeper aus//
		645
		646	set_beep ( 0, 0, BeepOff);
		647
		648	lcd_cls ();
		649	WriteLastPosition(last5pos[0].Longitude,last5pos[0].Latitude); // im EEprom speichern
		650	lcd_puts_at(0, 0, strGet(OSD_ERROR), 2); // ERROR: Datenverlust
		651	lcd_puts_at(0, 2, strGet(OSD_POS1), 0); // Letzte bekannte
		652	lcd_puts_at(0, 3, strGet(OSD_POS2), 0); // Position gespeichert.
		653	lcd_puts_at(0, 5, strGet(START_LASTPOS1), 0); // Breitengr L�ngengr
		654	// lcd_puts_at(12, 7, strGet(ENDE), 0);
		655	// lcd_puts_at(19, 7, strGet(OK), 0);
		656	// if (OSD_RCErrorbeep==true)
		657	// {
		658	set_beep ( 250, 0x0040, BeepNormal);
		659	// }
		660
		661	uint32_t lon = last5pos[0].Latitude;
		662	write_ndigit_number_u (1, 6, (uint16_t)(lon/10000000), 2, 0,0);
		663	lcd_printp_at (3, 6, PSTR("."), 0);
		664	write_ndigit_number_u (4, 6, (uint16_t)((lon/1000) % 10000), 4, 1,0);
		665	write_ndigit_number_u (8, 6, (uint16_t)((lon/10) % 100), 2, 1,0);
		666
		667	uint32_t lat = last5pos[0].Longitude;
		668	write_ndigit_number_u (12, 6, (uint16_t)(lat/10000000), 2, 0,0);
		669	lcd_printp_at (14, 6, PSTR("."), 0);
		670	write_ndigit_number_u (15, 6, (uint16_t)((lat/1000) % 10000), 4, 1,0);
		671	write_ndigit_number_u (19, 6, (uint16_t)((lat/10) % 100), 2, 1,0);
		672
		673	// while (!get_key_press (1 << KEY_ENTER));
		674	// _delay_ms(1000);
		675	timer = TIMEOUT;
		676	// lcd_cls();
		677	// return;
		678	}
		679	else
		680	{
		681	lcd_puts_at(0, 0, strGet(OSD_ERROR), 2);
		682	Show_LastPosition();
		683	if (Config.OSD_RCErrorbeep==true) set_beep ( 200, 0x0080, BeepNormal);
		684	// _delay_ms(2000);
		685	}
		686
		687	rxd_buffer_locked = FALSE; // 07.03.2013 OG: fix
		688	// es gab Probleme mit dem Empfang gueltiger NC-Daten, die zu unschoenen Starteffekten bei den
		689	// OSD-Screens gefuehrt haben. Mit rxd_buffer_locked = FALSE vor SwitchToNC() ist das PKT wieder im 'Takt'
		690
		691	SwitchToNC();
		692
		693	mode = 'O';
		694
		695	// disable debug...
		696	// RS232_request_mk_data (0, 'd', 0);
		697	tmp_dat = 0;
		698	SendOutData ('d', ADDRESS_ANY, 1, &tmp_dat, 1);
		699
		700	// request OSD Data from NC every 100ms
		701	// RS232_request_mk_data (1, 'o', 100);
		702	tmp_dat = 10;
		703	SendOutData ('o', ADDRESS_NC, 1, &tmp_dat, 1);
		704
		705	//_delay_ms(100);
		706	//rxd_buffer_locked = FALSE;
		707	}
		708
		709
		710
		711
		712	//-----------------------------------------------------------
		713	//
		714	void lcd_o_circle (uint16_t x, uint16_t y, int16_t breite, uint8_t mode, int8_t xoffs, int8_t yoffs)
		715	{
		716	breite *= 6;
		717	int16_t radius = breite / 2;
		718	x += 2;
		719	x *= 6;
		720	x += 2;
		721	y += 1;
		722	y *= 8;
		723	y += 3;
		724
		725	// 04.03.2012 OG: chg: x-radius von -3 auf -2 (runder auf dem display)
		726	//lcd_ellipse (x, y, radius - 3, radius - 5, mode);
		727	lcd_ellipse( x+xoffs, y+yoffs, radius - 2, radius - 5, mode);
		728	}
		729
		730
		731	//-----------------------------------------------------------
		732	// lcd_o_circ_line( x, y, breite, deg, rOffset, mode)
		733	//
		734	// x, y : in Chars
		735	// breite : in Chars
		736	// deg : in Pixel
		737	// rOffset: Beeinflusst den Schluss der Linie zum Huellkreis
		738	// 0 = Standard
		739	// >0 naeher zum Huellkreis
		740	// <0 entfernter vom Huellkreis
		741	// mode : siehe: lcd_ellipse_line()
		742	//-----------------------------------------------------------
		743	void lcd_o_circ_line( uint16_t x, uint16_t y, uint8_t breite, uint16_t deg, int8_t rOffset, uint8_t mode, int8_t xoffs, int8_t yoffs)
		744	{
		745	breite *= 6;
		746	int16_t radius = breite / 3;
		747	x += 2;
		748	x *= 6;
		749	x += 2;
		750	y += 1;
		751	y *= 8;
		752	y += 3;
		753
		754	// 04.03.2013 OG: der Radius kann mit rOffset >0 vergroessert werden um zum Kreis aufzuschliessen
		755	lcd_ellipse_line( x+xoffs, y+yoffs, radius+rOffset, radius+rOffset, deg, mode);
		756	}
		757
		758
		759	//--------------------------------------------------------------
		760	void draw_icon_home(uint8_t x, uint8_t y)
		761	{
		762	//lcd_plot( x+0, y+0, 1); // Referenz 0,0
		763	lcd_rect( x+0, y+5, 10, 8, 1); // Mitte
		764	lcd_line( x+5, y+0, x+0, y+5, 1); // Dach Links
		765	lcd_line( x+5, y+0, x+10, y+5, 1); // Dach Rechts
		766	lcd_rect( x+4, y+10, 2, 3, 1); // Tuere
		767
		768	}
		769
		770
		771	//--------------------------------------------------------------
		772	void draw_icon_sat(uint8_t x, uint8_t y)
		773	{
		774	//lcd_plot( x+0, y+0, 1); // Referenz 0,0
		775	lcd_rect( x+0, y+2, 4, 2, 1); // linker Fluegel
		776	lcd_rect( x+8, y+2, 4, 2, 1); // rechter Fluegel
		777	lcd_rect( x+4, y+0, 4, 6, 1); // Mitte, oben
		778	lcd_line( x+6, y+7, x+2, y+11, 1); // Strahl Links
		779	lcd_line( x+6, y+7, x+10, y+11, 1); // Strahl Rechts
		780	lcd_line( x+1, y+12, x+11, y+12, 1); // Strahl Unten
		781	}
		782
		783
		784	//--------------------------------------------------------------
		785	void draw_icon_battery(uint8_t x, uint8_t y)
		786	{
		787	//lcd_plot( x+0, y+0, 1); // Referenz 0,0
		788	lcd_rect( x+2, y+0, 2, 2, 1); // der kleine Knubbel oben
		789	lcd_rect( x+0, y+2, 6, 15, 1); // body
		790	}
		791
		792
		793
		794	//##############################################################
		795	//# OSD-ELEMENTS
		796	//##############################################################
		797
		798	//--------------------------------------------------------------
		799	// OSD_Element_Flag_Label( xC, yC, item, lOn, xoffs, yoffs)
		800	//
		801	// xC, yC : x,y in Characters
		802	// item : OSD_FLAG_AH, OSD_FLAG_PH, usw.
		803	// lOn : true / false
		804	// xoffs,yoffs : x,y Pixelverschiebung
		805	//--------------------------------------------------------------
		806	void OSD_Element_Flag_Label( uint8_t xC, uint8_t yC, uint8_t item, uint8_t lOn, int8_t xoffs, int8_t yoffs)
		807	{
		808	int8_t x = (xC*6)-2;
		809	int8_t y = (yC*8)-1;
		810	uint8_t w = 14;
		811	uint8_t h = 8;
		812
		813	const char *labels[OSD_FLAG_COUNT] =
		814	{
		815	PSTR("AH"), // OSD_FLAG_AH Altitue Hold
		816	PSTR("PH"), // OSD_FLAG_PH Position Hold
		817	PSTR("CF"), // OSD_FLAG_CF Care Free
		818	PSTR("CH"), // OSD_FLAG_CH Coming Home
		819	PSTR("o1"), // OSD_FLAG_O1 Out1
		820	PSTR("o2"), // OSD_FLAG_O2 Out2
		821	PSTR("BA"), // OSD_FLAG_BA LowBat warning (MK)
		822	PSTR("CA"), // OSD_FLAG_CA Calibrate
		823	PSTR("ST"), // OSD_FLAG_ST Start
		824	PSTR("MR"), // OSD_FLAG_MR Motor Run
		825	PSTR("FY"), // OSD_FLAG_FY Fly
		826	PSTR("EL"), // OSD_FLAG_EL Emergency Landing
		827	PSTR("FS"), // OSD_FLAG_FS RX Failsave Active
		828	PSTR("GP"), // OSD_FLAG_GP GPS Ok
		829	PSTR("S!"), // OSD_FLAG_S0 GPS-Sat not ok (GPS NOT ok)
		830	PSTR("TU"), // OSD_FLAG_TU Vario Trim Up
		831	PSTR("TD"), // OSD_FLAG_TD Vario Trim Down
		832	PSTR("FR"), // OSD_FLAG_FR Free
		833	PSTR("RL"), // OSD_FLAG_RL Range Limit
		834	PSTR("SL"), // OSD_FLAG_SL No Serial Link
		835	PSTR("TR"), // OSD_FLAG_TR Target Reached
		836	PSTR("MC") // OSD_FLAG_MC Manual Control
		837	};
		838
		839	//lcd_plot( x-2, y-2, 1); // Referenz
		840
		841	if( yC==0 ) { y = 0; h = 7; }
		842	if( xC==0 ) { x = 0; w = 12; }
		843
		844	if( lOn )
		845	{
		846	lcd_frect( x+xoffs, y+yoffs, w, h, 1); // Filler
		847	lcdx_printp_at( xC, yC, labels[item], MINVERS, xoffs,yoffs); // Label
		848	}
		849	else
		850	{
		851	lcd_frect( x+xoffs, y+yoffs, w, h, 0); // clear
		852	}
		853	}
		854
		855
		856	//--------------------------------------------------------------
		857	//--------------------------------------------------------------
		858	void OSD_Element_Flag( uint8_t xC, uint8_t yC, uint8_t item, int8_t xoffs, int8_t yoffs)
		859	{
		860	uint8_t lOn = 0;
		861
		862	// FC_StatusFlags 0.88
		863	switch( item )
		864	{
		865	// Altitue Hold
		866	case OSD_FLAG_AH : lOn = (naviData->FCStatusFlags2 & FC_STATUS2_ALTITUDE_CONTROL);
		867	break;
		868
		869	// Position Hold
		870	case OSD_FLAG_PH : lOn = (naviData->NCFlags & NC_FLAG_PH);
		871	break;
		872
		873	// Coming Home
		874	case OSD_FLAG_CH : lOn = (naviData->NCFlags & NC_FLAG_CH);
		875	break;
		876
		877	// Care Free
		878	case OSD_FLAG_CF : lOn = (naviData->FCStatusFlags2 & FC_STATUS2_CAREFREE);
		879	break;
		880
		881	// Out1
		882	case OSD_FLAG_O1 : lOn = (naviData->FCStatusFlags2 & FC_STATUS2_OUT1_ACTIVE);
		883	break;
		884
		885	// Out2
		886	case OSD_FLAG_O2 : lOn = (naviData->FCStatusFlags2 & FC_STATUS2_OUT2_ACTIVE);
		887	break;
		888
		889	// LowBat warning (MK)
		890	case OSD_FLAG_BA : lOn = (naviData->FCStatusFlags & FC_STATUS_LOWBAT);
		891	break;
		892
		893	// Calibrate
		894	case OSD_FLAG_CA : lOn = (naviData->FCStatusFlags & FC_STATUS_CALIBRATE);
		895	break;
		896
		897	// Start
		898	case OSD_FLAG_ST : lOn = (naviData->FCStatusFlags & FC_STATUS_START);
		899	break;
		900
		901	// Motor Run
		902	case OSD_FLAG_MR : lOn = (naviData->FCStatusFlags & FC_STATUS_MOTOR_RUN);
		903	break;
		904
		905	// Fly
		906	case OSD_FLAG_FY : lOn = (naviData->FCStatusFlags & FC_STATUS_FLY);
		907	break;
		908
		909	// Emergency Landing
		910	case OSD_FLAG_EL : lOn = (naviData->FCStatusFlags & FC_STATUS_EMERGENCY_LANDING);
		911	break;
		912
		913	// RC Failsave Active
		914	case OSD_FLAG_FS : lOn = (naviData->FCStatusFlags2 & FC_STATUS2_RC_FAILSAVE_ACTIVE);
		915	break;
		916
		917	// GPS ok
		918	case OSD_FLAG_GP : lOn = (naviData->NCFlags & NC_FLAG_GPS_OK);
		919	break;
		920
		921	// GPS-Sat not ok (GPS NOT ok)
		922	case OSD_FLAG_S0 : lOn = !(naviData->NCFlags & NC_FLAG_GPS_OK);
		923	break;
		924
		925	// Vario Trim Up
		926	case OSD_FLAG_TU : lOn = (naviData->FCStatusFlags & FC_STATUS_VARIO_TRIM_UP);
		927	break;
		928
		929	// Vario Trim Down
		930	case OSD_FLAG_TD : lOn = (naviData->FCStatusFlags & FC_STATUS_VARIO_TRIM_DOWN);
		931	break;
		932
		933	// Free
		934	case OSD_FLAG_FR : lOn = (naviData->NCFlags & NC_FLAG_FREE);
		935	break;
		936
		937	// Range Limit
		938	case OSD_FLAG_RL : lOn = (naviData->NCFlags & NC_FLAG_RANGE_LIMIT);
		939	break;
		940
		941	// No Serial Link
		942	case OSD_FLAG_SL : lOn = (naviData->NCFlags & NC_FLAG_NOSERIALLINK);
		943	break;
		944
		945	// Target Reached
		946	case OSD_FLAG_TR : lOn = (naviData->NCFlags & NC_FLAG_TARGET_REACHED);
		947	break;
		948
		949	// Manual Control
		950	case OSD_FLAG_MC : lOn = (naviData->NCFlags & NC_FLAG_MANUAL_CONTROL);
		951	break;
		952
		953	}
		954
		955	OSD_Element_Flag_Label( xC, yC, item, lOn, xoffs,yoffs);
		956	}
		957
		958
		959	//--------------------------------------------------------------
		960	// OSD_Element_AltitudeControl( x, y)
		961	//--------------------------------------------------------------
		962	void OSD_Element_AltitudeControl( uint8_t x, uint8_t y )
		963	{
		964	//---------------------------------------------------------
		965	// 10.03.2013 OG:
		966	// CFG2_HEIGHT_LIMIT im Augenblick nicht unterstuetzt
		967	// Siehe Anmerkungen in osd()
		968	//---------------------------------------------------------
		969	/*
		970	if (Flags_ExtraConfig & CFG2_HEIGHT_LIMIT)
		971	{
		972	if (naviData->FCStatusFlags2 & FC_STATUS2_ALTITUDE_CONTROL)
		973	lcd_puts_at (x, y, strGet(OSD_ALTI_1), 0); // H�he begr.
		974	else
		975	lcd_puts_at (x, y, strGet(OSD_ALTI_0), 0); // H�he aus
		976	}
		977	else
		978	{
		979	if (naviData->FCStatusFlags2 & FC_STATUS2_ALTITUDE_CONTROL)
		980	lcd_puts_at (x, y, strGet(OSD_VARIO_1), 0); // Vario H�he
		981	else
		982	lcd_puts_at (x, y, strGet(OSD_VARIO_0), 0); // Vario aus
		983	}
		984	*/
		985
		986	if (naviData->FCStatusFlags2 & FC_STATUS2_ALTITUDE_CONTROL)
		987	lcd_puts_at (x, y, strGet(OSD_VARIO_1), 0); // Vario H�he
		988	else
		989	lcd_puts_at (x, y, strGet(OSD_VARIO_0), 0); // Vario aus
		990
		991	}
		992
		993
		994	//--------------------------------------------------------------
		995	// Anzeige von Steigen / Sinken
		996	//--------------------------------------------------------------
		997	void OSD_Element_UpDown( uint8_t x, uint8_t y, int8_t xoffs, int8_t yoffs)
		998	{
		999	x = (x*6) + xoffs;
		1000	y = (y*8) + yoffs;
		1001
		1002	lcd_frect( x, y, 6, 7, 0); // clear
		1003
		1004	if( naviData->Variometer > 2 ) // steigen mehr als 0.2 m/sec (ein guter Wert muss noch in der Praxis ermittelt werden)
		1005	{
		1006	lcd_line( x+2, y+0, x+0, y+2, 1);
		1007	lcd_line( x+2, y+0, x+4, y+2, 1);
		1008	}
		1009	else if( naviData->Variometer < -2 ) // sinken mehr als 0.2 m/sec
		1010	{
		1011	lcd_line( x+2, y+6, x+0, y+4, 1);
		1012	lcd_line( x+2, y+6, x+4, y+4, 1);
		1013	}
		1014
		1015	}
		1016
		1017
		1018	//--------------------------------------------------------------
		1019	// OSD_Element_Altitude( x, y, nStyle)
		1020	// nStyle entspricht dem ehemaligen 'Mode'
		1021	//--------------------------------------------------------------
		1022	void OSD_Element_Altitude( uint8_t x, uint8_t y, uint8_t nStyle )
		1023	{
		1024	switch( nStyle )
		1025	{
		1026	case 0 :
		1027	case 1 : //note:lephisto:according to several sources it's /30
		1028	if (naviData->Altimeter > (300 / AltimeterAdjust) \|\| naviData->Altimeter < (-300 / AltimeterAdjust)) // above 10m only write full meters
		1029	write_ndigit_number_s (x, y, naviData->Altimeter / (30 / AltimeterAdjust), 4, 0,MNORMAL);
		1030	else // up to 10m write meters.dm
		1031	write_ndigit_number_s_10th (x, y, naviData->Altimeter / (3 / AltimeterAdjust), 3, 0,MNORMAL);
		1032
		1033	lcd_printp_at (x+4, y, PSTR("m"), MNORMAL);
		1034	lcd_putc (x+5, y, 0x09, 0); // Hoehensymbol
		1035	break;
		1036
		1037	case 2 : //note:lephisto:according to several sources it's /30
		1038	if (naviData->Altimeter > (300 / AltimeterAdjust) \|\| naviData->Altimeter < (-300 / AltimeterAdjust)) // above 10m only write full meters
		1039	write_ndigit_number_s (x+4, y, naviData->Altimeter / (30 / AltimeterAdjust), 4, 0,MBIG);
		1040	else // up to 10m write meters.dm
		1041	write_ndigit_number_s_10th (x+4, y, naviData->Altimeter / (3 / AltimeterAdjust), 3, 0,MBIG);
		1042	lcd_putc( x+8, y, 'm', MBIG);
		1043	lcd_printp_at (x, y, PSTR("H�he"), MNORMAL);
		1044	break;
		1045	}
		1046	}
		1047
		1048
		1049	//--------------------------------------------------------------
		1050	// fuer: Config.OSD_LipoBar==1
		1051	//--------------------------------------------------------------
		1052	void OSD_Element_BatteryLevel_Bar( uint8_t x, uint8_t y )
		1053	{
		1054	uint16_t Balken = 0;
		1055
		1056	drawmode = (naviData->UBat < BattLowVoltageWarning ? 2 : 0);
		1057
		1058	if( cells > 0 ) // LipobargraphAnzeige nur wenn Anzahl der Lipozellen bekannt sind
		1059	{
		1060	write_ndigit_number_u (x+6, y, cells, 1, 0, drawmode);
		1061	lcd_printp_at (x+7, y, PSTR("S"), drawmode);
		1062
		1063	if( cells==3 )
		1064	{
		1065	lcd_rect(x6, y8, 28, 7, 1); // Rahmen
		1066	Balken = ((naviData->UBat-(cellsMIN_CELL_VOLTAGE))10)/12;
		1067	if((Balken > 0) && (Balken <28)) lcd_frect((x6)+1, (y8)+1, Balken, 5, 1); // Fuellung
		1068	if(Balken <= 26) lcd_frect(Balken+(x6)+1, (y8)+1, 26-Balken, 5, 0); // loeschen
		1069	}
		1070
		1071	if( cells==4 \|\|cells==5 )
		1072	{
		1073	lcd_rect(x6, y8, 30, 7, 1); // Rahmen
		1074	if (cells == 4) Balken = ((naviData->UBat-(cellsMIN_CELL_VOLTAGE))10)/15;
		1075	if (cells == 5) Balken = ((naviData->UBat-(cellsMIN_CELL_VOLTAGE))10)/19;
		1076	if ((Balken > 0) && (Balken <=29)) lcd_frect((x6)+1, (y8)+1, Balken, 5, 1); // Fuellung
		1077	if (Balken <= 27) lcd_frect(Balken+(x6)+1, (y8)+1, 28-Balken, 5, 0); // loeschen
		1078	}
		1079
		1080	} // end if: cells > 0 (TODO: Anzeige fuer cells==0 implementieren)
		1081	}
		1082
		1083
		1084
		1085	//--------------------------------------------------------------
		1086	// fuer die neuen OSD-Screens
		1087	//--------------------------------------------------------------
		1088	void OSD_Element_BattLevel2( uint8_t x, uint8_t y, int8_t xoffs, int8_t yoffs )
		1089	{
		1090	drawmode = (naviData->UBat < BattLowVoltageWarning ? MINVERS : MNORMAL);
		1091	writex_ndigit_number_u_10th( x, y, naviData->UBat, 3, 0, drawmode, xoffs,yoffs);
		1092	lcdx_printp_at( x+4, y, PSTR("V"), drawmode, xoffs+1,yoffs); // Einheit
		1093	lcd_line( (x+4)6, y8, (x+4)6, y8+7, (drawmode==MINVERS ? 1 : 0) ); // filler zwischen Spannung und "V"
		1094
		1095	}
		1096
		1097
		1098	//--------------------------------------------------------------
		1099	// fuer: Config.OSD_LipoBar==0
		1100	// nStyle entspricht dem ehemaligen 'Mode'
		1101	//--------------------------------------------------------------
		1102	void OSD_Element_BatteryLevel_Text( uint8_t x, uint8_t y, uint8_t nStyle )
		1103	{
		1104	if( nStyle <= 1)
		1105	drawmode = (naviData->UBat < BattLowVoltageWarning ? 2 : 0); // Normal-Schrift
		1106	else
		1107	drawmode = (naviData->UBat < BattLowVoltageWarning ? 4 : 3); // Fett-Schrift
		1108
		1109	if( nStyle <= 1)
		1110	{
		1111	write_ndigit_number_u_10th (x, y, naviData->UBat, 3, 0, drawmode);
		1112	lcd_printp_at (x+4, y, PSTR("V"), drawmode);
		1113	}
		1114	else
		1115	{
		1116	write_ndigit_number_u_10th (x-2, y, naviData->UBat, 3, 0, drawmode);
		1117	lcd_printp_at (x+2, y, PSTR("V"), drawmode);
		1118	}
		1119	}
		1120
		1121
		1122	//--------------------------------------------------------------
		1123	// nStyle entspricht dem ehemaligen 'Mode'
		1124	//--------------------------------------------------------------
		1125	void OSD_Element_BatteryLevel( uint8_t x, uint8_t y, uint8_t nStyle )
		1126	{
		1127	if( Config.OSD_LipoBar )
		1128	OSD_Element_BatteryLevel_Bar( x, y);
		1129	else
		1130	OSD_Element_BatteryLevel_Text( x, y, nStyle);
		1131	}
		1132
		1133
		1134	//--------------------------------------------------------------
		1135	//--------------------------------------------------------------
		1136	void OSD_Element_Capacity( uint8_t x, uint8_t y )
		1137	{
		1138	drawmode = (naviData->UsedCapacity > Config.OSD_mAh_Warning ? 2 : 0);
		1139
		1140	write_ndigit_number_u (x, y, naviData->UsedCapacity, 5, 0, drawmode);
		1141	lcd_printp_at (x+5, y, PSTR("mAh"), drawmode);
		1142	// BeepTime = 3000;
		1143	// BeepMuster = 0x0020;
		1144	}
		1145
		1146
		1147	//--------------------------------------------------------------
		1148	// OSD_Element_CareFree( x, y)
		1149	//--------------------------------------------------------------
		1150	void OSD_Element_CareFree( uint8_t x, uint8_t y )
		1151	{
		1152	lcd_puts_at (x, y, strGet( naviData->FCStatusFlags2 & FC_STATUS2_CAREFREE ? OSD_CARE_FREE_1 : OSD_CARE_FREE_0 ), 0);
		1153	}
		1154
		1155
		1156	//--------------------------------------------------------------
		1157	// OSD_Element_CompassDegree( x, y, nStyle)
		1158	// nStyle entspricht dem ehemaligen 'Mode'
		1159	//--------------------------------------------------------------
		1160	void OSD_Element_CompassDegree( uint8_t x, uint8_t y, uint8_t nStyle )
		1161	{
		1162	switch( nStyle )
		1163	{
		1164	case 0 :
		1165	case 1 : write_ndigit_number_u (x, y, naviData->CompassHeading, 3, 0,MNORMAL);
		1166	x += 3;
		1167	break;
		1168
		1169	case 2 : write_ndigit_number_u (x, y, naviData->CompassHeading, 3, 0,MBIG);
		1170	x += 8;
		1171	break;
		1172	}
		1173	lcd_putc( x, y, 0x1E, MNORMAL); // degree symbol
		1174	}
		1175
		1176
		1177	//--------------------------------------------------------------
		1178	//--------------------------------------------------------------
		1179	void OSD_Element_CompassDirection( uint8_t x, uint8_t y )
		1180	{
		1181	lcd_printp_at (x, y, (const char *) (pgm_read_word ( &(directions_p[heading_conv(naviData->CompassHeading)]))), 0);
		1182	}
		1183
		1184
		1185	//--------------------------------------------------------------
		1186	//--------------------------------------------------------------
		1187	void OSD_Element_CompassRose( uint8_t x, uint8_t y )
		1188	{
		1189	draw_compass (x, y, naviData->CompassHeading);
		1190	}
		1191
		1192	//--------------------------------------------------------------
		1193	//--------------------------------------------------------------
		1194	void OSD_Element_Current( uint8_t x, uint8_t y )
		1195	{
		1196	write_ndigit_number_u_10th (x, y, naviData->Current, 3, 0,0);
		1197	lcd_printp_at (x+4, y, PSTR("A"), 0);
		1198	}
		1199
		1200
		1201	//--------------------------------------------------------------
		1202	//--------------------------------------------------------------
		1203	void OSD_Element_FlyingTime( uint8_t x, uint8_t y )
		1204	{
		1205	write_time (x, y, naviData->FlyingTime);
		1206	lcd_printp_at (x+5, y, PSTR("m"), 0);
		1207	}
		1208
		1209
		1210	//--------------------------------------------------------------
		1211	//--------------------------------------------------------------
		1212	void OSD_Element_GroundSpeed( uint8_t x, uint8_t y )
		1213	{
		1214	write_ndigit_number_u (x, y, (uint16_t) (((uint32_t) naviData->GroundSpeed * (uint32_t) 9) / (uint32_t) 250), 3, 0,0);
		1215	lcd_printp_at (x+3, y, PSTR("Kmh"), 0);
		1216	}
		1217
		1218
		1219
		1220	//--------------------------------------------------------------
		1221	//--------------------------------------------------------------
		1222	void OSD_Element_HomeCircle( uint8_t x, uint8_t y, uint8_t breite, int8_t rOffset, int8_t xoffs, int8_t yoffs )
		1223	{
		1224	lcd_o_circle( x, y, breite, 1, xoffs,yoffs);
		1225
		1226	if (Config.OSD_HomeMKView==1)
		1227	heading_home = (naviData->HomePositionDeviation.Bearing + 360 - naviData->CompassHeading) % 360;
		1228	else
		1229	heading_home = (naviData->CompassHeading- naviData->HomePositionDeviation.Bearing + 360 ) % 360;
		1230
		1231	lcd_o_circ_line( x, y, breite, old_hh , rOffset, 0, xoffs,yoffs);
		1232	lcd_o_circ_line( x, y, breite, heading_home, rOffset, 1, xoffs,yoffs);
		1233
		1234	old_hh = heading_home;
		1235	}
		1236
		1237
		1238
		1239
		1240	//--------------------------------------------------------------
		1241	//--------------------------------------------------------------
		1242	void OSD_Element_HomeDegree( uint8_t x, uint8_t y )
		1243	{
		1244	write_ndigit_number_u (x, y, heading_home, 3, 0,0);
		1245	lcd_putc (x+3, y, 0x1e, 0); // degree symbol
		1246	}
		1247
		1248
		1249	//--------------------------------------------------------------
		1250	// OSD_Element_HomeDistance( x, y, nStyle)
		1251	//--------------------------------------------------------------
		1252	void OSD_Element_HomeDistance( uint8_t x, uint8_t y, uint8_t nStyle )
		1253	{
		1254	switch( nStyle )
		1255	{
		1256	case 0 :
		1257	case 1 : write_ndigit_number_u (x, y, naviData->HomePositionDeviation.Distance / 10, 3, 0,0);
		1258	lcd_putc (x+3, y, 'm', 0);
		1259	draw_homesymbol(x+4, y);
		1260	break;
		1261
		1262	case 2 : lcd_printp_at (x, y, PSTR("Home"), 0);
		1263	write_ndigit_number_u (x+5, y, naviData->HomePositionDeviation.Distance / 10, 3, 0,0);
		1264	lcd_printp_at (x+8, y, PSTR("m -"), 0);
		1265	break;
		1266	}
		1267	}
		1268
		1269
		1270	//--------------------------------------------------------------
		1271	// OSD_Element_LEDOutput( x, y, bitmask)
		1272	//
		1273	// bitmask: LED1 = FC_STATUS2_OUT1_ACTIVE
		1274	// LED2 = FC_STATUS2_OUT2_ACTIVE
		1275	//--------------------------------------------------------------
		1276	void OSD_Element_LEDOutput( uint8_t x, uint8_t y, uint8_t bitmask )
		1277	{
		1278	uint8_t lOn;
		1279
		1280	lOn = (naviData->FCStatusFlags2 & bitmask ? 1 : 0); // Bit gesetzt?
		1281	lOn = (Config.OSD_InvertOut ? !lOn : lOn); // Invertieren?
		1282	lOn = (lOn ? 1 : 0); // auf 0 oder 1 setzen (hmm, geht auch besser...).
		1283
		1284	lcd_fcircle (x * 6 + 5, y * 8 + 3, Config.OSD_LEDform, lOn);
		1285	lcd_circle (x * 6 + 5, y * 8 + 3, 3, 1);
		1286
		1287	/*
		1288	if (!Config.OSD_InvertOut)
		1289	{
		1290	if (naviData->FCStatusFlags2 & FC_STATUS2_OUT1_ACTIVE)
		1291	{
		1292	lcd_fcircle (x * 6 + 5, y * 8 + 3, Config.OSD_LEDform, 0);
		1293	lcd_circle (x * 6 + 5, y * 8 + 3, 3, 1);
		1294	}
		1295	else
		1296	{
		1297	lcd_fcircle (x * 6 + 5, y * 8 + 3, Config.OSD_LEDform, 1);
		1298	lcd_circle (x * 6 + 5, y * 8 + 3, 3, 1);
		1299	}
		1300	}
		1301	else
		1302	{
		1303	if (naviData->FCStatusFlags2 & FC_STATUS2_OUT1_ACTIVE)
		1304	{
		1305	lcd_fcircle (x * 6 + 5, y * 8 + 3,Config.OSD_LEDform, 1);
		1306	lcd_circle (x * 6 + 5, y * 8 + 3, 3, 1);
		1307	}
		1308	else
		1309	{
		1310	lcd_fcircle (x * 6 + 5, y * 8 + 3, Config.OSD_LEDform, 0);
		1311	lcd_circle (x * 6 + 5, y * 8 + 3, 3, 1);
		1312	}
		1313	}
		1314	break;
		1315	*/
		1316	}
		1317
		1318
		1319	//--------------------------------------------------------------
		1320	// OSD_Element_LED1Output( x, y)
		1321	//--------------------------------------------------------------
		1322	void OSD_Element_LED1Output( uint8_t x, uint8_t y )
		1323	{
		1324	OSD_Element_LEDOutput( x, y, FC_STATUS2_OUT1_ACTIVE );
		1325	}
		1326
		1327
		1328	//--------------------------------------------------------------
		1329	// OSD_Element_LED2Output( x, y)
		1330	//--------------------------------------------------------------
		1331	void OSD_Element_LED2Output( uint8_t x, uint8_t y )
		1332	{
		1333	OSD_Element_LEDOutput( x, y, FC_STATUS2_OUT2_ACTIVE );
		1334	}
		1335
		1336
		1337	//--------------------------------------------------------------
		1338	// OSD_Element_Manuell( x, y)
		1339	//--------------------------------------------------------------
		1340	void OSD_Element_Manuell( uint8_t x, uint8_t y )
		1341	{
		1342	if (naviData->NCFlags & NC_FLAG_MANUAL_CONTROL)
		1343	lcd_putc (x, y, 'M', 0); // rc transmitter
		1344	else
		1345	lcd_putc (x, y, 'X', 0); // clear
		1346	}
		1347
		1348
		1349	//--------------------------------------------------------------
		1350	// OSD_Element_NaviMode( x, y)
		1351	//--------------------------------------------------------------
		1352	void OSD_Element_NaviMode( uint8_t x, uint8_t y )
		1353	{
		1354	if (naviData->NCFlags & NC_FLAG_FREE)
		1355	lcd_puts_at (x, y, strGet(OSD_NAVI_MODE_0), 0); // Navi aus
		1356	else if (naviData->NCFlags & NC_FLAG_PH)
		1357	lcd_puts_at (x, y, strGet(OSD_NAVI_MODE_1), 0); // Pos. Hold
		1358	else if (naviData->NCFlags & NC_FLAG_CH)
		1359	lcd_puts_at (x, y, strGet(OSD_NAVI_MODE_2), 0); // Coming Home
		1360	}
		1361
		1362
		1363	//--------------------------------------------------------------
		1364	// OSD_Element_RCIntensity( x, y)
		1365	//--------------------------------------------------------------
		1366	void OSD_Element_RCIntensity( uint8_t x, uint8_t y )
		1367	{
		1368	write_ndigit_number_u (x, y, naviData->RC_Quality, 3, 0,0);
		1369	lcd_printp_at (x+3, y, PSTR("\x1F"), 0); // RC-transmitter
		1370	if (naviData->NCFlags & NC_FLAG_NOSERIALLINK)
		1371	{
		1372	lcd_printpns_at(x+3, y, PSTR(" "), 0); // Clear
		1373	}
		1374	else
		1375	{
		1376	lcd_printpns_at(x+3, y, PSTR("PC"), 0);
		1377	}
		1378	}
		1379
		1380
		1381	//--------------------------------------------------------------
		1382	// OSD_Element_SatsInUse( x, y, nStyle)
		1383	//
		1384	// nStyle == 0: "00s"
		1385	// nStyle == 1: wie 0
		1386	// nStyle == 2: "00 Sat"
		1387	//
		1388	// nStyle entspricht dem ehemaligen 'Mode'
		1389	//--------------------------------------------------------------
		1390	void OSD_Element_SatsInUse( uint8_t x, uint8_t y, uint8_t nStyle )
		1391	{
		1392	drawmode = (naviData->NCFlags & NC_FLAG_GPS_OK ? 0 : 2);
		1393
		1394	switch( nStyle )
		1395	{
		1396	case 0 :
		1397	case 1 : write_ndigit_number_u (x, y, naviData->SatsInUse, 2, 0, drawmode);
		1398	lcd_putc (x+2, y, 0x08, drawmode);
		1399	break;
		1400
		1401	case 2 : write_ndigit_number_u (x, y, naviData->SatsInUse, 2, 0, drawmode);
		1402	lcd_printp_at (x+2, y, PSTR(" Sat"), drawmode);
		1403	break;
		1404	}
		1405	}
		1406
		1407
		1408	//--------------------------------------------------------------
		1409	// OSD_Element_StatusFlags( x, y)
		1410	//--------------------------------------------------------------
		1411	void OSD_Element_StatusFlags( uint8_t x, uint8_t y )
		1412	{
		1413	// FC_StatusFlags 0.88
		1414	// #define FC_STATUS_MOTOR_RUN 0x01
		1415	// #define FC_STATUS_FLY 0x02
		1416	// #define FC_STATUS_CALIBRATE 0x04
		1417	// #define FC_STATUS_START 0x08
		1418	// #define FC_STATUS_EMERGENCY_LANDING 0x10
		1419	// #define FC_STATUS_LOWBAT 0x20
		1420	// #define FC_STATUS_VARIO_TRIM_UP 0x40
		1421	// #define FC_STATUS_VARIO_TRIM_DOWN 0x80
		1422
		1423	if (naviData->FCStatusFlags & FC_STATUS_CALIBRATE)
		1424	lcd_puts_at (x, y, strGet(OSD_FLAGS_1), 0); // Calibrate
		1425	else if (naviData->FCStatusFlags & FC_STATUS_START)
		1426	lcd_puts_at (x, y, strGet(OSD_FLAGS_2), 0); // Start
		1427	else if (naviData->FCStatusFlags & FC_STATUS_MOTOR_RUN)
		1428	lcd_puts_at (x, y, strGet(OSD_FLAGS_3), 0); // Run
		1429	else if (naviData->FCStatusFlags & FC_STATUS_FLY)
		1430	lcd_puts_at (x, y, strGet(OSD_FLAGS_4), 0); // Fly
		1431	else if (naviData->FCStatusFlags & FC_STATUS_EMERGENCY_LANDING)
		1432	lcd_puts_at (x, y, strGet(OSD_FLAGS_5), 0); // Landing
		1433	else if (naviData->FCStatusFlags & FC_STATUS_LOWBAT)
		1434	lcd_puts_at (x, y, strGet(OSD_FLAGS_6), 0); // LowBat
		1435	else
		1436	// lcd_printp_at (x, y, PSTR(" "), 0); // Clear
		1437	lcd_puts_at (x, y, strGet(OSD_FLAGS_0), 0); // Clear
		1438	}
		1439
		1440
		1441	//--------------------------------------------------------------
		1442	// OSD_Element_Variometer( x, y)
		1443	//--------------------------------------------------------------
		1444	void OSD_Element_Variometer( uint8_t x, uint8_t y )
		1445	{
		1446	x *= 6;
		1447	y *= 8;
		1448	y += 7;
		1449
		1450	draw_variometer (x, y, 10, 14, naviData->Variometer);
		1451	}
		1452
		1453
		1454	//--------------------------------------------------------------
		1455	// OSD_Element_Target( x, y, nStyle)
		1456	//
		1457	// nStyle entspricht dem ehemaligen 'Mode'
		1458	// nStyle = 0,1: "000m"
		1459	// nStyle = 2,3: "Ziel 000m -"
		1460	//--------------------------------------------------------------
		1461	void OSD_Element_Target( uint8_t x, uint8_t y, uint8_t nStyle )
		1462	{
		1463	if( nStyle <= 1 )
		1464	{
		1465	write_ndigit_number_u (x, y, naviData->TargetPositionDeviation.Distance / 10, 3, 0,0);
		1466	lcd_putc (x+3, y, 'm', 0);
		1467	draw_targetsymbol(x+4,y);
		1468	}
		1469	else
		1470	{
		1471	lcd_printp_at (x, y, PSTR("Ziel"), 0);
		1472	write_ndigit_number_u (x+5, y, naviData->TargetPositionDeviation.Distance / 10, 3, 0,0);
		1473	lcd_printp_at (x+8, y, PSTR("m -"), 0);
		1474	}
		1475	}
		1476
		1477
		1478	//--------------------------------------------------------------
		1479	// TODO:
		1480	// - pruefen ob beep hier an richtiger Stelle ist
		1481	//--------------------------------------------------------------
		1482	void OSD_Element_VarioWert( uint8_t x, uint8_t y )
		1483	{
		1484	uint8_t FC_Fallspeed;
		1485
		1486	FC_Fallspeed = (unsigned int)naviData->Variometer;
		1487	FC_Fallspeed = 255-FC_Fallspeed;
		1488
		1489	drawmode = ( (naviData->Variometer < 0) && (FC_Fallspeed > Config.OSD_Fallspeed) ? 2 : 0);
		1490
		1491
		1492	if( Config.OSD_VarioBeep )
		1493	Beep_Vario(); // Beep ???
		1494
		1495	if( drawmode == 2 )
		1496	{
		1497	if( !Config.HWSound )
		1498	set_beep ( 1000, 0x0060, BeepNormal); // muss ein Beep hier hin????
		1499	else
		1500	variobeep(naviData->Variometer); // muss ein Beep hier hin????
		1501	}
		1502
		1503	write_ndigit_number_s_10th (x, y, naviData->Variometer, 3,0, drawmode);
		1504	lcd_printpns_at(x+4, y, PSTR("ms"), drawmode);
		1505	}
		1506
		1507
		1508	//--------------------------------------------------------------
		1509	//--------------------------------------------------------------
		1510	void OSD_Element_WayPoint( uint8_t x, uint8_t y )
		1511	{
		1512	if (!OldWP == naviData->WaypointIndex)
		1513	{
		1514	// BeepTime = 500;
		1515	// BeepMuster = 0x0080;
		1516	OldWP = naviData->WaypointIndex;
		1517	NextWP = true;
		1518	}
		1519
		1520	if ((NextWP==true)&& naviData->NCFlags & NC_FLAG_TARGET_REACHED)
		1521	{
		1522	set_beep ( 500, 0x0080, BeepNormal);
		1523	NextWP = false;
		1524	}
		1525
		1526	write_ndigit_number_u (x+2, y, naviData->WaypointIndex , 2, 0,0);
		1527
		1528	lcd_printp_at (x, y, PSTR("WP"), 0);
		1529	}
		1530
		1531
		1532	//--------------------------------------------------------------
		1533	//--------------------------------------------------------------
		1534	void OSD_Element_TargetDegree( uint8_t x, uint8_t y )
		1535	{
		1536	write_ndigit_number_u (x, y, naviData->TargetPositionDeviation.Bearing/ 10, 3, 0,0);
		1537	lcd_putc (x+3, y, 0x1e, 0); // degree symbol
		1538	}
		1539
		1540
		1541
		1542	//##############################################################
		1543	//# OSD-SCREENS
		1544	//##############################################################
		1545
		1546	//--------------------------------------------------------------
		1547	// OSD-Screen "General"
		1548	//
		1549	// nMode: 0 = update values
		1550	// 1 = redraw labels and update values
		1551	//--------------------------------------------------------------
		1552	const char * OSD_Screen_General( uint8_t nMode )
		1553	{
		1554	const char *ScreenName = PSTR("General");
		1555
		1556	//-----------------------------------------
		1557	// REDRAW
		1558	// statische Screen Elemente die nicht
		1559	// jedesmal neu gezeichnet werden muessen
		1560	//-----------------------------------------
		1561	if( nMode == OSD_SCREEN_REDRAW )
		1562	{
		1563	// Display: 128 x 64 with 6x8 Font => 21 x 8
		1564
		1565	// Linien: Horizontal
		1566	lcd_line (0, 28, 127, 28, 1); // mitte
		1567	lcd_line (0, 51, 127, 51, 1); // unten
		1568
		1569	// Linien: Vertikal
		1570	lcd_line (65, 0, 65, 50, 1); // mitte
		1571
		1572	//-----------------------------------------
		1573	// Block: Oben - Links
		1574	//-----------------------------------------
		1575	draw_icon_battery(0,4);
		1576	//lcdx_printp_at( 6, 0, PSTR("V") , MNORMAL, 1,0); // Spannung (Volt)
		1577	lcdx_printp_at( 7, 2, PSTR(" mA"), MNORMAL, 0,2);
		1578
		1579	//-----------------------------------------
		1580	// Block: Oben - Rechts
		1581	//-----------------------------------------
		1582	lcdx_printp_at( 12, 0, PSTR("Alt:") , MNORMAL, 0,0);
		1583	lcdx_printp_at( 12, 1, PSTR("Dir:") , MNORMAL, 0,1);
		1584	draw_symbol_degree( 20, 1, 1,1);
		1585	lcdx_printp_at( 12, 2, PSTR(" I:") , MNORMAL, 0,2);
		1586	lcdx_printp_at( 20, 2, PSTR("A") , MNORMAL, 2,2);
		1587
		1588	//-----------------------------------------
		1589	// Block: Unten - Links
		1590	//-----------------------------------------
		1591	draw_icon_sat(0,33);
		1592	lcdx_printp_at( 6, 5, PSTR(" kmh"), MNORMAL, 0,1);
		1593
		1594	//-----------------------------------------
		1595	// Block: Unten - Rechts
		1596	//-----------------------------------------
		1597	draw_icon_home( 70, 32);
		1598	lcdx_printp_at( 20, 4, PSTR("m"), MNORMAL, 2,0);
		1599	draw_symbol_degree( 20, 5, 1,1);
		1600	//lcd_putc( 20, 5, 0x1E, 0); // alternativ: degree symbol
		1601
		1602	//-----------------------------------------
		1603	// unterste Zeile
		1604	//-----------------------------------------
		1605	draw_symbol_rc(20,7); // RC-transmitter
		1606	}
		1607
		1608	//-----------------
		1609	// Batt Level (Volt)
		1610	//-----------------
		1611	OSD_Element_BattLevel2( 2, 0, 0,0 );
		1612
		1613	//-----------------
		1614	// LowBat Warnung MK
		1615	//-----------------
		1616	OSD_Element_Flag( 8, 0, OSD_FLAG_BA, 0,0 );
		1617
		1618	//-----------------
		1619	// Flugzeit
		1620	//-----------------
		1621	writex_time(2, 1, naviData->FlyingTime, MNORMAL, 0,1);
		1622
		1623	//-----------------
		1624	// entnommene Kapazitaet (mAh)
		1625	//-----------------
		1626	drawmode = (naviData->UsedCapacity > Config.OSD_mAh_Warning ? MINVERS : MNORMAL);
		1627	writex_ndigit_number_u( 2, 2, naviData->UsedCapacity, 5, 0, drawmode, 0,2);
		1628
		1629	//-----------------
		1630	// H�he
		1631	//-----------------
		1632	if (naviData->Altimeter > (300 / AltimeterAdjust) \|\| naviData->Altimeter < (-300 / AltimeterAdjust)) // above 10m only write full meters
		1633	write_ndigit_number_s ( 16, 0, naviData->Altimeter / (30 / AltimeterAdjust), 4, 0, MNORMAL);
		1634	else // up to 10m write meters.dm
		1635	write_ndigit_number_s_10th( 16, 0, naviData->Altimeter / (3 / AltimeterAdjust), 3, 0, MNORMAL);
		1636
		1637	//-----------------
		1638	// steigen / sinken
		1639	//-----------------
		1640	OSD_Element_UpDown( 20, 0, 2,0);
		1641
		1642	//-----------------
		1643	// Compass Degree
		1644	//-----------------
		1645	writex_ndigit_number_u (17, 1, naviData->CompassHeading, 3, 0,MNORMAL, 0,1);
		1646
		1647	//-----------------
		1648	// Strom
		1649	//-----------------
		1650	//write_ndigit_number_u_10th( 16, 2, naviData->Current, 3, 0,0); // alternativ mit Nachkomma
		1651	writex_ndigit_number_u( 17, 2, naviData->Current/10, 3, 0,MNORMAL, 0,2);
		1652
		1653	//-----------------
		1654	// Sat Anzahl
		1655	//-----------------
		1656	write_ndigit_number_u (4, 4, naviData->SatsInUse, 2, 0,MNORMAL);
		1657
		1658	//-----------------
		1659	// Sat Warnung "!"
		1660	//-----------------
		1661	/*
		1662	if( naviData->NCFlags & NC_FLAG_GPS_OK )
		1663	lcd_printp_at( 9, 4, PSTR(" "), MNORMAL);
		1664	else
		1665	lcd_printp_at( 9, 4, PSTR("!"), MNORMAL);
		1666	*/
		1667	OSD_Element_Flag( 8, 4, OSD_FLAG_S0, -1,0 ); // Sat Warnung (GPS not ok)
		1668
		1669	//-----------------
		1670	// Geschwindigkeit
		1671	//-----------------
		1672	writex_ndigit_number_u( 3, 5, (uint16_t) (((uint32_t) naviData->GroundSpeed * (uint32_t) 9) / (uint32_t) 250), 3, 0,MNORMAL, 0,1);
		1673
		1674	//-----------------
		1675	// Home Distance
		1676	//-----------------
		1677	write_ndigit_number_u( 17, 4, naviData->HomePositionDeviation.Distance / 10, 3, 0,MNORMAL);
		1678
		1679	//-----------------
		1680	// Home Winkel
		1681	//-----------------
		1682	writex_ndigit_number_u( 16, 5, heading_home, 4, 0,MNORMAL, 0,1);
		1683
		1684	//-----------------
		1685	// Flags
		1686	//-----------------
		1687	OSD_Element_Flag( 1, 7, OSD_FLAG_CF, 0,0 ); // Care Free
		1688	OSD_Element_Flag( 4, 7, OSD_FLAG_AH, 0,0 ); // Altitude Hold
		1689	OSD_Element_Flag( 7, 7, OSD_FLAG_PH, 0,0 ); // Position Hold
		1690	OSD_Element_Flag( 10, 7, OSD_FLAG_CH, 0,0 ); // Coming Home
		1691	OSD_Element_Flag( 13, 7, OSD_FLAG_EL, 0,0 ); // Emergency Landing
		1692
		1693	//-----------------
		1694	// RC-Quality (MK)
		1695	//-----------------
		1696	write_ndigit_number_u( 17, 7, naviData->RC_Quality, 3, 0,MNORMAL);
		1697
		1698	#ifdef OSD_DEMO
		1699	//-----------------
		1700	// Flags
		1701	//-----------------
		1702	OSD_Element_Flag_Label( 8, 0, OSD_FLAG_BA, true, 0,0 ); // DEMO: Batterie Warnung
		1703	OSD_Element_Flag_Label( 8, 4, OSD_FLAG_S0, true, -1,0 ); // DEMO: Sat Warnung (GPS not ok)
		1704
		1705	OSD_Element_Flag_Label( 1, 7, OSD_FLAG_CF, true, 0,0 ); // DEMO
		1706	OSD_Element_Flag_Label( 4, 7, OSD_FLAG_AH, true, 0,0 ); // DEMO
		1707	OSD_Element_Flag_Label( 7, 7, OSD_FLAG_PH, true, 0,0 ); // DEMO
		1708	OSD_Element_Flag_Label( 10, 7, OSD_FLAG_CH, true, 0,0 ); // DEMO
		1709	OSD_Element_Flag_Label( 13, 7, OSD_FLAG_EL, true, 0,0 ); // DEMO
		1710	#endif
		1711
		1712
		1713	return( ScreenName );
		1714	}
		1715
		1716
		1717	//--------------------------------------------------------------
		1718	// OSD-Screen "Navigation"
		1719	//
		1720	// nMode: 0 = update values
		1721	// 1 = redraw labels and update values
		1722	//--------------------------------------------------------------
		1723	const char * OSD_Screen_Navigation( uint8_t nMode )
		1724	{
		1725	const char *ScreenName = PSTR("Navigation");
		1726	int8_t xoffs, yoffs;
		1727
		1728	//-----------------------------------------
		1729	// REDRAW
		1730	// statische Screen Elemente die nicht
		1731	// jedesmal neu gezeichnet werden muessen
		1732	//-----------------------------------------
		1733	if( nMode == OSD_SCREEN_REDRAW )
		1734	{
		1735	// do things here for static screen elements like labels and so....
		1736
		1737	lcd_line ((66-4), 0, (66-4), 9, 1); // Linie Vertikal links
		1738	lcd_line ((156+3), 0, (156+3), 9, 1); // Linie Vertikal rechts
		1739	lcd_line (0, 10, 127, 10, 1); // Linie Horizontal
		1740
		1741	lcdx_printp_at( 0, 2, PSTR("Alt:"), MNORMAL, 0,2); // Hoehe
		1742	lcdx_printp_at( 0, 5, PSTR("Home:"), MNORMAL, 0,3); // Home Distance
		1743	}
		1744
		1745
		1746	//-----------------
		1747	// Oben: Batt Level (Volt)
		1748	//-----------------
		1749	OSD_Element_BattLevel2( 0, 0, 0,0 );
		1750
		1751	//-----------------
		1752	// Oben: Kompass Rose
		1753	//-----------------
		1754	OSD_Element_CompassRose( 6, 0);
		1755
		1756	//-----------------
		1757	// Oben: Flugzeit
		1758	//-----------------
		1759	write_time(16, 0, naviData->FlyingTime);
		1760
		1761	//-----------------
		1762	// Hoehe
		1763	//-----------------
		1764	xoffs = 0;
		1765	yoffs = 3;
		1766	drawmode = MNORMAL;
		1767	if (naviData->Altimeter > (300 / AltimeterAdjust) \|\| naviData->Altimeter < (-300 / AltimeterAdjust)) // above 10m only write full meters
		1768	writex_ndigit_number_s ( 0, 3, naviData->Altimeter / (30 / AltimeterAdjust), 4, 0, drawmode, xoffs,yoffs);
		1769	else // up to 10m write meters.dm
		1770	writex_ndigit_number_s_10th( 0, 3, naviData->Altimeter / (3 / AltimeterAdjust), 3, 0, drawmode, xoffs,yoffs);
		1771
		1772	//-----------------
		1773	// Steigen / Sinken
		1774	//-----------------
		1775	OSD_Element_UpDown( 4, 3, 1,yoffs);
		1776
		1777	//-----------------
		1778	// Home Distance
		1779	//-----------------
		1780	yoffs = 3;
		1781	writex_ndigit_number_u( 0, 6, naviData->HomePositionDeviation.Distance / 10, 4, 0,MNORMAL, 0,yoffs+1);
		1782	lcdx_printp_at( 4, 6, PSTR("m"), MNORMAL, 2,yoffs+1); // Home
		1783
		1784	//-----------------
		1785	// Home Circle
		1786	//-----------------
		1787	xoffs = 0;
		1788	yoffs = 3;
		1789	OSD_Element_HomeCircle( 8, 3, 9, 4, xoffs,yoffs); // Home Circle
		1790	lcd_frect( (96)-3+xoffs, (48)-2+yoffs, (36)+4, (18)+2, 0); // inner clear
		1791	lcd_rect ( (96)-4+xoffs, (48)-3+yoffs, (36)+6, (18)+4, 1); // inner rect
		1792	lcd_frect ( 61+xoffs, 57+yoffs, 2, 2, 1); // bottom mini rect
		1793	writex_ndigit_number_u( 9, 4, heading_home, 3, 0,MNORMAL, xoffs,yoffs); // Degree (Winkel)
		1794
		1795	//-----------------
		1796	// Variometer
		1797	//-----------------
		1798	//void draw_variometer (uint8_t x, uint8_t y, uint8_t width, uint8_t hight, int16_t variometer)
		1799	//draw_variometer( 95, 38, 7, 30, naviData->Variometer);
		1800	//draw_variometer( 94, 38, 7, 21, naviData->Variometer);
		1801	//draw_variometer2( 94, 28, 7, 21, naviData->Variometer);
		1802
		1803	//-----------------
		1804	// Flags
		1805	//-----------------
		1806	OSD_Element_Flag( 16, 2, OSD_FLAG_BA, -3, 0); // MK Batt Warning
		1807	OSD_Element_Flag( 19, 2, OSD_FLAG_CF, 0, 0); // Carefree
		1808	OSD_Element_Flag( 19, 4, OSD_FLAG_AH, 0,-3); // Altitude Hold
		1809	OSD_Element_Flag( 19, 6, OSD_FLAG_PH, 0,-6); // Position Hold
		1810	OSD_Element_Flag( 19, 7, OSD_FLAG_CH, 0,-1); // Coming Home
		1811	OSD_Element_Flag( 16, 7, OSD_FLAG_S0, -3,-1); // GPS-Sat not ok (GPS NOT ok)
		1812
		1813
		1814	#ifdef OSD_DEMO
		1815	//-----------------
		1816	// Flags
		1817	//-----------------
		1818	OSD_Element_Flag_Label( 16, 2, OSD_FLAG_BA, true, -3,0); // DEMO
		1819
		1820	OSD_Element_Flag_Label( 19, 2, OSD_FLAG_CF, true, 0,0); // DEMO
		1821	OSD_Element_Flag_Label( 19, 4, OSD_FLAG_AH, true, 0,-3); // DEMO
		1822	OSD_Element_Flag_Label( 19, 6, OSD_FLAG_PH, true, 0,-6); // DEMO
		1823	OSD_Element_Flag_Label( 19, 7, OSD_FLAG_CH, true, 0,-1); // DEMO
		1824
		1825	OSD_Element_Flag_Label( 16, 7, OSD_FLAG_S0, true, -3,-1); // DEMO
		1826	#endif
		1827
		1828
		1829	return( ScreenName );
		1830	}
		1831
		1832
		1833
		1834
		1835	//--------------------------------------------------------------
		1836	// OSD-Screen "Status"
		1837	//
		1838	// nMode: 0 = update values
		1839	// 1 = redraw labels and update values
		1840	//--------------------------------------------------------------
		1841	const char * OSD_Screen_MKStatus( uint8_t nMode )
		1842	{
		1843	const char *ScreenName = PSTR("MK-Status");
		1844	int8_t xoffs;
		1845
		1846	//-----------------------------------------
		1847	// REDRAW
		1848	// statische Screen Elemente die nicht
		1849	// jedesmal neu gezeichnet werden muessen
		1850	//-----------------------------------------
		1851	if( nMode == OSD_SCREEN_REDRAW )
		1852	{
		1853	// do things here for static screen elements like labels and so....
		1854
		1855	lcd_line ((66-3), 0, (66-3), 9, 1); // Linie Vertikal links
		1856	lcd_line ((156+3), 0, (156+3), 9, 1); // Linie Vertikal rechts
		1857	lcd_line (0, 10, 127, 10, 1); // Linie Horizontal
		1858
		1859	//lcdx_printp_at( 8, 0, PSTR("Status"), MNORMAL, -3,0); // oben, mitte Text
		1860	lcdx_printp_at( 13, 0, PSTR("A"), MNORMAL, -4,0); // oben, mitte "A"
		1861	}
		1862
		1863
		1864	//-----------------
		1865	// Oben: Batt Level (Volt)
		1866	//-----------------
		1867	OSD_Element_BattLevel2( 0, 0, 0,0 );
		1868
		1869	//-----------------
		1870	// Strom
		1871	//-----------------
		1872	writex_ndigit_number_u_10th( 7, 0, naviData->Current, 4, 0,MNORMAL, 1,0); // Strom mit Nachkomma
		1873
		1874	//-----------------
		1875	// Oben: Flugzeit
		1876	//-----------------
		1877	write_time(16, 0, naviData->FlyingTime);
		1878
		1879	//-----------------
		1880	// Flags
		1881	//-----------------
		1882	xoffs = -7;
		1883	OSD_Element_Flag( 19, 2, OSD_FLAG_CF, 0+xoffs, 0); // Carefree
		1884	OSD_Element_Flag( 19, 4, OSD_FLAG_AH, 0+xoffs,-3); // Altitude Hold
		1885	OSD_Element_Flag( 19, 6, OSD_FLAG_PH, 0+xoffs,-6); // Position Hold
		1886	OSD_Element_Flag( 19, 7, OSD_FLAG_CH, 0+xoffs,-1); // Coming Home
		1887
		1888	xoffs -= 4;
		1889	OSD_Element_Flag( 16, 2, OSD_FLAG_BA, -3+xoffs, 0); // MK Batt Warning
		1890	OSD_Element_Flag( 16, 4, OSD_FLAG_EL, -3+xoffs,-3); // Emergency Landing
		1891	OSD_Element_Flag( 16, 6, OSD_FLAG_RL, -3+xoffs,-6); // Range Limit
		1892	OSD_Element_Flag( 16, 7, OSD_FLAG_S0, -3+xoffs,-1); // GPS-Sat not ok (GPS NOT ok)
		1893
		1894	xoffs -= 4;
		1895	OSD_Element_Flag( 12, 2, OSD_FLAG_CA, 0+xoffs, 0); // Calibrate
		1896	OSD_Element_Flag( 12, 4, OSD_FLAG_ST, 0+xoffs,-3); // Start
		1897	OSD_Element_Flag( 12, 6, OSD_FLAG_MR, 0+xoffs,-6); // Motor Run
		1898	OSD_Element_Flag( 12, 7, OSD_FLAG_FY, 0+xoffs,-1); // Fly
		1899
		1900	xoffs -= 4;
		1901	OSD_Element_Flag( 9, 2, OSD_FLAG_O1, -2+xoffs, 0); // Out1
		1902	OSD_Element_Flag( 9, 4, OSD_FLAG_O2, -2+xoffs,-3); // Out2
		1903	OSD_Element_Flag( 9, 6, OSD_FLAG_TR, -2+xoffs,-6); // Target Reached
		1904	OSD_Element_Flag( 9, 7, OSD_FLAG_MC, -2+xoffs,-1); // Manual Control
		1905
		1906	xoffs -= 4;
		1907	OSD_Element_Flag( 6, 2, OSD_FLAG_TU, -4+xoffs, 0); // Vario Trim Up
		1908	OSD_Element_Flag( 6, 4, OSD_FLAG_TD, -4+xoffs,-3); // Vario Trim Down
		1909	OSD_Element_Flag( 6, 6, OSD_FLAG_FR, -4+xoffs,-6); // Free
		1910	OSD_Element_Flag( 6, 7, OSD_FLAG_SL, -4+xoffs,-1); // No Serial Link
		1911
		1912
		1913	#ifdef OSD_DEMO
		1914	//-----------------
		1915	// Flags
		1916	//-----------------
		1917	/*
		1918	PSTR("AH"), // OSD_FLAG_AH Altitue Hold
		1919	PSTR("PH"), // OSD_FLAG_PH Position Hold
		1920	PSTR("CF"), // OSD_FLAG_CF Care Free
		1921	PSTR("CH"), // OSD_FLAG_CH Coming Home
		1922	PSTR("o1"), // OSD_FLAG_O1 Out1
		1923	PSTR("o2"), // OSD_FLAG_O2 Out2
		1924	PSTR("BA"), // OSD_FLAG_BA LowBat warning (MK)
		1925	PSTR("CA"), // OSD_FLAG_CA Calibrate
		1926	PSTR("ST"), // OSD_FLAG_ST Start
		1927	PSTR("MR"), // OSD_FLAG_MR Motor Run
		1928	PSTR("FY"), // OSD_FLAG_FY Fly
		1929	PSTR("EL"), // OSD_FLAG_EL Emergency Landing
		1930	PSTR("FS"), // OSD_FLAG_FS RX Failsave Active
		1931	PSTR("GP"), // OSD_FLAG_GP GPS Ok
		1932	PSTR("S!") // OSD_FLAG_S0 GPS-Sat not ok (GPS NOT ok)
		1933	PSTR("TU"), // OSD_FLAG_TU Vario Trim Up
		1934	PSTR("TD"), // OSD_FLAG_TD Vario Trim Down
		1935	PSTR("FR"), // OSD_FLAG_FR Free
		1936	PSTR("RL"), // OSD_FLAG_RL Range Limit
		1937	PSTR("SL"), // OSD_FLAG_SL No Serial Link
		1938	PSTR("TR"), // OSD_FLAG_TR Target Reached
		1939	PSTR("MC") // OSD_FLAG_MC Manual Control
		1940	*/
		1941	xoffs = -7;
		1942	OSD_Element_Flag_Label( 19, 2, OSD_FLAG_CF, true, 0+xoffs, 0); // DEMO: Carefree
		1943	OSD_Element_Flag_Label( 19, 4, OSD_FLAG_AH, true, 0+xoffs,-3); // DEMO: Altitude Hold
		1944	OSD_Element_Flag_Label( 19, 6, OSD_FLAG_PH, true, 0+xoffs,-6); // DEMO: Position Hold
		1945	OSD_Element_Flag_Label( 19, 7, OSD_FLAG_CH, true, 0+xoffs,-1); // DEMO: Coming Home
		1946
		1947	xoffs -= 4;
		1948	OSD_Element_Flag_Label( 16, 2, OSD_FLAG_BA, true, -3+xoffs, 0); // DEMO: MK Batt Warning
		1949	OSD_Element_Flag_Label( 16, 4, OSD_FLAG_EL, true, -3+xoffs,-3); // DEMO: Emergency Landing
		1950	OSD_Element_Flag_Label( 16, 6, OSD_FLAG_RL, true, -3+xoffs,-6); // DEMO: Range Limit
		1951	OSD_Element_Flag_Label( 16, 7, OSD_FLAG_S0, true, -3+xoffs,-1); // DEMO: GPS-Sat not ok (GPS NOT ok)
		1952
		1953	xoffs -= 4;
		1954	OSD_Element_Flag_Label( 12, 2, OSD_FLAG_CA, true, 0+xoffs, 0); // DEMO: Calibrate
		1955	OSD_Element_Flag_Label( 12, 4, OSD_FLAG_ST, true, 0+xoffs,-3); // DEMO: Start
		1956	OSD_Element_Flag_Label( 12, 6, OSD_FLAG_MR, true, 0+xoffs,-6); // DEMO: Motor Run
		1957	OSD_Element_Flag_Label( 12, 7, OSD_FLAG_FY, true, 0+xoffs,-1); // DEMO: Fly
		1958
		1959	xoffs -= 4;
		1960	OSD_Element_Flag_Label( 9, 2, OSD_FLAG_O1, true, -2+xoffs, 0); // DEMO: Out1
		1961	OSD_Element_Flag_Label( 9, 4, OSD_FLAG_O2, true, -2+xoffs,-3); // DEMO: Out2
		1962	OSD_Element_Flag_Label( 9, 6, OSD_FLAG_TR, true, -2+xoffs,-6); // DEMO: Target Reached
		1963	OSD_Element_Flag_Label( 9, 7, OSD_FLAG_MC, true, -2+xoffs,-1); // DEMO: Manual Control
		1964
		1965	xoffs -= 4;
		1966	OSD_Element_Flag_Label( 6, 2, OSD_FLAG_TU, true, -4+xoffs, 0); // DEMO: Vario Trim Up
		1967	OSD_Element_Flag_Label( 6, 4, OSD_FLAG_TD, true, -4+xoffs,-3); // DEMO: Vario Trim Down
		1968	OSD_Element_Flag_Label( 6, 6, OSD_FLAG_FR, true, -4+xoffs,-6); // DEMO: Free
		1969	OSD_Element_Flag_Label( 6, 7, OSD_FLAG_SL, true, -4+xoffs,-1); // DEMO: No Serial Link
		1970
		1971	#endif
		1972
		1973
		1974	return( ScreenName );
		1975	}
		1976
		1977
		1978
		1979	//##############################################################
		1980	#ifdef OSD_DEBUG_SCREEN
		1981	//##############################################################
		1982
		1983	//**************************************************************
		1984	//* OSD_DEBUG_SCREEN - Experimental-Code usw.
		1985	//* - nicht fuer die Oeffentlichkeit bestimmt
		1986	//* - gesteuert ueber define OSD_DEBUG_SCREEN
		1987	//**************************************************************
		1988
		1989
		1990	//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
		1991	// NOTIZEN
		1992	//
		1993	// 1. Thema: Motorwerte abfragen
		1994	//
		1995	// ja, auf die gleiche Weise wie man an die Config Parameter kommt.
		1996	//
		1997	// SwitchToFC();
		1998	// SendOutData( 'u', ADDRESS_FC, BL-Adresse, &tmp_dat, 1);
		1999	//
		2000	// Die Daten kommen dann in der Form:
		2001	// typedef struct
		2002	// {
		2003	// uint8_t Version; // the version of the BL (0 = old)
		2004	// uint8_t SetPoint; // written by attitude controller
		2005	// uint8_t SetPointLowerBits; // for higher Resolution of new BLs
		2006	// uint8_t State; // 7 bit for I2C error counter, highest bit indicates if motor is present
		2007	// uint8_t ReadMode; // select data to read
		2008	// // the following bytes must be exactly in that order!
		2009	// uint8_t Current; // in 0.1 A steps, read back from BL
		2010	// uint8_t MaxPWM; // read back from BL -> is less than 255 if BL is in current limit, not running (250) or starting (40)
		2011	// int8_t Temperature; // old BL-Ctrl will return a 255 here, the new version the temp. in ?C
		2012	// } __attribute__((packed)) MotorData_t;
		2013	//
		2014	//
		2015	// kennst Du die Seite?:http://www.mikrokopter.de/ucwiki/en/SerialProtocol?highlight=%28%28----%28-%29%28\r%29%3F\n%29%28.%29CategoryCoding%29#en.2BAC8-SerialCommands.Flight-Ctrl
		2016	//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
		2017
		2018
		2019	//--------------------------------------------------------------
		2020	//--------------------------------------------------------------
		2021	uint8_t xload_setting( uint8_t setting )
		2022	{
		2023	mode = 'Q'; // Settings
		2024	uint8_t timeout = 50;
		2025	rxd_buffer_locked = FALSE;
		2026
		2027	while (!rxd_buffer_locked && timeout)
		2028	{
		2029	SendOutData ('q', ADDRESS_FC, 1, &setting, 1);
		2030	// _delay_ms(50);
		2031	timer = 20;
		2032	while (timer > 0);
		2033	timeout--;
		2034	}
		2035
		2036	if (timeout != 0)
		2037	{
		2038	Decode64 ();
		2039	setting = *pRxData;
		2040	mk_param_struct = (mk_param_struct_t *) (pRxData + 1) ;
		2041	}
		2042	else
		2043	{ // timeout occured
		2044	// lcd_printp_at (0, 2, PSTR("Fehler: keine Daten"), 0);
		2045	lcd_puts_at(0, 2, strGet(OSD_ERROR), 0);
		2046	timer = 100;
		2047	while (timer > 0);
		2048	setting = 255;
		2049	}
		2050	return setting;
		2051	}
		2052
		2053
		2054	//--------------------------------------------------------------
		2055	//--------------------------------------------------------------
		2056	const char * OSD_Screen_Debug( uint8_t nMode )
		2057	{
		2058	const char *ScreenName = PSTR("Debug");
		2059
		2060	static s16 min_debug = 0;
		2061	static s16 max_debug = 0;
		2062	static uint16_t debug_count = 0;
		2063
		2064	//-----------------------------------------
		2065	// REDRAW
		2066	// statische Screen Elemente die nicht
		2067	// jedesmal neu gezeichnet werden muessen
		2068	//-----------------------------------------
		2069	if( nMode == OSD_SCREEN_REDRAW )
		2070	{
		2071	// do things here for static screen elements like labels and so....
		2072	min_debug = 0;
		2073	max_debug = 0;
		2074	}
		2075
		2076	lcd_printp_at( 0, 0, PSTR("Debug"), 0);
		2077
		2078
		2079	debug_count++;
		2080
		2081	if( naviData->Variometer < min_debug ) min_debug = naviData->Variometer;
		2082	if( naviData->Variometer > max_debug ) max_debug = naviData->Variometer;
		2083
		2084	write_ndigit_number_s ( 8, 1, (naviData->Variometer), 12, 0,MNORMAL); // s16 Variometer;
		2085	write_ndigit_number_s ( 8, 2, (min_debug), 12, 0,MNORMAL); // s16 Variometer;
		2086	write_ndigit_number_s ( 8, 3, (max_debug), 12, 0,MNORMAL); // s16 Variometer;
		2087
		2088	write_ndigit_number_u ( 8, 5, (debug_count), 12, 0,MNORMAL); //
		2089	//write_ndigit_number_u ( 8, 6, (timer), 12, 0,MNORMAL); //
		2090
		2091	//draw_variometer2( 6, 19, 7, 21, naviData->Variometer);
		2092
		2093	return( ScreenName );
		2094	}
		2095	//##############################################################
		2096	#endif // OSD_DEBUG_SCREEN
		2097	//##############################################################
		2098
		2099
		2100
		2101	//--------------------------------------------------------------
		2102	// ehemals: OSD_ALTITUDE,Config.OSD_ScreenMode == 0
		2103	//--------------------------------------------------------------
		2104	const char * OSD_Screen_OSD0( uint8_t nMode )
		2105	{
		2106	const char *ScreenName = PSTR("OSD0");
		2107	//uint8_t xoffs;
		2108
		2109	//-----------------------------------------
		2110	// REDRAW static screen elements
		2111	//-----------------------------------------
		2112	if( nMode == OSD_SCREEN_REDRAW )
		2113	{
		2114	// do things here for static screen elements like labels and so....
		2115	}
		2116
		2117	OSD_Element_AltitudeControl ( 0, 3);
		2118	OSD_Element_Altitude ( 11, 3, 0);
		2119	OSD_Element_BatteryLevel ( 0, 7, 0);
		2120	OSD_Element_Capacity ( 13, 7);
		2121	OSD_Element_Current ( 8, 7);
		2122	OSD_Element_CareFree ( 0, 5);
		2123	OSD_Element_CompassDegree ( 13, 0, 0);
		2124	OSD_Element_CompassDirection( 18, 0);
		2125	OSD_Element_CompassRose ( 12, 1);
		2126	OSD_Element_FlyingTime ( 0, 1);
		2127	OSD_Element_GroundSpeed ( 0, 0);
		2128	OSD_Element_HomeCircle ( 16, 4, 5, 0, 0,0);
		2129	OSD_Element_HomeDegree ( 12, 4);
		2130	OSD_Element_HomeDistance ( 10, 5, 0);
		2131	OSD_Element_Target ( 10, 6, 0);
		2132	//OSD_Element_TargetDegree ( x, y);
		2133	OSD_Element_WayPoint ( 5, 6);
		2134	OSD_Element_LED1Output ( 0, 6);
		2135	OSD_Element_LED2Output ( 3, 6);
		2136	//OSD_Element_Manuell ( x, y);
		2137	OSD_Element_NaviMode ( 0, 4);
		2138	//OSD_Element_RCIntensity ( x, y);
		2139	OSD_Element_VarioWert ( 12, 2);
		2140	OSD_Element_SatsInUse ( 18, 2, 0);
		2141	OSD_Element_StatusFlags ( 0, 2);
		2142	OSD_Element_Variometer ( 9, 0);
		2143
		2144	return( ScreenName );
		2145	}
		2146
		2147
		2148
		2149
		2150	//--------------------------------------------------------------
		2151	// ehemals: OSD_ALTITUDE,Config.OSD_ScreenMode == 1
		2152	//--------------------------------------------------------------
		2153	const char * OSD_Screen_OSD1( uint8_t nMode )
		2154	{
		2155	const char *ScreenName = PSTR("OSD1");
		2156	//uint8_t xoffs;
		2157
		2158	//-----------------------------------------
		2159	// REDRAW static screen elements
		2160	//-----------------------------------------
		2161	if( nMode == OSD_SCREEN_REDRAW )
		2162	{
		2163	// do things here for static screen elements like labels and so....
		2164	}
		2165
		2166	//OSD_Element_AltitudeControl( x, y);
		2167	OSD_Element_Altitude ( 1, 1, 1);
		2168	OSD_Element_BatteryLevel ( 0, 7, 1);
		2169	OSD_Element_Capacity ( 13, 7);
		2170	OSD_Element_Current ( 8, 7);
		2171	//OSD_Element_CareFree ( x, y);
		2172	OSD_Element_CompassDegree ( 13, 0, 1);
		2173	OSD_Element_CompassDirection( 18, 0);
		2174	OSD_Element_CompassRose ( 12, 1);
		2175	OSD_Element_FlyingTime ( 7, 6);
		2176	OSD_Element_GroundSpeed ( 0, 0);
		2177	OSD_Element_HomeCircle ( 1, 3, 7, 0, 0,0);
		2178	OSD_Element_HomeDegree ( 8, 3);
		2179	OSD_Element_HomeDistance ( 7, 2, 1);
		2180	//OSD_Element_Target ( x, y, 1);
		2181	//OSD_Element_TargetDegree ( x, y);
		2182	//OSD_Element_WayPoint ( x, y);
		2183	//OSD_Element_LED1Output ( x, y);
		2184	//OSD_Element_LED2Output ( x, y);
		2185	//OSD_Element_Manuell ( x, y);
		2186	OSD_Element_NaviMode ( 8, 5);
		2187	OSD_Element_RCIntensity ( 15, 6);
		2188	OSD_Element_VarioWert ( 15, 2);
		2189	OSD_Element_SatsInUse ( 8, 4, 1);
		2190	//OSD_Element_StatusFlags ( x, y);
		2191	OSD_Element_Variometer ( 9, 0);
		2192
		2193	return( ScreenName );
		2194	}
		2195
		2196
		2197	//--------------------------------------------------------------
		2198	// ehemals: OSD_ALTITUDE,Config.OSD_ScreenMode == 2
		2199	//--------------------------------------------------------------
		2200	const char * OSD_Screen_OSD2( uint8_t nMode )
		2201	{
		2202	const char *ScreenName = PSTR("OSD2");
		2203	//uint8_t xoffs;
		2204
		2205	//-----------------------------------------
		2206	// REDRAW static screen elements
		2207	//-----------------------------------------
		2208	if( nMode == OSD_SCREEN_REDRAW )
		2209	{
		2210	// do things here for static screen elements like labels and so....
		2211	}
		2212
		2213	OSD_Element_AltitudeControl ( 0, 1);
		2214	OSD_Element_Altitude ( 0, 4, 2);
		2215	OSD_Element_BatteryLevel ( 13, 7, 2);
		2216	OSD_Element_Capacity ( 0, 7);
		2217	OSD_Element_Current ( 8, 7);
		2218	OSD_Element_CareFree ( 0, 3);
		2219	OSD_Element_CompassDegree ( 12, 3, 2);
		2220	//OSD_Element_CompassDirection( x, y);
		2221	//OSD_Element_CompassRose ( x, y);
		2222	OSD_Element_FlyingTime ( 15, 5);
		2223	//OSD_Element_GroundSpeed ( x, y);
		2224	OSD_Element_HomeCircle ( 16, 0, 5, 0, 0,0);
		2225	OSD_Element_HomeDegree ( 11, 5);
		2226	OSD_Element_HomeDistance ( 0, 5, 2);
		2227	OSD_Element_Target ( 0, 6, 2);
		2228	OSD_Element_TargetDegree ( 11, 6);
		2229	//OSD_Element_WayPoint ( x, y);
		2230	OSD_Element_LED1Output ( 12, 2);
		2231	OSD_Element_LED2Output ( 14, 2);
		2232	//OSD_Element_Manuell ( x, y);
		2233	OSD_Element_NaviMode ( 0, 2);
		2234	//OSD_Element_RCIntensity ( x, y);
		2235	OSD_Element_VarioWert ( 15, 4);
		2236	OSD_Element_SatsInUse ( 10, 0, 2);
		2237	OSD_Element_StatusFlags ( 0, 0);
		2238	//OSD_Element_Variometer ( x, y);
		2239
		2240	return( ScreenName );
		2241	}
		2242
		2243
		2244	//--------------------------------------------------------------
		2245	//--------------------------------------------------------------
		2246	const char * OSD_Screen_3DLage( uint8_t nMode )
		2247	{
		2248	const char *ScreenName = PSTR("3D Lage");
		2249	uint16_t head_home;
		2250	uint8_t Nick;
		2251	uint8_t Roll;
		2252
		2253	//-----------------------------------------
		2254	// REDRAW static screen elements
		2255	//-----------------------------------------
		2256	if( nMode == OSD_SCREEN_REDRAW )
		2257	{
		2258	// do things here for static screen elements like labels and so....
		2259	}
		2260
		2261	head_home = (naviData->HomePositionDeviation.Bearing + 360 - naviData->CompassHeading) % 360;
		2262
		2263	//lcd_cls ();
		2264
		2265	lcd_line(26,32,100,32,1); // horizontal //
		2266	lcd_line(63,0,63,63,1); // vertical //
		2267	//lcd_puts_at(12, 7, strGet(KEYLINE5), 0);
		2268
		2269	// 45' Angel
		2270	lcd_line(61,11,65,11,1); // -- //
		2271	lcd_line(40,30,40,34,1); // \| //
		2272	lcd_line(86,30,86,34,1); // \| //
		2273	lcd_line(61,53,65,53,1); // -- //
		2274
		2275	lcd_puts_at(9, 0, strGet(OSD_3D_V), 0); // V
		2276	lcd_puts_at(3, 3, strGet(OSD_3D_L), 0); // L
		2277	lcd_puts_at(17, 3, strGet(OSD_3D_R), 0); // R
		2278	lcd_puts_at(9, 7, strGet(OSD_3D_H), 0); // H
		2279
		2280	lcd_puts_at(0, 0, strGet(OSD_3D_NICK), 0); // Ni
		2281	write_ndigit_number_s (2, 0, naviData->AngleNick, 3, 0,0);
		2282	lcd_putc (5, 0, 0x1e, 0); // degree symbol
		2283
		2284	lcd_puts_at(0, 7, strGet(OSD_3D_ROLL), 0); // Ro
		2285	write_ndigit_number_s (2, 7, naviData->AngleRoll, 3, 0,0);
		2286	lcd_putc (5, 7, 0x1e, 0); // degree symbol
		2287
		2288	lcd_puts_at(13, 0, strGet(OSD_3D_COMPASS), 0);
		2289	//write_ndigit_number_s (15, 0,head_home, 3, 0);
		2290	write_ndigit_number_u (15, 0, naviData->CompassHeading, 3, 0,0);
		2291	lcd_putc (18, 0, 0x1e, 0); // degree symbol
		2292	lcd_printp_at (19, 0, (const char *) (pgm_read_word ( &(directions_p[heading_conv(naviData->CompassHeading)]))), 0);
		2293
		2294	Nick = ((-naviData->AngleNick/2)+32);
		2295	Roll = ((-naviData->AngleRoll/2)+63);
		2296
		2297	lcd_ellipse ( old_AngleRoll, old_AngleNick, 9, 8, 0);
		2298	lcd_ellipse_line( old_AngleRoll, old_AngleNick, 8, 7, old_hh, 0);
		2299
		2300	lcd_ellipse ( Roll, Nick, 9, 8, 1);
		2301	lcd_ellipse_line( Roll, Nick, 8, 7, head_home, 1);
		2302
		2303	// remember last values (3DL)
		2304	old_hh = head_home;
		2305	old_AngleNick = Nick;
		2306	old_AngleRoll = Roll;
		2307
		2308	return( ScreenName );
		2309	}
		2310
		2311
		2312	//--------------------------------------------------------------
		2313	//--------------------------------------------------------------
		2314	const char * OSD_Screen_Statistics( uint8_t nMode )
		2315	{
		2316	const char *ScreenName = PSTR("Statistics");
		2317	uint8_t line = 0;
		2318
		2319	//-----------------------------------------
		2320	// REDRAW static screen elements
		2321	//-----------------------------------------
		2322	/*
		2323	if( nMode == OSD_SCREEN_REDRAW )
		2324	{
		2325	// do things here for static screen elements like labels and so....
		2326	}
		2327	*/
		2328
		2329	//---------------------------
		2330	// max Altitude
		2331	lcd_puts_at (0, line, strGet(STATS_ITEM_0), MNORMAL);
		2332	write_ndigit_number_s (14, line, max_Altimeter / (30 / AltimeterAdjust), 4, 0,MNORMAL);
		2333	lcdx_putc (18, line, 'm', MNORMAL, 2,0);
		2334
		2335	//---------------------------
		2336	// max Speed
		2337	// max_GroundSpeed = 1;
		2338	lcd_puts_at (0, ++line, strGet(STATS_ITEM_1), MNORMAL);
		2339	write_ndigit_number_u (15, line, (uint16_t) (((uint32_t) max_GroundSpeed * (uint32_t) 9) / (uint32_t) 250), 3, 0,MNORMAL);
		2340	lcdx_printp_at(18, line, PSTR("kmh"), MNORMAL, 2,0);
		2341
		2342	//---------------------------
		2343	// max Distance
		2344	// max_Distance = 64512;
		2345	lcd_puts_at (0, ++line, strGet(STATS_ITEM_2), MNORMAL);
		2346	write_ndigit_number_u (14, line, max_Distance / 10, 4, 0,MNORMAL);
		2347	lcdx_putc (18, line, 'm', MNORMAL, 2,0);
		2348
		2349	//---------------------------
		2350	// max time
		2351	// max_FlyingTime = 3600;
		2352	lcd_puts_at (0, ++line, strGet(STATS_ITEM_4), MNORMAL);
		2353	write_time (13, line, max_FlyingTime);
		2354
		2355	//---------------------------
		2356	// min voltage
		2357	lcd_puts_at (0, ++line, strGet(STATS_ITEM_3), MNORMAL);
		2358	if( min_UBat==255 )
		2359	lcd_printp_at(14, line, PSTR(" 0"), MNORMAL);
		2360	else
		2361	write_ndigit_number_u_10th (14, line, min_UBat, 3, 0,MNORMAL);
		2362	lcdx_putc (18, line, 'V', MNORMAL, 2,0);
		2363
		2364	//---------------------------
		2365	// max Current
		2366	// max_Current = 1000;
		2367	lcd_puts_at (0, ++line, strGet(STATS_ITEM_5), MNORMAL);
		2368	write_ndigit_number_u_10th (13, line, max_Current, 4, 0,MNORMAL);
		2369	lcdx_putc (18, line, 'A', MNORMAL, 2,0);
		2370
		2371	//---------------------------
		2372	// Used Capacity
		2373	lcd_puts_at (0, ++line, strGet(STATS_ITEM_6), MNORMAL);
		2374	write_ndigit_number_u (14, line, max_Capacity, 4, 0,MNORMAL);
		2375	lcdx_printp_at(18, line, PSTR("mAh"), MNORMAL, 2,0);
		2376
		2377	return( ScreenName );
		2378	}
		2379
		2380
		2381	//--------------------------------------------------------------
		2382	//--------------------------------------------------------------
		2383	void print_statistics (void)
		2384	{
		2385	lcd_cls ();
		2386	lcd_puts_at(12, 7, strGet(ENDE), 0);
		2387
		2388	OSD_Screen_Statistics( OSD_SCREEN_REDRAW );
		2389
		2390	while (!get_key_press (1 << KEY_ESC))
		2391	timer = TIMEOUT;
		2392
		2393	COSD_FLAGS2 &= ~COSD_WASFLYING;
		2394	get_key_press(KEY_ALL);
		2395	lcd_cls();
		2396	}
		2397
		2398
		2399	//-----------------------------------------------------------
		2400	//-----------------------------------------------------------
		2401	void OSD_Info( uint8_t ScreenNum, const char *ScreenName)
		2402	{
		2403	lcd_frect( 0, 36, 127, 10, 0); // clear
		2404	lcd_frect( 0, 34, 4, 4, 0); // clear links
		2405	lcd_frect( 0, 40, 127, 24, 1); // Box
		2406	lcd_frect( 10, 36, 108, 4, 1); // Filler oben
		2407	lcd_fcircle( 8, 39, 7, 1); // Links
		2408	lcd_fcircle( 121, 41, 5, 1); // Rechts
		2409
		2410	lcd_line ( 4, 51, 122, 51, 0); // Linie mitte
		2411
		2412	//-----------------------
		2413	// ScreenNummer: ScreenName
		2414	//-----------------------
		2415	write_ndigit_number_s ( 1, 5, ScreenNum, 2, 1,2);
		2416	lcd_printp_at( 3, 5, PSTR(":"), 2);
		2417	lcd_printp_at( 5, 5, ScreenName, 2);
		2418
		2419	//-----------------------
		2420	// Key's
		2421	//-----------------------
		2422	lcd_puts_at(0, 7, strGet(KEYLINE3), 2);
		2423	lcd_printp_at (17, 7, PSTR("Info"), 2);
		2424
		2425	do
		2426	{
		2427	timer = TIMEOUT;
		2428	_delay_ms(50);
		2429	} while ( !( (get_key_press (1 << KEY_ENTER)) \|\| (get_key_press (1 << KEY_ESC)) \|\| (get_key_press (1 << KEY_PLUS)) \|\| (get_key_press (1 << KEY_MINUS)) ) );
		2430	}
		2431
		2432
		2433
		2434	//##############################################################
		2435	//# OSD MAIN LOOP
		2436	//##############################################################
		2437
		2438	//--------------------------------------------------------------
		2439	// OSD MAIN LOOP
		2440	//--------------------------------------------------------------
		2441	void osd( uint8_t ShowMode )
		2442	{
		2443	uint8_t flag;
		2444	uint8_t tmp_dat;
		2445	uint8_t ScreenRefresh;
		2446	uint8_t MAX_OSD_Screens;
		2447	//uint8_t status; // FC Kommunikation
		2448
		2449	const char *ScreenName = PSTR("");
		2450
		2451	lcd_cls();
		2452
		2453	//----------------------------------------
		2454	// NC Hardware needed
		2455	//----------------------------------------
		2456	if( hardware == FC )
		2457	{
		2458	lcd_puts_at(0, 3, strGet(ONLY_NC), 0); // Nur mit NC
		2459	timer = 100;
		2460	while (timer > 0);
		2461	return;
		2462	}
		2463
		2464
		2465	/*
		2466	//-----------------------------------------------------------------------------------------------
		2467	// 07.03.2013 OG: del
		2468	// Dieser Teil hat immer wieder Probleme bereitet bei der Verbindung des PKT-OSD zum MK da
		2469	// Timeouts zustande kamen. Eine Recherche im Code ergab, dass die Nutzdaten die
		2470	// hierueber bezogen werden sich lediglich auf Flags_ExtraConfig beschraenkten (CFG2_HEIGHT_LIMIT).
		2471	// Siehe dazu untere Kommentare.
		2472	//
		2473	// Der negative Effekt moeglicher Timeouts und Verzoegerungen sind es aktuell nicht Wert
		2474	// CFG2_HEIGHT_LIMIT zu unterstuetzen. Dieses Feature ist erstmal raus.
		2475	//
		2476	// Falls gewuenscht wird, dass CFG2_HEIGHT_LIMIT wieder in das PKT-OSD kommt muss
		2477	// es zuverlaessig an anderer Stelle implementiert werden - und zwar nicht in osd.c
		2478	// weil es eine statische FC-Information ist (ggf. beim Verbindungsaufbau PKT <-> MK).
		2479	//
		2480	// Hat auch aktuell Auswirkung auf den Code OSD_Element_AltitudeControl()
		2481	//
		2482	lcd_printp_at( 0, 3, PSTR("connecting MK..."), 0);
		2483
		2484	SwitchToFC();
		2485
		2486	status = load_setting(0xff);
		2487
		2488	if( status == 255 )
		2489	{
		2490	lcd_puts_at(0, 0, strGet(NO_SETTINGS), 0); // Keine Settings
		2491	_delay_ms(2000);
		2492	}
		2493	Flags_ExtraConfig = mk_param_struct->ExtraConfig; // OG: wird in osd.c nur verwendet von: OSD_Element_AltitudeControl()
		2494	Flags_GlobalConfig = mk_param_struct->GlobalConfig; // OG: wird nicht in osd.c verwendet
		2495	Flags_GlobalConfig3 = mk_param_struct->GlobalConfig3; // OG: wird nicht in osd.c verwendet
		2496	*/
		2497
		2498
		2499	rxd_buffer_locked = FALSE; // 07.03.2013 OG: fix
		2500	// es gab Probleme mit dem Empfang gueltiger NC-Daten, die zu unschoenen Starteffekten bei den
		2501	// OSD-Screens gefuehrt haben. Mit rxd_buffer_locked = FALSE vor SwitchToNC() ist das PKT wieder im 'Takt'
		2502
		2503	SwitchToNC();
		2504
		2505	mode = 'O';
		2506
		2507	// disable debug...
		2508	// RS232_request_mk_data (0, 'd', 0);
		2509	tmp_dat = 0;
		2510	SendOutData ('d', ADDRESS_ANY, 1, &tmp_dat, 1);
		2511
		2512	// request OSD Data from NC every 100ms
		2513	// RS232_request_mk_data (1, 'o', 100);
		2514	tmp_dat = 10;
		2515	OSD_active = true; // benoetigt f�r Navidata Ausgabe an SV2
		2516	SendOutData( 'o', ADDRESS_NC, 1, &tmp_dat, 1);
		2517
		2518
		2519	//-------------------------
		2520	// Clear statistics
		2521	//-------------------------
		2522	max_Altimeter = 0;
		2523	max_GroundSpeed = 0;
		2524	max_Distance = 0;
		2525	min_UBat = 255;
		2526	max_FlyingTime = 0;
		2527	CellIsChecked = 0;
		2528	cells = 0;
		2529	AkkuWarnThreshold = 0;
		2530	OldWP = 0;
		2531	NextWP = false;
		2532
		2533
		2534	//-------------------------
		2535	//-------------------------
		2536	MAX_OSD_Screens = 8;
		2537
		2538	#ifdef OSD_DEBUG_SCREEN
		2539	MAX_OSD_Screens += 1;
		2540	#endif
		2541
		2542	if( Config.OSD_ScreenMode >= MAX_OSD_Screens ) Config.OSD_ScreenMode = 0;
		2543
		2544
		2545	//-------------------------
		2546	// Timer & Flags
		2547	//-------------------------
		2548	ScreenRefresh = OSD_SCREEN_REDRAW;
		2549	flag = 0;
		2550	timer = TIMEOUT;
		2551	abo_timer = ABO_TIMEOUT;
		2552	timer2 = OSD_REFRESH_TIME;
		2553
		2554
		2555	do
		2556	{
		2557	if( rxd_buffer_locked )
		2558	{
		2559	timer = TIMEOUT;
		2560	Decode64 ();
		2561	naviData = (NaviData_t *) pRxData;
		2562
		2563
		2564	//----------------------------------
		2565	// Winkel zu Home
		2566	//----------------------------------
		2567	if( Config.OSD_HomeMKView == 1 )
		2568	heading_home = (naviData->HomePositionDeviation.Bearing + 360 - naviData->CompassHeading) % 360;
		2569	else
		2570	heading_home = (naviData->CompassHeading - naviData->HomePositionDeviation.Bearing + 360 ) % 360;
		2571
		2572
		2573	//----------------------------------
		2574	// speichere letzte GPS-Positionen
		2575	//----------------------------------
		2576	GPS_Pos_t currpos;
		2577	currpos.Latitude = naviData->CurrentPosition.Latitude;
		2578	currpos.Longitude = naviData->CurrentPosition.Longitude;
		2579
		2580	if((currpos.Latitude != last5pos[0].Latitude)&&(currpos.Longitude != last5pos[0].Longitude))
		2581	{
		2582	last5pos[6] = last5pos[5];
		2583	last5pos[5] = last5pos[4];
		2584	last5pos[4] = last5pos[3];
		2585	last5pos[3] = last5pos[2];
		2586	last5pos[2] = last5pos[1];
		2587	last5pos[1] = last5pos[0];
		2588	last5pos[0] = currpos;
		2589	}
		2590
		2591	// 07.03.2013 OG: Speichere permanent letzte Position in Config
		2592	// wurde vorher nur in OSD_TimeOut() gemacht
		2593	Config.LastLatitude = currpos.Latitude; // speichere letzte Position in Config
		2594	Config.LastLongitude = currpos.Longitude; // speichere letzte Position in Config
		2595
		2596	flag = 1;
		2597
		2598	if (naviData->FCStatusFlags & FC_STATUS_MOTOR_RUN)
		2599	{ // should be engines running
		2600	// motors are on, assume we were/are flying
		2601	COSD_FLAGS2 \|= COSD_WASFLYING;
		2602	}
		2603
		2604
		2605	//----------------------------------
		2606	// remember statistics (only when engines running)
		2607	//----------------------------------
		2608	if( naviData->FCStatusFlags & FC_STATUS_MOTOR_RUN )
		2609	{
		2610	if (naviData->Altimeter > max_Altimeter) max_Altimeter = naviData->Altimeter;
		2611	if (naviData->GroundSpeed > max_GroundSpeed) max_GroundSpeed = naviData->GroundSpeed;
		2612	if (naviData->HomePositionDeviation.Distance > max_Distance) max_Distance = naviData->HomePositionDeviation.Distance;
		2613	if (naviData->FlyingTime > max_FlyingTime) max_FlyingTime = naviData->FlyingTime;
		2614	if (naviData->UBat < min_UBat) min_UBat = naviData->UBat;
		2615	if (naviData->Current > max_Current) max_Current = naviData->Current;
		2616	if (naviData->UsedCapacity > max_Capacity) max_Capacity = naviData->UsedCapacity;
		2617	}
		2618
		2619
		2620	//----------------------------------
		2621	// OSD-Screens
		2622	//----------------------------------
		2623	if( ScreenRefresh == OSD_SCREEN_REDRAW ) lcd_cls();
		2624
		2625	if( timer2 == 0 \|\| ScreenRefresh == OSD_SCREEN_REDRAW)
		2626	{
		2627	if( Config.OSD_ScreenMode == 0) ScreenName = OSD_Screen_General( ScreenRefresh );
		2628	else if( Config.OSD_ScreenMode == 1) ScreenName = OSD_Screen_Navigation( ScreenRefresh );
		2629	else if( Config.OSD_ScreenMode == 2) ScreenName = OSD_Screen_MKStatus( ScreenRefresh );
		2630	else if( Config.OSD_ScreenMode == 3) ScreenName = OSD_Screen_OSD0( ScreenRefresh );
		2631	else if( Config.OSD_ScreenMode == 4) ScreenName = OSD_Screen_OSD1( ScreenRefresh );
		2632	else if( Config.OSD_ScreenMode == 5) ScreenName = OSD_Screen_OSD2( ScreenRefresh );
		2633	else if( Config.OSD_ScreenMode == 6) ScreenName = OSD_Screen_3DLage( ScreenRefresh );
		2634	else if( Config.OSD_ScreenMode == 7) ScreenName = OSD_Screen_Statistics( ScreenRefresh );
		2635
		2636	#ifdef OSD_DEBUG_SCREEN
		2637	else if( Config.OSD_ScreenMode == (MAX_OSD_Screens-1) ) ScreenName = OSD_Screen_Debug( ScreenRefresh );
		2638	#endif
		2639
		2640	}
		2641	ScreenRefresh = OSD_SCREEN_REFRESH;
		2642
		2643	if( timer2 == 0 ) timer2 = OSD_REFRESH_TIME;
		2644
		2645
		2646	//-----------------------
		2647	// Key-Handler
		2648	//-----------------------
		2649
		2650	//if (get_key_press (1 << KEY_PLUS))
		2651	//{
		2652	// print_position ();
		2653	//}
		2654
		2655	if( get_key_press (1 << KEY_ENTER) ) // info
		2656	{
		2657	OSD_Info( Config.OSD_ScreenMode, ScreenName);
		2658	ScreenRefresh = OSD_SCREEN_REDRAW;
		2659	}
		2660
		2661	if (get_key_press (1 << KEY_MINUS)) // previous screen
		2662	{
		2663	if( Config.OSD_ScreenMode == 0 )
		2664	Config.OSD_ScreenMode = MAX_OSD_Screens-1;
		2665	else
		2666	Config.OSD_ScreenMode--;
		2667	ScreenRefresh = OSD_SCREEN_REDRAW;
		2668	}
		2669
		2670	if (get_key_press (1 << KEY_PLUS)) // next Screen
		2671	{
		2672	Config.OSD_ScreenMode++;
		2673	Config.OSD_ScreenMode = ( Config.OSD_ScreenMode >= MAX_OSD_Screens ? 0 : Config.OSD_ScreenMode );
		2674	ScreenRefresh = OSD_SCREEN_REDRAW;
		2675	}
		2676
		2677
		2678	//-----------------------
		2679	// Akku Warnung
		2680	//-----------------------
		2681	CheckMKLipo();
		2682
		2683	// if (naviData->UBat > MK_LowBat) //bei kurzzeitigen Schwankungen Beeper erst wieder aus wenn UBat 0,2 V h�her als Warnschwelle
		2684	// { //Beeper aus
		2685	// BeepTime = 0;
		2686	// BeepMuster = 0xFFFF;
		2687	// }
		2688	// Akku Warnung Ende
		2689
		2690
		2691	//-----------------------
		2692	// remember last values
		2693	//-----------------------
		2694	last_RC_Quality = naviData->RC_Quality;
		2695	last_UBat = naviData->UBat;
		2696	old_FCFlags = naviData->FCStatusFlags;
		2697
		2698	rxd_buffer_locked = FALSE;
		2699
		2700
		2701	//-----------------------
		2702	// abo_timer
		2703	//-----------------------
		2704	if (!abo_timer)
		2705	{ // renew abo every 3 sec
		2706	// request OSD Data from NC every 100ms
		2707	// RS232_request_mk_data (1, 'o', 100);
		2708	tmp_dat = 10;
		2709	SendOutData ('o', ADDRESS_NC, 1, &tmp_dat, 1);
		2710	abo_timer = ABO_TIMEOUT;
		2711	}
		2712
		2713	} //if (rxd_buffer_locked)
		2714
		2715	if (!timer)
		2716	{
		2717	OSD_Timeout(flag);
		2718	flag = 0;
		2719	ScreenRefresh = OSD_SCREEN_REDRAW;
		2720	}
		2721
		2722	} while (!get_key_press (1 << KEY_ESC));
		2723
		2724	OSD_active = false;
		2725	}

Subversion Repositories Projects

(root)/Transportables_Koptertool/branch/PKT/branch/GPL_PKT_V3_6_7f_FC090b/osd/osd.c - Rev 1934