/*
	FG_panel.ino  - pour ESP32 - version Afficheur TFT 480x320
	todo: renommer en FG_PFD
 
	par Silicium628
 
	Ce logiciel est libre et gratuit sous licence GNU GPL
 
---------------------------------------------------------------------------------------	
	Pour les #includes issus de l'univers Arduino (que je ne fournis pas), il faut voir au cas par cas.
	(drivers d'affichage en particulier)
 
---------------------------------------------------------------------------------------
	De petites images à placer sur la SDcard centrées sur les aérodromes proviennent de OpenStreetMap
 
	OpenStreetMap® est un ensemble de données ouvertes,
	disponibles sous la licence libre Open Data Commons Open Database License (ODbL)
	accordée par la Fondation OpenStreetMap (OSMF).
 
	Voir ce lien pour plus de détails :
	https://www.openstreetmap.org/copyright
 
---------------------------------------------------------------------------------------	
 
 
*/
 
 
/**
--------------------------------------------------------
CONCERNANT L'AFFICHAGE TFT : connexion :
 
( Pensez à configurer le fichier User_Setup.h de la bibliothèque ~/Arduino/libraries/TFT_eSPI/ )
 
// ESP32 pins used for the parallel interface TFT
#define TFT_CS   27  // Chip select control pin
#define TFT_DC   14  // Data Command control pin - must use a pin in the range 0-31
#define TFT_RST  26  // Reset pin
 
#define TFT_WR   12  // Write strobe control pin - must use a pin in the range 0-31
#define TFT_RD   13
 
#define TFT_D0   16  // Must use pins in the range 0-31 for the data bus
#define TFT_D1   4  // so a single register write sets/clears all bits
#define TFT_D2   2  // 23
#define TFT_D3   22
#define TFT_D4   21
#define TFT_D5   15 // 19
#define TFT_D6   25 // 18
#define TFT_D7   17
 
 
**/
 
	String version="12.3"; // fonction Autoland + Wifi Dialogue ND
 
// le numéro de version doit (depuis la 10.1) être identique à celui du ND (Navigation Display)	
 
#include <stdint.h>
#include <TFT_eSPI.h> // Hardware-specific library
#include "Free_Fonts.h"
 
#include "FS.h"
#include "SD.h"
#include "SPI.h"
 
#include "FG_data.h"
 
 
#include <WiFi.h>
 
// #include <WebServer.h>
#include "ESPAsyncWebServer.h"
 
 
/*
#include "BluetoothSerial.h"
 
#if !defined(CONFIG_BT_ENABLED) || !defined(CONFIG_BLUEDROID_ENABLED)
#error Bluetooth is not enabled! Please run `make menuconfig` to and enable it
#endif
 
BluetoothSerial SerialBT;
*/
 
 
const char* ssid = "FGpanel_srv"; 
const char* password = "72r4TsJ28";
 
AsyncWebServer server(80); // Create AsyncWebServer object on port 80
 
String argument_recu1;
 
TFT_eSPI TFT = TFT_eSPI(); // Configurer le fichier User_Setup.h de la bibliothèque TFT_eSPI au préalable
 
TFT_eSprite SPR_E = TFT_eSprite(&TFT);  // Declare Sprite object "SPR_11" with pointer to "TFT" object
TFT_eSprite SPR_N = TFT_eSprite(&TFT);
TFT_eSprite SPR_O = TFT_eSprite(&TFT);
TFT_eSprite SPR_S = TFT_eSprite(&TFT);	
 
//uint16_t s_width = TFT.Get_Display_Width();  
//uint16_t s_heigh = TFT.Get_Display_Height();
 
int16_t Ax_actu, Ay_actu; 
int16_t Bx_actu, By_actu;
 
 
// COULEURS RGB565
// Outil de sélection -> http://www.barth-dev.de/online/rgb565-color-picker/
 
#define NOIR   		0x0000
#define ROUGE  		0xF800
#define ROSE		0xFBDD
#define ORANGE 		0xFBC0
#define JAUNE   	0xFFE0
#define JAUNE_PALE  0xF7F4
#define VERT   		0x07E0
#define OLIVE		0x05A3
#define CYAN    	0x07FF
#define BLEU_CLAIR  0x455F
#define AZUR  		0x1BF9
#define BLEU   		0x001F
#define MAGENTA 	0xF81F
#define VIOLET1		0x781A
#define VIOLET2		0xECBE
#define GRIS_TRES_CLAIR 0xDEFB
#define GRIS_CLAIR  0xA534
#define GRIS   		0x8410
#define GRIS_FONCE  0x5ACB
#define GRIS_TRES_FONCE  0x2124
 
#define GRIS_AF 	0x51C5		// 0x3985
#define BLANC   	0xFFFF
 
 
// AVIONIQUE : Horizon Artificiel (HA):
 
#define HA_CIEL		0x33FE
#define HA_SOL		0xAA81 //0xDB60
 
//position et dimensions de l'horizon artificiel
 
#define HA_x0 210
#define HA_y0 130
#define HA_w 120 // demi largeur
#define HA_h 100	// demi hauteur
 
#define x_autopilot 320
 
// Width and height of sprite
#define SPR_W 14
#define SPR_H 14
 
 
/*
#define taille1 100000  //480*320*2
uint8_t data_ecran[taille1];
*/
 
uint32_t memo_micros = 0;
uint32_t temps_ecoule;
uint16_t nb_secondes=0;
 
float roulis;
float tangage;
 
int32_t altitude;
int32_t gnd_elv;
int32_t vitesse;
int32_t memo_vitesse;
int16_t dV;
int16_t acceleration;
int16_t vspeed;		// vitesse verticale
 
int16_t cap; 		// en degrés d'angle; direction actuelle du nez de l'avion
 
 
int16_t hdg1  = 150; // en degrés d'angle; consigne cap = Heading (HDG) Bug
int16_t memo_hdg1;
 
char var_array[5];	// 4 char + zero terminal - pour envoi par WiFi
 
// Nav1 -> pour VOR
int32_t nav1dst; // en mètres
uint32_t nav1frq;
float nav1radial; // 0..35900
uint16_t nav1radial_deg; // 0..359
 
 
// Nav2 -> pour ILS
int32_t nav2dst;
uint32_t nav2frq;
float nav2loc; 		// angle de déviation (erreur / axe de la piste) dans le plan horizontal
float nav2glide; 	// angle de descente (pente) vue depuis la balise
float nav2radial;
 
int16_t loc=0; 		// localizer
int16_t memo_loc=0;
 
int16_t gld=0; 		// glide
int16_t memo_gld=0;
 
int16_t num_bali=0; 
 
int16_t asel1 = 30; // consigne altitude
 
uint8_t SDcardOk=0;
uint16_t data_ok;
uint8_t gs_ok;
 
uint8_t premier_passage =1;
uint8_t attente_data=1;
 
uint8_t autoland=0;
 
//uint8_t premier_passage =1;
//uint8_t take_off_ok =0; // passe à 1 si altitude atteinte = 3000ft
 
 
 
float memo_R2;
int16_t memo_y0;
 
const int bouton1 = 36;  // attention: le GPIO 36 n'a pas de R de pullup interne, il faut en câbler une au +3V3
bool bouton1_etat;
bool memo_bouton1_etat;
 
 
 
// deux encodeurs rotatifs pas à pas
const int rot1a = 32;  // GPIO32 -> câbler une R au +3V3
const int rot1b = 33;  // GPIO33 -> câbler une R au +3V3
 
const int rot2a = 35;  // GPIO35 -> câbler une R au +3V3
const int rot2b = 34;  // GPIO34 -> câbler une R au +3V3
 
//const int led1 = 25; // GPIO15
 
 
#define TEMPO 5 // tempo anti-rebond pour l'acquisition des encodeurs rotatifs
volatile uint32_t timer1 = 0;
volatile uint32_t timer2 = 0;
 
uint16_t compteur1;
 
// TFT.setTextColor(TFT_BLACK, TFT_WHITE);
// TFT.drawLine(x0, y0, x1, y1, TFT_BLACK);
// TFT.fillTriangle(x0, y0, x1, y1, x2, y2, TFT_GREEN);
// TFT.drawRect(5, 3, 230, 119, TFT_BLACK);
// TFT.fillRect(5, 3, 230, 119, TFT_WHITE);
 
 
void RAZ_variables()
{
	roulis=0;
	tangage=0;
	altitude=0;
	gnd_elv=0;
	vitesse=0;
	vspeed=0;		
	cap=0; 		
	memo_hdg1=0;
	nav1dst=0;
	nav1radial=0;
	nav1radial_deg=0;
	nav2dst=0;
	nav2loc=0; 		
	nav2glide=0; 	
	loc=0;
	memo_loc=0;
	gld=0;
	memo_gld=0;
}
 
 
 
/** ***********************************************************************************
		IMAGE.bmp					
***************************************************************************************/
 
/**
Rappel et décryptage de la fonction Color_To_565 : (elle se trouve dans le fichier LCDWIKI_KBV.cpp)
 
//Pass 8-bit (each) R,G,B, get back 16-bit packed color
 
uint16_t Color_To_565(uint8_t r, uint8_t g, uint8_t b)
{
	return ((r & 0xF8) << 8) | ((g & 0xFC) << 3) | ((b & 0xF8) >> 3);
}
 
0xF8 = 11111000
0xFC = 11111100
 
(r & 0xF8) -> 5 bit de gauche de r (on ignore donc les 3 bits de poids faible)
(g & 0xFC) -> 6 bit de gauche de g (on ignore donc les 2 bits de poids faible)
(b & 0xF8) -> 5 bit de gauche de b (on ignore donc les 3 bits de poids faible)
 
rrrrr---
gggggg--
bbbbb---
 
après les décallages on obtient les 16 bits suivants:
 
rrrrr---========
     gggggg--===
        ===bbbbb
 
soit après le ou :
 
rrrrrggggggbbbbb       
 
calcul de la Fonction inverse : 
RGB565_to_888
**/
 
 
void RGB565_to_888(uint16_t color565, uint8_t *R, uint8_t *G, uint8_t *B)
{
	*R=(color565 & 0xFFFFF800) >> 8;
	*G=(color565 & 0x7E0) >> 3;
	*B=(color565 & 0x1F) << 3 ;
}
 
 
 
/** -----------------------------------------------------------------------------------
		CAPTURE D'ECRAN vers SDcard				
/** ----------------------------------------------------------------------------------- */
 
void write_TFT_on_SDcard() // enregistre le fichier .bmp
{
	if (SDcardOk==0) {return;}
 
	String s1;
	uint16_t ys=200;
	TFT.setFreeFont(FF1);
	TFT.setTextColor(JAUNE, NOIR);
 
	uint16_t x, y;
	uint16_t color565;
	uint16_t bmp_color;
	uint8_t R, G, B;
 
	if( ! SD.exists("/bmp/capture2.bmp"))
	{
		TFT.fillRect(0, 0, 480, 320, NOIR); // efface
		TFT.setTextColor(ROUGE, NOIR);
		TFT.drawString("NO /bmp/capture2.bmp !", 100, ys);
		delay(300);
		TFT.fillRect(100, ys, 220, 20, NOIR); // efface
		return;
	}
 
 
	File File1 = SD.open("/bmp/capture2.bmp", FILE_WRITE); // ouverture du fichier binaire (vierge) en écriture
	if (File1)
	{
/*
Les images en couleurs réelles BMP888 utilisent 24 bits par pixel: 
Il faut 3 octets pour coder chaque pixel, en respectant l'ordre de l'alternance bleu, vert et rouge.
*/
		uint16_t bmp_offset = 138;
		File1.seek(bmp_offset);
 
 
		TFT.setTextColor(VERT, NOIR);;	
 
		for (y=320; y>0; y--)
		{
			for (x=0; x<480; x++)
			{
				color565=TFT.readPixel(x, y);
 
				RGB565_to_888(color565, &R, &G, &B);
 
				File1.write(B); //G
				File1.write(G); //R
				File1.write(R); //B
			}
 
			s1=(String) (y/10);
			TFT.fillRect(450, 300, 20, 20, NOIR);
			TFT.drawString(s1, 450, 300);// affi compte à rebour
		} 
 
		File1.close();  // referme le fichier
 
		TFT.fillRect(450, 300, 20, 20, NOIR); // efface le compte à rebour
	}
}
 
/** ----------------------------------------------------------------------------------- */
 
 
 
void Draw_arc_elliptique(uint16_t x0, uint16_t y0, int16_t dx, int16_t dy, float alpha1, float alpha2, uint16_t couleur) // alpha1 et alpha2 en radians
{
/*
REMARQUES :	
-cette fonction permet également de dessiner un arc de cercle (si dx=dy), voire le cercle complet
- dx et dy sont du type int (et pas uint) et peuvent êtres négafifs, ou nuls.
-alpha1 et alpha2 sont les angles (en radians) des caps des extrémités de l'arc 
*/ 
	uint16_t n;
	float i;
	float x,y;
 
	i=alpha1;
	while(i<alpha2)
	{
		x=x0+dx*cos(i);
		y=y0+dy*cos(i+M_PI/2.0);
		TFT.drawPixel(x,y, couleur);
		i+=0.01;  // radians
	}
}
 
 
void affi_rayon1(uint16_t x0, uint16_t y0, uint16_t rayon, double angle, float pourcent, uint16_t couleur_i, bool gras)
{
// trace une portion de rayon de cercle depuis 100%...à pourcent du rayon du cercle
// angle en radians - sens trigo
	float x1, x2;
	float y1, y2;
 
	x1=x0+rayon* cos(angle);
	y1=y0-rayon* sin(angle);
 
	x2=x0+pourcent*rayon* cos(angle);
	y2=y0-pourcent*rayon* sin(angle);
 
	TFT.drawLine(x1, y1, x2, y2, couleur_i);
	if (gras)
	{
		TFT.drawLine(x1, y1-1, x2, y2-1, couleur_i);
		TFT.drawLine(x1, y1+1, x2, y2+1, couleur_i);
	}
}
 
 
 
void affi_rayon2(uint16_t x0, uint16_t y0, float r1, float r2, float angle_i, uint16_t couleur_i, bool gras)
{
// trace une portion de rayon de cercle entre les distances r1 et r2 du centre
// angle_i en degrés décimaux - sens trigo
 
	float angle =angle_i/57.3;  // (57.3 ~ 180/pi)
	int16_t x1, x2;
	int16_t y1, y2;
 
	x1=x0+int16_t(r1* cos(angle));
	y1=y0-int16_t(r1* sin(angle));
 
	x2=x0+int16_t(r2* cos(angle));
	y2=y0-int16_t(r2* sin(angle));
 
	if ((x1>0) && (x2>0) && (y1>0) && (y2>0) && (x1<480) && (x2<480) && (y1<320) && (y2<320) )
	{
		TFT.drawLine(x1, y1, x2, y2, couleur_i);
 
		if (gras)
		{
			TFT.drawLine(x1, y1-1, x2, y2-1, couleur_i);
			TFT.drawLine(x1, y1+1, x2, y2+1, couleur_i);
		}
	}
 
	//TFT.fillCircle(x2, y2, 2, ROUGE);
}
 
 
 
 
void affi_tiret_H(uint16_t x0, uint16_t y0, uint16_t r, double angle_i, uint16_t couleur_i)
{
// trace un tiret perpendiculaire à un rayon de cercle de rayon r
// angle_i en degrés décimaux
 
	float angle =angle_i/57.3;  // (57.3 ~ 180/pi)
	float x1, x2;
	float y1, y2;
 
	x1=x0+(r)* cos(angle-1);
	y1=y0-(r)* sin(angle-1);		
 
	x2=x0+(r)* cos(angle+1);
	y2=y0-(r)* sin(angle+1);
 
	TFT.drawLine(x1, y1,  x2, y2, couleur_i);	
}
 
 
 
void affi_pointe(uint16_t x0, uint16_t y0, uint16_t r, double angle_i, uint16_t couleur_i)
{
// trace une pointe de flèche sur un cercle de rayon r
// angle_i en degrés décimaux - sens trigo
 
	float angle =angle_i/57.3;  // (57.3 ~ 180/pi)
	int16_t x1, x2, x3;
	int16_t y1, y2, y3;
 
	x1=x0+r* cos(angle); // pointe
	y1=y0-r* sin(angle); // pointe
 
	x2=x0+(r-7)* cos(angle-0.1); // base A
	y2=y0-(r-7)* sin(angle-0.1); // base A		
 
	x3=x0+(r-7)* cos(angle+0.1); // base B
	y3=y0-(r-7)* sin(angle+0.1); // base B
 
	TFT.fillTriangle(x1, y1,  x2, y2,  x3, y3,	couleur_i);	
}
 
 
void affi_rectangle_incline(uint16_t x0, uint16_t y0, uint16_t r, double angle_i, uint16_t couleur_i)
{
//rectangle inscrit dans le cerce de rayon r
// angle_i en degrés décimaux - sens trigo
 
	float angle =angle_i/57.3;  // (57.3 ~ 180/pi)
	int16_t x1, x2, x3, x4;
	int16_t y1, y2, y3, y4;
	float d_alpha=0.08; // détermine la largeur du rectangle
 
// point 1
	x1=x0+r*cos(angle-d_alpha); 
	y1=y0+r*sin(angle-d_alpha);	
// point 2
	x2=x0+r*cos(angle+d_alpha); 
	y2=y0+r*sin(angle+d_alpha);	
// point 3
	x3=x0+r*cos(M_PI + angle-d_alpha); 
	y3=y0+r*sin(M_PI + angle-d_alpha);
// point 4
	x4=x0+r*cos(M_PI + angle+d_alpha); 
	y4=y0+r*sin(M_PI + angle+d_alpha);
 
	TFT.drawLine(x1, y1,  x2, y2, couleur_i);
	TFT.drawLine(x2, y2,  x3, y3, couleur_i);
	TFT.drawLine(x3, y3,  x4, y4, couleur_i);
	TFT.drawLine(x4, y4,  x1, y1, couleur_i);
 
}
 
 
 
void affi_indexH(uint16_t x, uint16_t y, int8_t sens, uint16_t couleur) 
{
// petite pointe de flèche horizontale
// sens = +1 ou -1 pour orienter la pointe vers la droite ou vers la gauche
 
	TFT.fillTriangle(x, y-4,  x, y+4,  x+8*sens, y, couleur);
}
 
 
 
void affi_indexV(uint16_t x, uint16_t y, int8_t sens, uint16_t couleur) 
{
// petite pointe de flèche verticale
// sens = +1 ou -1 pour orienter la pointe vers le haut ou vers le bas
 
	TFT.fillTriangle(x-4, y,  x+4, y,  x, y+8*sens, couleur);
}
 
 
 
float degTOrad(float angle)
{
	return (angle * M_PI / 180.0);
}
 
 
 
void init_affi_HA()
{
	TFT.fillRect(HA_x0-HA_w, HA_y0-HA_h-1, 2*HA_w, HA_h+1, HA_CIEL);
	TFT.fillRect(HA_x0-HA_w, HA_y0-HA_h +  HA_h, 2*HA_w, HA_h, HA_SOL);
 
}
 
 
 
 
void dessine_avion()
{
// aile gauche	
	TFT.fillRect(HA_x0-102, HA_y0-3, 60, 10, BLANC);	//H contour en blanc
	TFT.fillRect(HA_x0-42, HA_y0-3, 10, 19, BLANC);	//V
 
	TFT.fillRect(HA_x0-100, HA_y0-1, 60, 5, NOIR);	//H
	TFT.fillRect(HA_x0-40, HA_y0-1, 5, 15, NOIR);		//V
 
 
// aile droite	
	TFT.fillRect(HA_x0+28, HA_y0-3, 64, 10, BLANC);	//H contour en blanc
	TFT.fillRect(HA_x0+28, HA_y0-3, 10, 19, BLANC);	//V
 
	TFT.fillRect(HA_x0+30, HA_y0-1, 60, 5, NOIR);		//H
	TFT.fillRect(HA_x0+30, HA_y0-1, 5, 15, NOIR);		//V
 
//carré blanc au centre
 
	TFT.fillRect(HA_x0-4, HA_y0-3, 8, 2, BLANC);
	TFT.fillRect(HA_x0-4, HA_y0-3, 2, 8, BLANC);
 
	TFT.fillRect(HA_x0-4, HA_y0+3, 10, 2, BLANC);
	TFT.fillRect(HA_x0+4, HA_y0-3, 2, 8, BLANC);
 
	//affi_dst_NAV();
 
}
 
 
 
void lign_sep(uint16_t Ax, uint16_t Ay, uint16_t Bx, uint16_t By)
{
// actualise la ligne de séparation ciel-sol
 
	TFT.drawLine(Ax, Ay-1, Bx, By-1, HA_CIEL);
	TFT.drawLine(Ax, Ay, Bx, By, BLANC);
	TFT.drawLine(Ax, Ay+1, Bx, By+1, HA_SOL);
}
 
 
 
void arrondissement_coins()
{
 
// fillTriangle(int32_t x1,int32_t y1, int32_t x2,int32_t y2, int32_t x3,int32_t y3, uint32_t color);
 
//HG
	TFT.fillTriangle(
		HA_x0-HA_w, HA_y0-HA_h-1,
		HA_x0-HA_w, HA_y0-HA_h+20,
		HA_x0-HA_w+20, HA_y0-HA_h-1,
	NOIR);
 
 
//----------------------------------------------
//HD
	TFT.fillTriangle(
		HA_x0+HA_w, HA_y0-HA_h-1,
		HA_x0+HA_w, HA_y0-HA_h+20,
		HA_x0+HA_w-20, HA_y0-HA_h-1,
	NOIR);
 
 
 
//----------------------------------------------
//BG
	TFT.fillTriangle(
		HA_x0-HA_w, HA_y0+HA_h+1,
		HA_x0-HA_w, HA_y0+HA_h-20,
		HA_x0-HA_w+20, HA_y0+HA_h+1,
	NOIR);
 
//----------------------------------------------
//BD
	TFT.fillTriangle(
		HA_x0+HA_w, HA_y0+HA_h+1,
		HA_x0+HA_w, HA_y0+HA_h-20,
		HA_x0+HA_w-20, HA_y0+HA_h+1,
	NOIR);
 
}
 
 
 
void affi_HA()  // Horizon Artificiel
{
	String s1;
 
	////String s1=(String) roulis;
	////TFT.drawString(s1, 400, 20);
 
 
// pivot
	int16_t x0=0;
	int16_t y0=0;
 
//points d'intersection avec le bord du carré
	int16_t Ax, Ay; // sur le bord gauche
	int16_t Bx, By; // sur le bord droit
// Le dessin consistera à tracer des segments colorés entre les points A et B	
 
 
// roulis -> [-90..+90]
 
// normalisation de la valeur R2 -> toujours >0
	float R2 = -1*roulis;
	if (R2<0) {R2+=360;} // ce qui est un angle identique, de valeur positive (sens trigo)
 
// le pivot reste centré horizontalement mais se déplace verticalement en fonction du tangage	
	y0 += 2*tangage;
 
//calcul & memorisation de ces deux facteurs, ce qui évitera 2 calculs de tangente à chaque passage dan la fonction
	float tgt_moins = tan(degTOrad(90-R2));
	float tgt_plus = tan(degTOrad(90+R2));
 
//-----------------------------------------------------------------------------
// CALCUL COTE DROIT (point B)
 
// calcul du point B d'intersection 
	Bx=HA_w;
	By=y0 + HA_w*tan(degTOrad(R2));
 
//test si le point d'intersection se trouve plus haut que le haut du carré :
 
	if(By>HA_h)
	{
		By=HA_h;
		Bx = x0 + (HA_h-y0)*tgt_moins;
	}
 
	if(By< -HA_h)
	{
		By= -HA_h;
		Bx = x0 + (HA_h+y0)*tgt_plus;
	}
//-----------------------------------------------------------------------------
// CALCUL COTE GAUCHE (point A)
 
	Ax=-HA_w;
	Ay=y0 - HA_w*tan(degTOrad(R2));
 
	if(Ay> HA_h)
	{
		Ay= HA_h;
		Ax = x0 + (HA_h-y0)*tgt_moins;
	}
 
	if(Ay< -HA_h)
	{
		Ay= -HA_h;
		Ax = x0 + (HA_h+y0)*tgt_plus;
	}
 
 
//-----------------------------------------------------------------------------
// positionnement de l'ensemble sur l'écran	
 
	Ax += HA_x0;
	Ay += HA_y0;
 
	Bx += HA_x0;
	By += HA_y0;
 
// pour éviter un tracé hors cadre au premier passage :
	if (premier_passage == 1)
	{
		Ax_actu = Ax;
		Ay_actu = Ay;
 
		Bx_actu = Bx;
		By_actu = By;
		premier_passage=0;
	}
 
 
//-----------------------------------------------------------------------------
// ligne "verticale" d'inclinaison (tangage)
 
	affi_rayon2(HA_x0, HA_y0, 85, -memo_y0, 90-memo_R2, HA_CIEL, false); // efface partie supérieure
	affi_rayon2(HA_x0, HA_y0, 85, -y0, 90-R2, BLANC, false);	// retrace ligne partie supérieure
 
	affi_rayon2(HA_x0, HA_y0, -85,-memo_y0, 90-memo_R2, HA_SOL, false);  // efface partie inférieure
	affi_rayon2(HA_x0, HA_y0, -85,-y0, 90-R2, VERT, false);	// retrace ligne partie inférieure
 
	affi_pointe(HA_x0, HA_y0, 85, 90-memo_R2, HA_CIEL); // efface
	affi_pointe(HA_x0, HA_y0, 85, 90-R2, BLANC); // retrace
 
 
	affi_glide();
	affi_localizer();
	//affi_tiret_H(HA_x0, HA_y0, 50, degTOrad(90-memo_R2), HA_CIEL); // efface
	//affi_tiret_H(HA_x0, HA_y0, 50, degTOrad(90-R2), ROSE); // retrace
 
// graduation fixe
	TFT.setFreeFont(FF1);
	TFT.setTextColor(BLANC, GRIS_AF);
	TFT.drawString("30", HA_x0-70, HA_y0-98);
	TFT.drawString("60", HA_x0-120, HA_y0-55);
 
	TFT.drawString("30", HA_x0+60, HA_y0-98);
	TFT.drawString("60", HA_x0+100, HA_y0-55);
 
//-----------------------------------------------------------------------------
// animation de la ligne de séparation horizontale
 
	while ((Bx_actu != Bx) ||  (By_actu != By) || (Ax_actu != Ax) ||  (Ay_actu != Ay))
	{
	// déplacements successifs de 1 pixel de chaque extrémités de la ligne	
 
		//TFT.drawLine(Bx, By, x2, y2, BLANC);
 
		if (Bx_actu < Bx) { Bx_actu++; lign_sep(Ax_actu, Ay_actu, Bx_actu, By_actu); }
		if (Bx_actu > Bx) { Bx_actu--; lign_sep(Ax_actu, Ay_actu, Bx_actu, By_actu); }
 
		if (Ax_actu < Ax) { Ax_actu++; lign_sep(Ax_actu, Ay_actu, Bx_actu, By_actu); }
		if (Ax_actu > Ax) { Ax_actu--; lign_sep(Ax_actu, Ay_actu, Bx_actu, By_actu); }
 
		if (By_actu < By) { By_actu++; lign_sep(Ax_actu, Ay_actu, Bx_actu, By_actu); }
		if (By_actu > By) { By_actu--; lign_sep(Ax_actu, Ay_actu, Bx_actu, By_actu); }
 
		if (Ay_actu < Ay) { Ay_actu++; lign_sep(Ax_actu, Ay_actu, Bx_actu, By_actu); }
		if (Ay_actu > Ay) { Ay_actu--; lign_sep(Ax_actu, Ay_actu, Bx_actu, By_actu); }
 
	}
 
 
// graduation roulis qui se déplace angulairement avec la ligne de tangage
	for (int8_t n=0; n<4; n++)
	{
		Draw_arc_elliptique(HA_x0, HA_y0, 20*n, 20*n, degTOrad(80-memo_R2+n), degTOrad(100-memo_R2-n), HA_CIEL); // efface bas
		Draw_arc_elliptique(HA_x0, HA_y0, 20*n, 20*n, degTOrad(80-R2+n), degTOrad(100-R2-n), BLANC); // trace bas
 
		Draw_arc_elliptique(HA_x0, HA_y0, 20*n, 20*n, degTOrad(260-memo_R2+n), degTOrad(280-memo_R2-n), HA_SOL); // efface haut
		Draw_arc_elliptique(HA_x0, HA_y0, 20*n, 20*n, degTOrad(260-R2+n), degTOrad(280-R2-n), BLANC); // trace haut
	}
 
	memo_R2 = R2;
	memo_y0 = y0;
 
 
 
 
//-----------------------------------------------------------------------------
	arrondissement_coins();
 
	//affi_frq_NAV1();
	affi_dst_NAV1();
	affi_dst_NAV2();
 
	affi_alti_NAV2();
}
 
 
 
void affi_acceleration()
{
// POUR TEST **********
////String s2= (String) acceleration;
////TFT.fillRect(100, 50, 200, 20, TFT_BLACK);
////TFT.setFreeFont(FF5);
////TFT.setTextColor(BLANC, NOIR);
////TFT.drawString("Acceleration=", 100, 50);
////TFT.drawString(s2, 250, 50);
// ******************** 
 
//barres verticales colorées juste à droite de la vitesse indiquant sa variation
	uint16_t x0=60;
	uint16_t Y_zero=162;
 
	int16_t dy=0;
 
//fleche haute
	TFT.fillRect(x0, 30, 8, Y_zero, GRIS_TRES_FONCE); // efface haut
	if (acceleration > 1)
	{
		dy= acceleration;
 
		TFT.fillRect(x0, Y_zero-dy, 8, dy, VERT); // fleche 
	}
 
 
//fleche basse
	TFT.fillRect(x0, Y_zero, 8, 132, GRIS_TRES_FONCE); // efface bas
	if (acceleration < -1)
	{
		dy= -acceleration;
 
		TFT.fillRect(x0, Y_zero, 8, dy, JAUNE); // fleche
	}
 
	TFT.fillRect(x0, Y_zero, 10, 2, BLANC);
 
}
 
 
void affi_vitesse()
{
 
	uint16_t x1;
	String s1;
 
	TFT.setTextColor(BLANC); // Background is not defined so it is transparent
 
//---------------------------------------------------------------------------------------
//bande verticale multicolore
 
	#define vitesse_sol 40
	int16_t vitesse_mini1 =90;
	int16_t vitesse_mini2 =130;
	int16_t vitesse_maxi1 =200;
	int16_t vitesse_maxi2 =280;
 
//calcul de la position des limites	entre les différentes couleurs verticales
	float d1=HA_y0+HA_w/2 + 3.2*((vitesse - vitesse_sol));		if (d1<30) {d1=30;} if (d1>290) {d1=290;}
	float d2=HA_y0+HA_w/2 + 3.2*((vitesse - vitesse_mini1));	if (d2<30) {d2=30;} if (d2>290) {d2=290;}
	float d3=HA_y0+HA_w/2 + 3.2*((vitesse - vitesse_mini2));	if (d3<30) {d3=30;} if (d3>290) {d3=290;}
	float d4=HA_y0+HA_w/2 + 3.2*((vitesse - vitesse_maxi1));	if (d4<30) {d4=30;} if (d4>290) {d4=290;}
	float d5=HA_y0+HA_w/2 + 3.2*((vitesse - vitesse_maxi2));	if (d5<30) {d5=30;} if (d5>290) {d5=290;}
 
 
	TFT.fillRect(50, 30, 6, (int16_t)d5,  ORANGE);
	TFT.fillRect(50, (int16_t)d5, 6, d4-d5, JAUNE); 
	TFT.fillRect(50, (int16_t)d4, 6, d3-d4, VERT); 
	TFT.fillRect(50, (int16_t)d3, 6, d2-d3, ORANGE);
	TFT.fillRect(50, (int16_t)d2, 6, d1-d2, ROUGE);
	TFT.fillRect(50, (int16_t)d1, 6, 290-(int16_t)d1, GRIS);
 
//---------------------------------------------------------------------------------------
//échelle verticale graduée glissante
 
	uint16_t y0;
	uint16_t y_min=30;
	uint16_t y_max=290;
 
	int16_t vit1;
	float d6;
 
	TFT.setFreeFont(FF1);
 
	y0=3.2*(vitesse%10);
 
	TFT.fillRect(0, y_min, 50, y_max-30, GRIS_AF); // bande verticale à gauche
	for(int n=0; n<10; n++)
	{
		d6 =2+y0+32.0*n; // 24 pixels verticalement entre chaque trait -> 10*24 = 240px (hauteur de l'affiur)
		{
			if ( (d6>y_min) && (d6<y_max-10) && (vit1>=0) && (vit1<1000) ) 
			{
				TFT.fillRect(45, (int16_t)d6, 10, 2, BLANC); // petits tirets horizontaux
			}
 
			vit1 = vitesse -10*(n-5);
			vit1 /= 10;
			vit1 *= 10;
			s1=(String) vit1;
 
			if ( (d6>y_min) && (d6<y_max-10) && (vit1>=0) && (vit1<1000) ) 
			{
				TFT.setTextColor(BLANC, GRIS_AF);
				//TFT.drawString("    ", 9, d6);
				x1=0; 
				if(vit1<100){x1=7;} // pour affichage centré
				if(vit1<10){x1=14;}
				if (vit1>=10)
				{
					TFT.drawString(s1, x1, (uint16_t)d6-5); // Graduation (tous les 20kts)
				}
			}
		}
	}
	//TFT.fillRect(0, 0, 65, 20, NOIR);
 
//---------------------------------------------------------------------------------------
// affichage de la valeur principale
 
	uint16_t VP_y0 = 150;
 
	TFT.setTextColor(BLANC, NOIR);
	TFT.setFreeFont(FF18);
	s1=(String)vitesse;
 
	TFT.fillRect(3, VP_y0, 42, 26, NOIR); // efface le nombre précédemment affiché (pour le cas où on passe de trois à deux chiffres)
 
	if ((vitesse>=0) && (vitesse <1000))
	{
		x1=3; 
		if(vitesse<100){x1=10;} // pour affichage centré
		if(vitesse<10){x1=20;}
		TFT.drawString(s1, x1, VP_y0+3); // affi le nombre
	} // affi en gros à mi-hauteur de l'écran
	else
	{ TFT.fillRect(3, VP_y0, 42, 26, GRIS); }
 
	TFT.drawRoundRect(1, VP_y0-1, 45, 28, 5, BLANC); // encadrement de la valeur centrale affichée
 
	TFT.fillTriangle(45, VP_y0+7, 45, VP_y0+17, 55, VP_y0+12, NOIR); // petit triangle (curseur) noir
}
 
 
 
void affi_asel()
{
// consigne ALTITUDE de l'autopilot
// ( chiffres en rose en haut à droite	)
 
	String s2 =(String)(asel1*100);     
	TFT.setTextColor(ROSE, NOIR);
	TFT.setFreeFont(FF5);
	uint16_t x1;
	x1=340;
	TFT.fillRect(x1+7, 0, 70, 20, NOIR); // efface
	if(asel1<10000){x1+=7;}
	if(asel1<1000){x1+=7;} 
	if(asel1<100){x1+=7;} // pour affichage centré
	if(asel1<10){x1+=7;}
 
	TFT.drawString(s2, x1, 5);	
}
 
 
 
void affi_vt_verticale()
{
// affichage analogique sur la droite de l'écran
 
	uint16_t x0=435;
	uint16_t y0=165;
 
	float y1;
 
	uint16_t x1;
	String s1;
 
	TFT.fillRect(x0, y0-90, 45, 180, GRIS_AF); // barre grise
	TFT.fillRect(x0, y0, 25, 2, BLEU_CLAIR);  // centre
 
// ------------------------
// graduations sur un arc vertical
	TFT.setFreeFont(FF1);
 
	TFT.setTextColor(BLANC, NOIR);
	TFT.drawString("ft/mn", x0-8, y0+125);
 
 
	TFT.setTextColor(BLANC, GRIS_AF);
 
 
 
	float angle;
	for(uint8_t n=0; n<7; n++ )
	{
		angle =135+ n*15;  // 1 tiret tous les 15 degrés
		affi_rayon1(HA_x0+340, y0, 110, degTOrad(angle), 0.9, BLANC, false); // tirets de graduation
	}
 
 
	TFT.drawString("3", x0+9, y0-90);
	TFT.drawString("2", x0-3, y0-65);
	TFT.drawString("1", x0-8, y0-35);
	TFT.drawString("0", x0-3, y0-5 + 0);
	TFT.drawString("1", x0-8, y0+25);
	TFT.drawString("2", x0-3, y0+50);
	TFT.drawString("3", x0+9, y0+75);
 
// ------------------------
// aiguille à droite de l'écran
	float angle2;
 
	TFT.setFreeFont(FF1);
	s1=(String) (vspeed*60);
 
	angle2 = 180.0 - vspeed *0.92;
 
	TFT.fillRect(x0-10, y0-110, 55, 15, GRIS_TRES_FONCE); // efface haut
	TFT.fillRect(x0-10, y0+105, 55, 15, GRIS_TRES_FONCE); // efface bas
 
	if ((vspeed > -50) && (vspeed < 50))
	{
		affi_rayon1(HA_x0+330, y0, 100, degTOrad(angle2), 0.7, JAUNE, true);
 
		TFT.setTextColor(JAUNE, NOIR);
	}
	else if (vspeed > 50)
	{
		affi_rayon1(HA_x0+330, y0, 110, degTOrad(132), 0.7, JAUNE, true);
		TFT.setTextColor(JAUNE, NOIR);
 
		TFT.drawString(s1, x0-10, y0-110);
	}
	else if (vspeed < -50)
	{
		affi_rayon1(HA_x0+330, y0, 110, degTOrad(228), 0.7, JAUNE, true);
		TFT.setTextColor(JAUNE, NOIR);
 
		TFT.drawString(s1, x0-10, y0+105);
	}
 
 
// affichage digital de la valeur
 
 
/*	
// = vitesse ascensionnelle, sous forme de barres verticales vertes, à droite, près de l'echelle d'altitude	
	uint16_t x0=405;
	uint16_t y0=40;
 
	int16_t dy=0;
 
//fleche haute
	TFT.fillRect(x0, 0, 10, 140, GRIS_FONCE); // efface haut
	if (vspeed > 1)
	{
		dy= vspeed;
 
		TFT.fillRect(x0, y0+100-dy, 10, dy, VERT); // fleche 
	}
 
 
//fleche basse
	TFT.fillRect(x0, y0+150, 10, 135, GRIS_FONCE); // efface bas
	if (vspeed < -1)
	{
		dy= -vspeed;
 
		TFT.fillRect(x0, y0+150, 10, dy, VERT); // fleche
	}
*/
 
}
 
 
 
 
void affi_cap()
{
// cercle tournant de CAP gradué en bas au centre de l'écran
// Les lettres 'N' 'S' 'E' 'O' pour Nord Sud Est Ouset sont initialisées sous forme de sprites dans la fonction setup()
 
	uint16_t x02 = 200;
	uint16_t y02 = 350;
	float angle; // en radians
	//float cap_RD; // en radians (le cap fourni par FG étant en degrés d'angle)
	uint16_t x_spr;
	uint16_t y_spr;
 
	uint16_t x_hdg;
	uint16_t y_hdg;
 
	uint8_t R =70;
	uint8_t R2 =R-6;
/**
360° =2 pi rad
1° = 2 pi/360 rad = pi/180 rad
**/
 
	TFT.fillCircle(x02,y02, R, GRIS_AF);
 
	for(uint8_t n=0; n<24; n++ )
	{
		angle = cap+15 + n*15;  // 1 tiret tous les 15 degrés
		affi_rayon1(x02, y02, (R-5), degTOrad(angle), 0.9, BLANC, false); // tirets de graduation
	}
	x_hdg =  x02 + R2*cos(degTOrad(hdg1-90-cap));
	y_hdg =  y02 + R2*sin(degTOrad(hdg1-90-cap));
 
	TFT.drawLine(x02, y02, x_hdg, y_hdg, VERT);
	TFT.drawCircle(x_hdg, y_hdg, 5, VERT); // rond vert sur le cercle = consigne de cap	de l'autopilot
 
	x_spr = x02+R2 * cos(degTOrad(angle));
	y_spr = y02-R2 * sin(degTOrad(angle));
	TFT.setPivot(x_spr, y_spr);
	SPR_E.pushRotated(-cap+90, TFT_BLACK); // Plot rotated Sprite, black = transparent
 
	x_spr = x02+R2* cos(degTOrad(angle+90));
	y_spr = y02-R2 * sin(degTOrad(angle+90));
	TFT.setPivot(x_spr, y_spr);
	SPR_N.pushRotated(-cap, TFT_BLACK); 
 
	x_spr = x02+R2 * cos(degTOrad(angle+180));
	y_spr = y02-R2 * sin(degTOrad(angle+180));
	TFT.setPivot(x_spr, y_spr);
	SPR_O.pushRotated(-cap-90, TFT_BLACK); 
 
	x_spr = x02+R2 * cos(degTOrad(angle-90));
	y_spr = y02-R2 * sin(degTOrad(angle-90));
	TFT.setPivot(x_spr, y_spr);
	SPR_S.pushRotated(-cap, TFT_BLACK); 
 
 
// petite "maison" dans le cercle (valeur du cap)
 
	#define a 180   // x général
	#define b a+20
	#define c b+20
	#define d 288	// y général
	#define e d+10
	#define f e+20
 
	TFT.drawLine(a, f, c, f, BLANC); // sol
	TFT.drawLine(a, f, a, e, BLANC); // mur de gauche
	TFT.drawLine(c, f, c, e, BLANC); // mur de droite
	TFT.drawLine(a, e, b, d, BLANC); // toit pente gauche
	TFT.drawLine(c, e, b, d, BLANC); // toit pente droite
 
 
// affi la valeur	
	String s1;
	uint16_t x0 = a+2;
	uint16_t y0 = e;
 
	uint16_t x1= x0;
	if(cap<100){x1+=5;} // pour affichage centré
	if(cap<10){x1+=5;}
 
	s1=(String) cap;
 
	TFT.fillRect(x0, y0, 35, 20, NOIR); // efface le nombre précédemment affiché
	TFT.setTextColor(BLANC, NOIR);
	TFT.setFreeFont(FM9);
	TFT.drawString(s1, x1, y0);
 
 
}
 
 
 
void affi_altitude()
{
	String s1;
	uint16_t x0 =365;
//---------------------------------------------------------------------------------------
//échelle verticale graduée glissante
 
	uint16_t x1;
	uint16_t y0;	
	int16_t alt1;
	float d5;
 
	TFT.setFreeFont(FF1);
 
	y0=3.2*(altitude%10);
 
	TFT.fillRect(x0, 20, 60, 319, GRIS_AF); //efface bande verticale à droite
 
 
	for(int n=0; n<10; n++)
	{
		d5 =0+y0+32.0*n; // pixels verticalement entre chaque trait -> 10*24 = 240px (hauteur de l'affi)
		{
			if (d5>=20)  // marge en haut
			{
				TFT.fillRect(x0, (int16_t)d5+5, 5, 2, BLANC); // petits tirets horizontaux
 
				alt1 = altitude -10*(n-5);
				alt1 /= 10;
				alt1 *= 10;
				s1=(String) alt1;
 
				TFT.setTextColor(BLANC, GRIS_AF);
				//TFT.drawString("    ", 9, d5);
				x1=x0;
				if(alt1<10000){x1+=7;} // pour affichage centré
				if(alt1<1000){x1+=7;} 
				if(alt1<100){x1+=7;} 
				if(alt1<10){x1+=7;}
				TFT.drawString(s1, x1, (uint16_t)d5); // Graduation (tous les 20kts)
			}
		}
	}
 
 
//---------------------------------------------------------------------------------------
// affichage de la valeur principale
 
 
 
	uint16_t x2;
	uint16_t y0b = 155;
	TFT.fillRect(x0-20, y0b, 80, 25, NOIR); // efface le nombre précédemment affiché
	TFT.setTextColor(BLANC, NOIR);
	TFT.setFreeFont(FF18);
 
	if ((altitude >=0) && (altitude < 60000))
	{
		s1=(String) altitude;
	}
	else {s1="----";}
	x2=x0-20;
	if(altitude<10000){x2+=10;} // pour affichage centré
	if(altitude<1000){x2+=10;}
	if(altitude<100){x2+=10;} 
	if(altitude<10){x2+=10;}
	TFT.drawString(s1, x2, y0b);
	TFT.drawRoundRect(x0-20, y0b-3, 75, 28, 5, BLANC); // encadrement de la valeur centrale affichée
 
 
}
 
 
void affi_frq_NAV1()
{
	String s1;
	uint16_t x0=120;
	uint16_t y0=234;
	float f1;
 
	f1 = nav1frq/1000.0;
	s1= String(f1, 2);
 
	TFT.fillRect(x0, y0, 55, 18, NOIR); // efface
	TFT.setFreeFont(FM9);
	TFT.setTextColor(VERT, NOIR);
	TFT.drawString(s1, x0, y0);
	TFT.drawString("MHz", x0+70, y0);
}
 
 
void affi_dst_NAV1()
{
 
	if (nav1dst<0) {nav1dst=0;}
	String s1;
	uint16_t x0=180;
	uint16_t y0=236; 
// rappel: 1 mile marin (NM nautical mile) = 1852m
	float nav1_nm = (float)nav1dst / 1852.0;
//Serial.println(nav1_nm);
 
	TFT.setTextColor(JAUNE, NOIR);
	TFT.drawString("Nv1", x0-40, y0);
	TFT.setTextColor(BLANC, NOIR);
 
	uint8_t nb_decimales =1;
	if (nav1_nm >99) {nb_decimales=0;}
 
	s1 = String( nav1_nm, nb_decimales);
	TFT.fillRect(x0, y0, 52, 18, NOIR); // efface
	TFT.setFreeFont(FM9);
	TFT.drawString(s1, x0, y0);
	TFT.drawRoundRect(x0, y0-2, 50, 18, 5, GRIS_FONCE); // encadrement de la valeur affichée
 
	TFT.drawString("NM", x0+55, y0);
}
 
 
void affi_radial_NAV1()
{
 
	if (nav1radial<0) {nav1radial=0;}
	String s;
	uint16_t x0=260;
	uint16_t y0=236; 
 
	int16_t alpha1 = nav1radial/100.0;
 
	int16_t alpha2 = alpha1 + 180;
	if (alpha2>360)  {alpha2 -= 360;}
 
	if (alpha1 == 360) {alpha1 =0;}
	if (alpha2 == 360) {alpha2 =0;}
 
 
//affichage numérique de l'angle
	TFT.setTextColor(VERT, NOIR);
	//s = String (alpha1 , 0); // 0 décimales
	s = (String) alpha1; 
	TFT.fillRect(x0, y0, 50, 18, NOIR); // efface
	TFT.setFreeFont(FM9);
	TFT.drawString(s, x0+5, y0);
	TFT.drawRoundRect(x0, y0-2, 40, 18, 5, GRIS_FONCE); // encadrement de la valeur affichée
	TFT.drawCircle(x0+46, y0, 2, JAUNE); // caractère 'degré'
 
//affichage numérique de l'angle opposé
	x0+=50;
	TFT.setTextColor(VERT, NOIR);
	//s = String (alpha2 , 0); // 0 décimales
	s = (String) alpha2;
	TFT.fillRect(x0, y0, 50, 18, NOIR); // efface
	TFT.setFreeFont(FM9);
	TFT.drawString(s, x0+5, y0);
	TFT.drawRoundRect(x0, y0-2, 40, 18, 5, GRIS_FONCE); // encadrement de la valeur affichée
	TFT.drawCircle(x0+46, y0, 2, JAUNE);
 
 
}
 
 
void affi_dst_NAV2()
{
 
	if (nav2dst<0) {nav2dst=0;}
	String s1;
	uint16_t x0=180;
	uint16_t y0=255; 
	float nav_nm;
// rappel: 1 mile marin (NM nautical mile) = 1852m
	nav_nm = (float)nav2dst / 1852.0;
	if (nav_nm >99) {nav_nm=0;}
 
	TFT.setTextColor(JAUNE, NOIR);
	TFT.drawString("Nv2", x0-40, y0);
	TFT.drawString("NM", x0+55, y0);
 
	TFT.setTextColor(BLANC, NOIR);
	s1 = String( nav_nm, 1); // 1  -> 0 décimale
	TFT.fillRect(x0, y0, 52, 18, NOIR); // efface
	TFT.setFreeFont(FM9);
	TFT.drawString(s1, x0, y0);
	TFT.drawRoundRect(x0, y0-2, 50, 18, 5, GRIS_FONCE); // encadrement de la valeur affichée
 
}
 
 
void affi_radial_NAV2()
{
 
	if (nav2radial<0) {nav2radial=0;}
	String s1;
	uint16_t x0=260;
	uint16_t y0=255; 
 
//affichage numérique
	TFT.setTextColor(BLEU_CLAIR, NOIR);
	s1 = String (nav2radial/100, 0); // 0 décimales
	TFT.fillRect(x0, y0, 50, 18, NOIR); // efface
	TFT.setFreeFont(FM9);
	TFT.drawString(s1, x0+5, y0);
	TFT.drawRoundRect(x0, y0-2, 40, 18, 5, GRIS_FONCE); // encadrement de la valeur affichée
	TFT.drawCircle(x0+46, y0, 2, JAUNE);
}
 
 
void affi_alti_NAV2()
{
// hauteur (en ft) conseillée pour l'approche IFR à la distance en nautiques (NM) de la balise Nav2
	String s1;
	uint16_t x=425;
	uint16_t y=5;
 
	float nav_nm;
	float hauteur; // attention: ne pas confondre hauteur (au dessus du sol) et altitude (au dessus du niveau de la mer)
	nav_nm = (float)nav2dst / 1852.0;
	hauteur = 300.0*nav_nm;
 
	s1 = String( hauteur, 0); // 0  -> 0 décimale
	TFT.fillRect(x, y, 55, 18, NOIR); // efface
 
	if (gs_ok==1)
	{
		TFT.setTextColor(VERT, NOIR);
		TFT.setFreeFont(FF1);
		//TFT.setFreeFont(FM9);
		//TFT.setFreeFont(FS9);
		//TFT.setFreeFont(FF5);
		TFT.drawString(s1, x, y);
	}
}
 
 
 
void affi_indicateurs()
{
 
	TFT.setFreeFont(FSS9);
 
/*
	TFT.drawString("CLB | IAS |", 100, 0, 1);
 
	TFT.setTextColor(AZUR, NOIR);
	TFT.drawString("ALT", 210, 0, 1);
 
	TFT.setTextColor(VERT, NOIR);
	TFT.drawString(" |", 245, 0, 1);	
 
	TFT.setTextColor(AZUR, NOIR);
	TFT.drawString("HDG", 260, 0, 1);
 
	TFT.setTextColor(VERT, NOIR);
	TFT.drawString(" |", 300, 0, 1);	
*/
 
	//if (gs_ok != 0)	{ TFT.setTextColor(VERT, NOIR); } else { TFT.setTextColor(GRIS_FONCE, NOIR); }
	//TFT.drawString("ILS", 110, 0);
 
}
 
 
void affi_Airport()
{
	uint16_t n;
	float v1;
	String s1;
 
	TFT.fillRect(270, 280, 40, 40, NOIR); // efface
	TFT.setTextFont(1);
	TFT.setTextColor(BLEU_CLAIR, NOIR);
 
 
	s1= liste_bali[num_bali].ID_OACI;
	TFT.drawString(s1, 270, 280);
 
	TFT.fillRect(255, 290, 105, 10, NOIR); // efface
	s1= liste_bali[num_bali].nom;
	TFT.drawString(s1, 255, 290);
 
	TFT.setTextColor(VERT, NOIR);
 
	v1= liste_bali[num_bali].frq_VOR/100.0;
	s1 = String(v1, 2);
	TFT.drawString(s1, 270, 300);
 
	v1= liste_bali[num_bali].frq_ILS/100.0;
	s1 = String(v1, 2);
	TFT.drawString(s1, 270, 310);
 
}
 
 
 
void auto_landing()
{
/**
 voir: https://en.wikipedia.org/wiki/Autoland
 
 Attérrissage automatique, contrôlé par le bouton1 (si compilé avec la bonne config, voir fonction loop)
 CAPTURE l'avion et le POSE !
 vitesse conseillée : 160kts max
 distance conseillée : entre 20 et 10 nautiques
 hauteur conseillée : 3000ft (= niveau 30)
 
 à ceci près que l'autopilot se déconnecte automatiquement (par FlightGear) sous 100ft de hauteur
 ( Donc garder le manche en main pour le touché final, en surveillant la vitesse et le pitch
 parce que si le trim de profondeur est mal réglé, à la déconnexion de l'autopilot c'est le plongeon près du sol = crash !
 avec ma manette Thrustmaster et le Citation X, je n'arrive pas à régler le trim !! )
 
**/
 
	TFT.setFreeFont(FSS9);
 
	TFT.setTextColor(GRIS_FONCE, NOIR);
	TFT.fillRect(110, 0, 220, 16, NOIR); // efface tout le bandeau d'information en haut
 
	if (autoland != 0)
	{
		// (si bouton1 en position basse, sinon on ne fait rien de plus)
 
		TFT.setTextColor(BLANC, ROUGE);
		TFT.setFreeFont(FF1);
		TFT.drawString("Landing Auto", HA_x0-60, HA_y0+65);
 
		TFT.setTextColor(GRIS, NOIR);
		TFT.drawString("ILS", 110, 0);	
 
		float nav2_nm =(float)nav2dst / 1852.0;
		float nav2_err = nav2loc / 1000.0;
 
	////String s1 = String (nav2_err, 1);
	////TFT.setTextColor(BLEU_CLAIR, NOIR);
	////TFT.drawString(s1, 220, 0);
 
 
		if ((gs_ok != 0) && (altitude < 4000) && (nav2_nm < 20.0))	
		{
	// effectif (capture) seulement si l'avion est suffisamment proche de la balise et suffisamment bas
 
			TFT.setTextColor(BLANC, NOIR);
			TFT.drawString("ILS", 110, 0); 
 
			if((nav2_err > -9.5) && (nav2_err < +9.5)) // attention: |nav2_err| jamais > 10, quoi qu'il arrive !
			{
 
				TFT.setTextColor(VERT, NOIR);
				TFT.drawString("ILS", 110, 0); 
 
				TFT.setTextColor(VERT, NOIR); // Autolanding en cours, ok
				TFT.drawString("APP", 150, 0);
 
				// ici l'avion est proche, bas, et dans un angle serré (9.5° max) mais pas forcément bien orienté 
				hdg1 = (uint16_t)((nav2radial/100.0) + 2.0 *nav2_err); //corrige la consigne de cap de l'autopilot pour rejoindre puis rester dans l'axe de la piste
 
				float alti1 = 3.0*nav2_nm + gnd_elv/100.0; // altitude avion doit être = hauteur avion (souhaitée) + altitude terrain (réelle)
				String s1 = String(alti1,0);
				TFT.setTextColor(JAUNE, NOIR);
				TFT.drawString(s1, 220, 0);
 
				//correction en conséquence de la consigne d'altitude du pilote auto
				if (alti1 < asel1) //empêche de (re)monter lors de la capture ILS, reste en palier le cas échéant
				{
					asel1 = alti1; 
				}
	/**
	REMARQUES:
	la hauteur avion (souhaitée) [= 3.0*nav_nm ] est donc un simple calcul en fonction de la distance: niv=30 à 10NM -> pente à 5%.
	On aurait aussi pu exploiter le glide, mais alors il faudrait :
	- agir sur la gouverne de profondeur plutôt que sur le pilote auto
	- ou bien règler l'autopilot (F11) sur PTCH  (pitch = tangage) pour rester dans le plan incliné à 3° du glide de l'ILS,
	et règler ce pitch en fonction du glide.
	... à voir
	**/
			}
			else
			{
				TFT.setTextColor(GRIS, NOIR); // indique conditions Autolanding non remplies
				TFT.drawString("APP", 150, 0); 
			} 
		}
 
		if (altitude < 100)
		{
			TFT.setTextColor(BLANC, ROUGE);
			TFT.drawString("APP", 150, 0); // en grisé si bouton1 enclenché MAIS conditions non satisfaites; En vert si tout est ok
		} // évite de décoller avec l'autoland activé !!
	}
 
}
 
 
 
void affi_localizer()
{
//ILS dans le plan horizontal ; affiche l'erreur de position par rapport à l'axe de la piste
 
	uint16_t y1 = HA_y0-HA_h-14;
 
// nav2loc = -10 *1000 .. +10 *1000
// l'affichage doit se faire en HA_x0 +/- HA_w
// 10000/HA_w = 10000/120 = 83
 
	uint16_t couleur1 = ROSE;
	loc = HA_x0 + nav2loc / 83;
	if ( loc < (HA_x0-HA_w+5)) {loc = HA_x0-HA_w+5; couleur1 = GRIS;}
	if ( loc > (HA_x0+HA_w-5)) {loc= HA_x0+HA_w-5; couleur1 = GRIS;}
 
 
	TFT.fillRect(HA_x0-HA_w, y1, 2*HA_w, 9, GRIS_TRES_FONCE);
 
	TFT.drawLine(HA_x0, y1-5, HA_x0, y1+5, BLANC);
	if (gs_ok != 0)
	{
		affi_indexV(loc, y1, 1, couleur1); 
	}
	memo_loc=loc;
}
 
 
 
void affi_glide()  // Nav2
{
/*
 "Glide Path-pente" = ILS dans le plan vertical	
 trace des index horizontaux sur les bords de l'HA
 
 Remarque : dans FG toutes les pistes ne sont pas équipées d'un faisceau ILS GLIDE dans les deux sens d'approche...
 L'affichage de la carte (interne ou externe dans le navigateur) permet de visualiser les faisceaux en question si existants.
 par exemple, dans FG et pour LFMT, seule l'approche par le sud (par la mer) est fonctionnelle
 
 D'autre part, il faut avoir réglé le récepteur NAV2 sur la bonne fréquence.
 Voir le pannel F12 de FD ainsi que les cartes d'aéroport.
 
 On peut aussi lancer FG avec les options suivantes dans FGo! (par exemple):
	--nav1=114.45 		(pour le VOR)
	--nav2=305:108.55 	(pour l'ILS de LFMT piste 31R)
*/
 
	uint16_t x1 = 75;
	uint16_t x2 = 332;
 
	gld = HA_y0 - 50*(3.0-nav2glide/1000.0);
 
 
	TFT.fillRect(x1, 30, 9, 2*HA_h, GRIS_TRES_FONCE); // efface
	TFT.fillRect(x2, 30, 9, 2*HA_h, GRIS_TRES_FONCE); // efface
 
	TFT.drawRect(x1, HA_y0, 12, 5, BLANC);
	TFT.drawRect(x2, HA_y0, 12, 5, BLANC);
 
	uint16_t couleur1 = ROSE;
	if ( gld < (HA_y0-HA_h+5)) {gld = HA_y0-HA_h+5; couleur1 = GRIS;}
	if ( gld > (HA_y0+HA_h-5)) {gld = HA_y0+HA_h-5; couleur1 = GRIS;}
 
	affi_indexH(x1, gld, 1, couleur1); 
	affi_indexH(x2+8, gld, -1, couleur1); 		
 
	memo_gld=gld;
}
 
 
 
void trace_arc_gradu()
{
//arc gradué en haut au centre, indiquant la valeur de l'inclinaison
 
	float angle;
	//Draw_arc_elliptique(HA_x0, 120, 120, 80, 0.6, 2.6, BLANC);
 
 
	for(uint8_t n=0; n<9; n++ )
	{
		angle =30+ n*15;  // 1 tiret tous les 15 degrés
		float pourcent = 0.9;
		if (((n+2)%2) == 0) {pourcent = 0.8;}
 
		affi_rayon1(HA_x0, HA_y0+10, 110, degTOrad(angle), pourcent, BLANC, false); // tirets de graduation
	}
}
 
 
 
void rotation1()
{ 
// consigne de cap
// acquisition de l'encodeur pas à pas (1)
	if ( millis() - TEMPO  >= timer1 )
	{
		timer1 = millis();
		bool etat = digitalRead(rot1b);
		if(etat == 0) { hdg1+=1;} else { hdg1-=1;}
		if (hdg1<0){hdg1=355;}
 
		if (hdg1>359){hdg1=0;}		
	}
}
 
 
 
void rotation2()
{
// consigne d'altitude
// acquisition de l'encodeur pas à pas (2)
	if ( millis() - TEMPO  >= timer2 )
	{
		timer2 = millis();
		bool etat = digitalRead(rot2b);
		if(etat == 0) {	asel1+=1; }	else { asel1-=1; }
		if (asel1<1){asel1=1;} // 100 pieds -> 30m
		if (asel1>600){asel1=600;}
	}
}
 
 
 
void init_SDcard()
{
	String s1;
 
	TFT.fillRect(0, 0, 480, 320, NOIR); // efface
	TFT.setTextColor(BLANC, NOIR);
	TFT.setFreeFont(FF1);
 
	uint16_t y=0;
 
	TFT.drawString("PRIMARY FLIGHT DISPLAY", 0, y);
	y+=20;
 
	s1="version " + version;
	TFT.drawString(s1, 0, y);
 
	y+=40;
	TFT.setTextColor(VERT, NOIR);
	TFT.drawString("Init SDcard", 0, y);
	y+=20;
 
 
 	if(!SD.begin())
	{
		TFT.drawString("Card Mount Failed", 0, y);
		delay (2000);
		TFT.fillRect(0, 0, 480, 320, NOIR); // efface
		return;
	}
 
 
    uint8_t cardType = SD.cardType();
 
    if(cardType == CARD_NONE)
    {
        TFT.drawString("No SDcard", 0, y);
        delay (2000);
		TFT.fillRect(0, 0, 480, 320, NOIR); // efface
        return;
    }
 
    SDcardOk=1;
 
    TFT.drawString("SDcard Type: ", 0, y);
	if(cardType == CARD_SD)    {TFT.drawString("SDSC", 150, y);}
    else if(cardType == CARD_SDHC) {TFT.drawString("SDHC", 150, y);}
 
	y+=20;
 
	uint32_t cardSize = SD.cardSize() / (1024 * 1024);
	s1=(String)cardSize + " GB";
	TFT.drawString("SDcard size: ", 0, y);
	TFT.drawString(s1, 150, y);
 
   // listDir(SD, "/", 0);
 
    //Serial.printf("Total space: %lluMB\n", SD.totalBytes() / (1024 * 1024));
    //Serial.printf("Used space: %lluMB\n", SD.usedBytes() / (1024 * 1024));
 
	delay (1000);
	TFT.fillRect(0, 0, 480, 320, NOIR); // efface
 
}
 
 
void init_sprites()
{
	// sprites représentant les lettres 'N' 'S' 'E' 'O' qui seront affichées  sur un cercle, inclinées donc.
 
	SPR_E.setFreeFont(FF1);
	SPR_E.setTextColor(JAUNE);
	SPR_E.createSprite(SPR_W, SPR_H);
	SPR_E.setPivot(SPR_W/2, SPR_H/2);  // Set pivot relative to top left corner of Sprite
	SPR_E.fillSprite(GRIS_TRES_FONCE);
	SPR_E.drawString("E", 2, 1 );
 
	SPR_N.setFreeFont(FF1);
	SPR_N.setTextColor(JAUNE);
	SPR_N.createSprite(SPR_W, SPR_H);
	SPR_N.setPivot(SPR_W/2, SPR_H/2);
	SPR_N.fillSprite(GRIS_TRES_FONCE);
	SPR_N.drawString("N", 2, 1 );
 
	SPR_O.setFreeFont(FF1);
	SPR_O.setTextColor(JAUNE);
	SPR_O.createSprite(SPR_W, SPR_H);
	SPR_O.setPivot(SPR_W/2, SPR_H/2);
	SPR_O.fillSprite(GRIS_TRES_FONCE);
	SPR_O.drawString("W", 2, 1 );
 
	SPR_S.setFreeFont(FF1);
	SPR_S.setTextColor(JAUNE);
	SPR_S.createSprite(SPR_W, SPR_H);
	SPR_S.setPivot(SPR_W/2, SPR_H/2);
	SPR_S.fillSprite(GRIS_TRES_FONCE);
	SPR_S.drawString("S", 2, 1 );
}
 
 
void int_to_array(uint16_t valeur_i)
{
	String s1= (String) valeur_i;
	var_array[0]=s1[0];
	var_array[1]=s1[1];
	var_array[2]=s1[2];
	var_array[3]=s1[3];
	var_array[4]=0;  // zéro terminal  -> string
}
 
 
 
void setup()
{
    Serial.begin(19200);
 
 
	WiFi.persistent(false);
	WiFi.softAP(ssid, password);  // ok, ça marche, crée un réseau. mode privé
	IPAddress IP = WiFi.softAPIP();
 
	server.on("/hdg", HTTP_GET, [](AsyncWebServerRequest *request) // consigne de cap
	{
// attention: ce code est appelé par une interruption WiFi qui intervient hors timing. Donc pas d'affichage ici !!		
		//size_t n=request->params();  // get arguments count
 
		argument_recu1 = request->arg("a1"); // reception de l'argument n°1 de la requête
		num_bali=argument_recu1.toInt();
 
		int_to_array(hdg1);
 
//cet array because la fonction "request->send_P()" n'accèpte pas directement le string
//rappel :
//void send_P(int code, const String& contentType, const uint8_t * content, size_t len, AwsTemplateProcessor callback=nullptr);
//void send_P(int code, const String& contentType, PGM_P content, AwsTemplateProcessor callback=nullptr);
 
		request->send_P(200, "text/plain", var_array); // envoie hdg1 comme réponse au client
	});
 
// réponses aux requêtes :
	server.on("/cap", HTTP_GET, [](AsyncWebServerRequest *request)
	{
		int_to_array(cap);
		request->send_P(200, "text/plain", var_array); // envoie réponse au client
	});
 
	server.on("/rd1", HTTP_GET, [](AsyncWebServerRequest *request)
	{
		int_to_array(nav1radial_deg);
		request->send_P(200, "text/plain", var_array); // envoie réponse au client
	});
 
	server.on("/VORnm", HTTP_GET, [](AsyncWebServerRequest *request)
	{
		uint16_t nav1_nm10 = (uint16_t) (nav1dst / 185.2);
		//if (nav1_nm10 >1000) {nav1_nm10=0;}
 
		int_to_array(nav1_nm10);
		request->send_P(200, "text/plain", var_array); // envoie réponse au client
	});
 
 
    server.begin();
 
/*
// ************* BLUETOOTH *************
	SerialBT.begin("FGpanel_BT01"); //Bluetooth device name
	//Serial.println("The device started, now you can pair it with bluetooth!");
// *************************************
*/
	pinMode(bouton1, INPUT);
 
	//pinMode(led1, OUTPUT);
 
	pinMode(rot1a, INPUT_PULLUP);
	pinMode(rot1b, INPUT_PULLUP);
	pinMode(rot2a, INPUT_PULLUP);
	pinMode(rot2b, INPUT_PULLUP);
 
 
	attachInterrupt(rot1a, rotation1, RISING);
	attachInterrupt(rot2a, rotation2, RISING);
 
	TFT.init();
	TFT.setRotation(1); // 1 ou 3 -> in[0..3] à voir, suivant disposition de l'afficheur
	TFT.fillScreen(TFT_BLACK);
 
	init_SDcard();
 
	init_sprites();
 
	delay(100);
 
 
 
	TFT.setTextColor(NOIR, BLANC);
 
	//TFT.setFreeFont(FF19);
 
	init_affi_HA();
 
	delay(100);
 
	//TFT.fillRect(48, 0, 6, 100,   0xFFE0);
 
//	TFT.fillRect(0, 0, 479, 30, NOIR);
	TFT.setTextColor(BLANC, NOIR);
	TFT.setFreeFont(FF19);
	String s1 = "PFD v";
	s1+= version;
//	TFT.drawString(s1, 70, 3);
 
 
	Ay_actu=120;
	By_actu=120;
 
	altitude =0;
	vitesse =0;
	roulis =0;
	tangage =0;
	cap=0;
	vspeed=0; // vitesse verticale
 
	nav1frq=123500;
	nav2frq=108000;
 
	nav1dst=1852*102; // 102km
	nav1radial_deg=45;
	nav1radial=45.0 * 100.0;
	nav2dst=20000; // 20km
//	affichages();
 
	bouton1_etat = digitalRead(bouton1);
	memo_bouton1_etat = bouton1_etat;
 
	init_FG_bali();
 
	init_affi_autopilot();
	//affi_indicateurs();
	//affi_frq_NAV1();
 
	affi_dst_NAV1();
	affi_radial_NAV1();
 
	affi_dst_NAV2();
	affi_radial_NAV2();
 
	affi_Airport();
}
 
 
 
 
//uint8_t buffer1[200];
 
uint16_t L=0;
uint16_t C=0;
uint16_t x, y;
uint16_t i1 = 0;
 
uint8_t p1;
 
int32_t number = 0;
 
String parametre;
String s1;
String s2;
 
 
void acquisitions()
{
	TFT.setFreeFont(FM9);
	TFT.setTextColor(VERT, NOIR);
 
	if(Serial.available() > 14)
	{
		parametre="";
		s1="";
		char octet_in;
 
		while(octet_in != '=')
		{
		  octet_in = Serial.read();
		  if(octet_in != '=')  {parametre += octet_in; }
		}		
		while(octet_in != '\n')
		{
		  octet_in = Serial.read();
		  if(octet_in != '\n') {s1 += octet_in;  }
		}
 
		if(parametre == "alti" )
		{
			char buf[50];
			s1.toCharArray(buf, 50);
			altitude = atol(buf);
			if (altitude <0) {altitude =0;}  //car pendant la phase d'init du programme Flightgear, altitude << 0 !
			data_ok |= 1; // positionne bit0
 
			////TFT.drawString("Altitude", 0, 40);
			////s2= (String) altitude;
			////TFT.fillRect(120, 40, 100, 30, TFT_BLACK);
			////TFT.drawString(s2, 120, 40);
		}
 
 
		if(parametre == "gnd_elv" )
		{
			char buf[50];
			s1.toCharArray(buf, 50);
			gnd_elv = atol(buf);
			if (gnd_elv <0) {gnd_elv =0;}  
			data_ok |= 2; // positionne bit1
 
			////TFT.drawString("gnd_elv", 0, 0);
			////s2= (String) gnd_elv;
			////TFT.fillRect(120, 0, 100, 30, TFT_BLACK);
			////TFT.drawString(s2, 120, 0);
		}
 
 
 
		if(parametre == "speed" )
		{
			char buf[50];
			s1.toCharArray(buf, 50);
			vitesse = atol(buf);
			data_ok |= 4; // positionne bit2
 
			////TFT.drawString("Vitesse", 0, 70);
			////s2= (String) vitesse;
			////TFT.fillRect(120, 70, 100, 30, TFT_BLACK);
			////TFT.drawString(s2, 120, 70);
		}
 
 
		if(parametre == "pitch" )
		{
			char buf[50];
			s1.toCharArray(buf, 50);
			tangage = atol(buf);
			data_ok |= 8; // positionne bit3
 
			////TFT.drawString("Tangage", 0, 100);
			////s2= (String) tangage;
			////TFT.fillRect(120, 100, 100, 30, TFT_BLACK);
			////TFT.drawString(s2, 120, 100);
		}
 
		if(parametre == "roll" )
		{
			char buf[50];
			s1.toCharArray(buf, 50);
			roulis = atol(buf);
			data_ok |= 16; // positionne bit4
 
			////TFT.drawString("Roulis", 0, 130);
			////s2= (String) roulis;
			////TFT.fillRect(120, 130, 100, 30, TFT_BLACK);
			////TFT.drawString(s2, 120, 130);
		}
 
 
 
		if(parametre == "heading" ) // /orientation/heading-deg = cap actuel de l'avion ; ne pas confondre avec HDG bug !
		{
			char buf[50];
			s1.toCharArray(buf, 50);
			cap = atol(buf);
			data_ok |= 32; // positionne bit5
 
			////TFT.drawString("Cap", 0, 160);
			////s2= (String) roulis;
			////TFT.fillRect(120, 160, 100, 30, TFT_BLACK);
			////TFT.drawString(s2, 120, 160);
		}
 
 
		if(parametre == "vspeed" )
		{
			char buf[50];
			s1.toCharArray(buf, 50);
			vspeed = atol(buf);
			data_ok |= 64; // positionne bit6
 
			////TFT.drawString("vspeed", 0, 170);
			////s2= (String) vspeed;
			////TFT.fillRect(120, 170, 100, 30, TFT_BLACK);
			////TFT.drawString(s2, 120, 170);
		}
 
 
		if(parametre == "nav1frq" )
		{
			char buf[50];
			s1.toCharArray(buf, 50);
			nav1frq = atol(buf);
			data_ok |= 128; // positionne bit7
 
			////TFT.drawString("nav1frq", 100, 170, 1);
			////s2= String(nav1frq, 2); //  String(navfrq, 2);
			////TFT.fillRect(180, 170, 100, 20, TFT_BLACK);
			////TFT.drawString(s2, 180, 170);
		}
 
 
		if(parametre == "nav1dst" )
		{
			char buf[50];
			s1.toCharArray(buf, 50);
			nav1dst = atol(buf);  // en mètres
 
			// Serial.println(nav1dst);
 
			data_ok |= 256; // positionne bit8
 
			////TFT.drawString("nav1dst", 0, 170, 1);
			////s2= (String) nav1dst;
			////TFT.fillRect(120, 170, 100, 30, TFT_BLACK);
			////TFT.drawString(s2, 120, 170);
		}
 
 
		x=100;
 
		if(parametre == "nav2dst" )
		{
			char buf[50];
			s1.toCharArray(buf, 50);
			nav2dst = atol(buf);
			data_ok |= 512; // positionne bit9
 
			////y=160;
			////TFT.drawString("dst:", x, y);
			////s2= (String) nav2dst;
 
			////TFT.fillRect(x+70, y, 100, 20, TFT_BLACK);
			////TFT.drawString(s2, x+70, y);
 
		}
 
 
		if(parametre == "nav2loc" )
		{
// erreur d'angle (/ à l'axe de la piste) dans le plan horizontal sous lequel l'antenne ILS au sol voit l'avion; Doit être 0°
// en fait varie dans la plage [-10.0 .. +10.0] avec un facteur 1000 écrit dans "hardvare4.xml"
			char buf[50];
			s1.toCharArray(buf, 50);
 
			nav2loc = atol(buf); // = 1000* [-10.0 .. +10.0] c.a.d = [-10000 .. +10000];
			//Attention : |nav2loc| jamais > 10, même si l'angle réel est bien plus grand, de l'ordre de 90° !!
 
			data_ok |= 1024; // positionne bit10
 
			////y=160;
			////TFT.drawString("angl_H", x, y);
			////s2= String (nav2loc/1000, 2);
 
			////TFT.fillRect(x+70, y, 100, 20, TFT_BLACK);
			////TFT.drawString(s2, x+70, y);
		}
 
 
		if(parametre == "nav2glide" )
		{
//angle dans le plan vertical sous lequel l'antenne au sol (ILS GLIDE) voit l'avion; Doit être de 3° en finale
//c'est l'inclinaison du plan de descente effectif
			char buf[50];
			s1.toCharArray(buf, 50);
			nav2glide = atol(buf);
			data_ok |= 2048; // positionne bit11
 
			////y=180;
			////TFT.drawString("angl_V", x, y);
			////s2= String (nav2glide/1000, 2);
 
			////TFT.fillRect(x+70, y, 100, 20, TFT_BLACK);
			////TFT.drawString(s2, x+70, y);
		}
 
 
		if(parametre == "gs_ok" )
		{
// indique si le signal ILS  est reçu
// un test en vol permet de voir que le signal décroche au delà de 27.2 nautiques soit 50km de distance 
			char buf[50];
			s1.toCharArray(buf, 50);
			gs_ok = atol(buf);
			data_ok |= 4096; // positionne bit12
 
			////y=180;
			////TFT.drawString("angl_V", x, y);
			////s2= String (nav2glide/1000, 2);
 
			////TFT.fillRect(x+70, y, 100, 20, TFT_BLACK);
			////TFT.drawString(s2, x+70, y);
		}		
 
 
		if(parametre == "nav1radial" )
		{
//angle dans le plan horizontal sous lequel la station (VOR) voit l'avion
			char buf[50];
			s1.toCharArray(buf, 50);
			nav1radial = atol(buf);
			nav1radial_deg = nav1radial/100;
			data_ok |= 8192; // positionne bit13
 
			////y=180;
			////TFT.drawString("radial", x, y);
			////s2= String (nav2radial/100, 2);
 
			////TFT.fillRect(x+70, y, 100, 20, TFT_BLACK);
			////TFT.drawString(s2, x+70, y);
		}
 
 
		if(parametre == "nav2radial" )
		{
//angle dans le plan horizontal sous lequel l'antenne au sol (LOC) voit l'avion
			char buf[50];
			s1.toCharArray(buf, 50);
			nav2radial = atol(buf);
			data_ok |= 16384; // positionne bit14
 
			////y=180;
			////TFT.drawString("radial", x, y);
			////s2= String (nav2radial/100, 2);
 
			////TFT.fillRect(x+70, y, 100, 20, TFT_BLACK);
			////TFT.drawString(s2, x+70, y);
		}
 
	}
 
 
 
	delay(3); // important sinon ne recevra pas la totalité des données (qui se fait en plusieurs passes)
 
// pour test	
////TFT.drawString("data= ", 90, 40);
////s2= (String) data_ok;
////TFT.fillRect(140, 40, 50, 30, TFT_BLACK);
////TFT.drawString(s2, 150, 40);
 
}
 
 
 
void data_out()
{
 
// destination FlightGear par la liaison série USB
 
	Serial.print(hdg1);  // consigne de Cap -> autopilot
	Serial.print(',');
 
	Serial.print(asel1); // consigne d'altitude -> autopilot
	Serial.print(',');
 
	float v1 = liste_bali[num_bali].frq_VOR/100.0;
	Serial.print(v1);  // écrit la fréquence VOR dans Nav1
	Serial.print(',');
 
	float v2 = liste_bali[num_bali].frq_ILS/100.0;
	Serial.print(v2); // écrit la fréquence ILS dans Nav2
	Serial.print('\n');	
 
}
 
 
 
void affichages()
{
	if (roulis < -45)	{roulis = -45;}
	if (roulis > 45)	{roulis = 45;}
 
	if (tangage < -30)	{tangage = -30;}
	if (tangage > 30)	{tangage = 30;}
 
 
	affi_HA();
	affi_vitesse();
	affi_altitude();
	trace_arc_gradu();
	affi_cap();
	affi_vt_verticale();
	affi_acceleration();
	affi_autopilot();
	affi_asel();
	dessine_avion();
	affi_indicateurs();
	affi_radial_NAV1();
	affi_radial_NAV2();
	affi_Airport();
}
 
 
void affi_nop()
{
	for(int8_t dy=-2; dy<3; dy++)
	{
		TFT.drawLine(HA_x0-HA_w, HA_y0-HA_h +dy, HA_x0 +HA_w, HA_y0 +HA_h +dy, ROUGE);
		TFT.drawLine(HA_x0-HA_w, HA_y0+HA_h +dy, HA_x0 +HA_w, HA_y0 -HA_h +dy, ROUGE);
	}
 
	//TFT.fillRect(0, 0, 239, 30, NOIR);
	TFT.setTextColor(BLANC, ROUGE);
	TFT.setFreeFont(FF18);
	TFT.drawString("No Data", HA_x0-34, HA_y0+30);
}
 
 
 
 
void init_affi_autopilot()
{
 
	TFT.setFreeFont(FF1);
	TFT.setTextColor(JAUNE, GRIS_AF);
 
// ALT
 
	//TFT.drawString("ALT", x_autopilot, 260, 1);
	//TFT.drawRoundRect(x_autopilot-4, 255, 45, 42, 5, BLANC);
}
 
 
 
void affi_autopilot()
{
// dans le petit cercle en bas à gauche	:
// affiche HDG (flèche jaune), piste (rectangle bleu), VOR (Nav1, ligne verte)
 
	uint16_t x0=70; // 70
	uint16_t y0=248; // 255
 
	TFT.setFreeFont(FF1);
 
	TFT.fillRect(x0, y0+2, 70, 80, NOIR); // efface
 
	TFT.setTextColor(JAUNE, NOIR);
	TFT.drawString("HDG", x0, y0-18);
	//TFT.drawRoundRect(x0-4, 255, 45, 42, 5, BLANC);
 
	TFT.drawCircle(x0+35, y0+34, 30, BLANC);
 
	String s1 =(String)hdg1;
	TFT.setTextColor(BLANC, NOIR);
 
	TFT.drawString(s1, x0+18, y0+35);
 
	TFT.setTextColor(BLANC, NOIR);
	TFT.drawString("N", x0+30, y0-5);
 
	TFT.setTextColor(BLANC, NOIR);
	TFT.drawString("S", x0+30, y0+60);
 
	TFT.setTextColor(BLANC, NOIR);
	TFT.drawString("E", x0+60, y0+27);
	TFT.drawString("W", x0, y0+27);
 
	uint16_t x1,y1;
 
 
// flèche jaune = règlage HDG de l'autopilot
	float angle1 = 90-hdg1;
	affi_rayon2(x0+35, y0+34, 0, 30, angle1, JAUNE, 0); // tige de la flèche
	affi_pointe(x0+35, y0+34, 30, angle1, JAUNE); // pointe triangulaire en bout de flèche
 
// rectangle bleu, très fin -> orientation ('radial') de l'axe de la piste
	float angle2 = 90+nav2radial/100.0;
	affi_rectangle_incline(x0+35, y0+34, 35, angle2, BLEU_CLAIR);
 
// trait vert -> radial du VOR (dont la fréquence radio est réglée dans Nav1)
	float angle3 = 90+nav1radial/100.0;
	//affi_rectangle_incline(x0+35, y0+34, 35, angle3, ROUGE);
	affi_rayon2(x0+35, y0+34, -28, 28, -angle3, VERT, 0); 
 
 
 
// ALTITUDE
 
// ce paramétrage permet de régler la valeur de 0 à 200 (soit 0 à 20000 pieds soit 6000m environ)
//pour aller plus haut on peut toujours utiliser l'interface de FG (touche F11...)
 
/*
	String s2 =(String)asel1;
	TFT.setTextColor(ROSE, NOIR);
	TFT.fillRect(x_autopilot, 280, 40, 15, NOIR); // efface
	TFT.drawString(s2, x_autopilot, 278);
*/
	affi_asel();
 
	data_out();  // ** à commenter le cas échéant pour libérer le port série lors de la mise au point **
 
}
 
 
 
void toutes_les_10s()
{
/*
	uint8_t aa1;
	aa1=70;
	SerialBT.write(aa1);
*/	
	//TFT.fillCircle(450, 310, 5, VERT);
	//delay (100);
	//TFT.fillCircle(450, 310, 5, NOIR);
 
	// write_TFT_on_SDcard(); // commenté le temps de trouver le moyen de lancer par bouton poussoir (manque pin libre...)
 
 
}
 
 
 
void toutes_les_1s()
{
	nb_secondes++;
 
 
//// size_t write(uint8_t c);
//// size_t write(const uint8_t *buffer, size_t size);
 
 
	if(nb_secondes>10)
	{
		nb_secondes=0;
		toutes_les_10s();
	}
 
	dV =10*(vitesse - memo_vitesse);
	memo_vitesse = vitesse;
 
	auto_landing(); // ne sera effectif que si la variable autoland==1; toutefois la fonction est toujours appelée afin d'actualiser les affichages
 
 }
 
/** ================================================================== 
 variables à gérer obligatoirement */
 
uint8_t TEST_AFFI=0;// =0 pour un fonctionnement normal; =1 pour tester les affichages et la fluidité
 
//le nombre de ports GPIO libres étant atteint, on va utiiser un switch unique pour deux fonctions :
uint8_t fonction_bt1 = 1; // 0=saisie écran ; 1=autoland (atterrissage automatique)
 
/** ==================================================================  */
 
uint16_t t=0; // temps -> rebouclera si dépassement    
void loop()
{
 
 
 
	//if (SerialBT.available()) {	Serial.write(SerialBT.read()); }
 
 
 
//le bouton1 est partagé entre deux fonctions, voir ci-dessus "variables à gérer obligatoirement"
	bouton1_etat = digitalRead(bouton1);
 
	if (bouton1_etat != memo_bouton1_etat)
	{
		memo_bouton1_etat = bouton1_etat;
		if (bouton1_etat==0)
		{
			TFT.fillCircle(455, 310, 5, VERT);
 
 
			if (fonction_bt1 == 0) {write_TFT_on_SDcard(); }
			if (fonction_bt1 == 1)
			{
				memo_hdg1 = hdg1; // mémorise le cap avant de passer la main à l'autoland
				autoland=1;
			}
		}
		if (bouton1_etat==1)
		{
			TFT.fillCircle(455, 310, 5, NOIR);
			if (fonction_bt1=1)
			{
// si, suite à un enclenchement non correct de l'autoland (sur un mauvais sens du localizer en particulier)	le cap a été boulversé
// on le remet à sa valeur mémorisée. Evite de devoir tourner le bouton pendant une heure avec l'avion qui part à l'aventure !			
				hdg1 = memo_hdg1; 
				autoland=0;
				init_affi_HA();
			}
		}
	}
 
	temps_ecoule = micros() - memo_micros;
	if (temps_ecoule  >= 1E6)  // (>=) et pas strictement égal (==) parce qu'alors on rate l'instant en question
	{
		memo_micros = micros();
		toutes_les_1s();
	}
 
	if (dV > acceleration) {acceleration++;}
	if (dV < acceleration) {acceleration--;}
 
 
//---------------------------------------------------------------------------------------
	if(TEST_AFFI==1) // pour test des affichages:
	{  
 
	// les valeurs de ces paramètres peuvent être modifiées afin de tester tel ou tel point particulier
 
		vitesse = 100 - 100*cos(t/200.0);
		//vitesse = 100;
 
		altitude = 1000 - 800*cos(t/400.0);
		vspeed = 80*sin(t/100.0);
 
		tangage =20.0*sin(t/87.0);
		roulis = 35.0*sin(t/35.0);
 
		cap =180.0+180.0*sin(t/300.0);
 
		nav1dst=200000+200000*sin(t/100.0) ;// test 400 000 nautiques max = 741km
		nav1radial= 100*45;// 100*(180 + 180.0*sin(t/250.0));
 
		nav2dst-=30;
		nav2radial=304.0 *100.0;
 
 
		data_ok=32767;
		nav2glide= (int16_t) (3000 + 2000*sin(t/77.0) ); // soit 5°... 4°
		nav2loc = 10E+3*sin(t/63.0); // soit -10°... +10°
		gs_ok=1;
 
		affichages();
 
		t++;
 
		TFT.setTextColor(JAUNE, BLEU);
		TFT.setFreeFont(FF1);
		TFT.drawString("mode TEST", 0, 0);
 
 
		if (dV > acceleration) {acceleration++;}
		if (dV < acceleration) {acceleration--;}
		delay(20);
 
	}
 
//---------------------------------------------------------------------------------------
	else  // FONCTIONNEMENT NORMAL
	{
		compteur1+=1;
		if (compteur1 >= 100)  // tous les 1000 passages dans la boucle 
		{
			compteur1=0;
			affi_autopilot();
		}		
 
		acquisitions();
 
/** ----------------------------------------------
 pour tester si data_ok à bien la valeur attendue, c.a.d si toutes les acquisitions sont effectuées
 ce qui est le cas lorsque le dialogue avec le serveur de protocole FG est correctement programmé
 sachant que ce ne sont pas les pièges qui manquent !
*/ 
////TFT.setFreeFont(FM9);
////TFT.setTextColor(VERT, NOIR);
////TFT.drawString("d_sum:", 0, 0);
////s2= (String) data_ok;
////TFT.fillRect(70, 0, 50, 30, TFT_BLACK);
////TFT.drawString(s2, 70, 0);
 
/** ---------------------------------------------- **/
 
		if (data_ok == 32767)
// 32767 = 1+2+4+8+16+32+64+128+256+512+1024+2048+4096+8192+16384 = 0b 1111111 11111111 = (2^15)-1 voir fonction "acquisitions()"
		{
			TFT.fillCircle(440, 310, 5, VERT);
			if (attente_data == 1)
			{
				attente_data=0;
				TFT.fillScreen(TFT_BLACK);
				init_affi_HA();
				init_affi_autopilot();
			}
 
			affichages();
			data_ok=0;
		}
		else
		{
			TFT.fillCircle(440, 310, 5, ROUGE);
			if(attente_data==1)
			{
				affi_nop();
				RAZ_variables();
				affichages();
				delay(300);
			}
		}
	}
 
//---------------------------------------------------------------------------------------
 
 
 
}
 
 
 
/**
-----------------------------------------------------------------------------------------------------------
  ci-dessous contenu du fichier (pour Linux): "/usr/share/games/protocol/hardware4.xml"  qui va bien pour CE programme
 
  IMPORTANT : Lorsque je fais évoluer le programme principal (ci-dessus) je modifie également (le cas échéant) le fichier hardware4.xml (ci-dessous)
  je ne numérote pas le fichier ci-dessous. Donc pensez à toujours utiliser celui qui est présent ici
  (en le recopiant au bon endroit, ici ce n'est qu'un commentaire non fonctionnel en tant que tel).
  en effet les variables transmises par FG doivent correspondre exactement à ce qu'attend l'ESP32, voir la fonction "void acquisitions()"
 
 
  FG doit être lancé avec les paramètres suivants :
 
	--generic=serial,in,2,/dev/ttyUSB0,9600,hardware4
	--generic=serial,out,2,/dev/ttyUSB0,9600,hardware4
 
IMPORTANT :
	Il faut ajouter les DEUX lignes dans un lanceur (tel que "FGo!") pour obtenir un fonctionnement bidirectionnel
 
Remarques :
  - le nom du fichier "hardware4.xml" peut être autre chose pourvu que le paramètre de lancement corresponde exactement au nom choisi
  - le fichier en question n'existe pas par défaut dans ce répertoire, il faut le créer.
 
-----------------------------------------------------------------------------------------------------------
 
 
<?xml version="1.0"?>
 
<PropertyList>
 
<generic>
    <output>
        <binary_mode>false</binary_mode>
        <line_separator>\n</line_separator>
        <var_separator>\n</var_separator>
        <preamble></preamble>
        <postamble></postamble>
 
        <chunk>
            <name>Altitude</name>
            <node>/position/altitude-ft</node>
            <type>integer</type>
            <format>alti=%i</format>
        </chunk>
 
		<chunk>
			<name>ground_elevation</name>
			<type>integer</type>
			<node>/position/ground-elev-ft</node>
			<format>gnd_elv=%i</format>
		</chunk>
        
 
        <chunk>
            <name>Speed</name>
            <node>/velocities/airspeed-kt</node>
            <type>integer</type>
            <format>speed=%i</format>
        </chunk>
 
        <chunk>
            <name>Tangage</name>
            <node>/orientation/pitch-deg</node>
            <type>integer</type>
            <format>pitch=%i</format>
        </chunk>
 
        <chunk>
            <name>Roulis</name>
            <node>/orientation/roll-deg</node>
            <type>integer</type>
            <format>roll=%i</format>
        </chunk>
 
        <chunk>
            <name>Cap</name>
            <node>/orientation/heading-deg</node>
            <type>integer</type>
            <format>heading=%i</format>
        </chunk>
 
        <chunk>
            <name>Vertical_speed</name>
            <node>/velocities/vertical-speed-fps</node>
            <type>integer</type>
            <format>vspeed=%i</format>
        </chunk>
 
 		<chunk>
			<name>Nav1_frq</name>
			<type>integer</type>
			<node>/instrumentation/nav/frequencies/selected-mhz</node>
			<factor>1000</factor>
			<format>nav1frq=%i</format>
		</chunk>       
 
 
        <chunk>
            <name>Nav1_distance</name>
            <node>/instrumentation/nav/nav-distance</node>
            <type>integer</type>
            <format>nav1dst=%i</format>
        </chunk>
 
 
		<chunk>
			<name>Nav2_dist</name>
			<type>integer</type>
			<node>/instrumentation/nav[1]/gs-distance</node>
			<format>nav2dst=%i</format>
		</chunk>
 
 
		<chunk>
			<name>Nav2_loc</name>
			<type>integer</type>
			<node>/instrumentation/nav[1]/heading-needle-deflection</node>
			<factor>1000</factor>
			<format>nav2loc=%i</format>
		</chunk>
 
 
		<chunk>
			<name>Nav2_glide</name>
			<type>integer</type>
			<node>/instrumentation/nav[1]/gs-direct-deg</node>
			<factor>1000</factor>
			<format>nav2glide=%i</format>
		</chunk>
 
 
		<chunk>
			<name>GS_OK</name>
			<type>integer</type>
			<node>/instrumentation/nav[1]/gs-in-range</node>
			<format>gs_ok=%i</format>
		</chunk>
 
 
		<chunk>
			<name>Nav1_radial</name>
			<type>integer</type>
			<node>/instrumentation/nav/radials/actual-deg</node>
			<factor>100</factor>
			<format>nav1radial=%i</format>
		</chunk>
 
 
		<chunk>
			<name>Nav2_radial</name>
			<type>integer</type>
			<node>/instrumentation/nav[1]/radials/target-radial-deg</node>
			<factor>100</factor>
			<format>nav2radial=%i</format>
		</chunk>
 
 
 
 
    </output>
 
 
    <input>
		<line_separator>\n</line_separator>
        <var_separator>,</var_separator>
 
       <chunk>
         <name>heading_bug</name>
         <node>/autopilot/settings/heading-bug-deg</node>
         <type>integer</type>
         <relative>false</relative>
     </chunk>
 
     <chunk>
         <name>asel</name>
         <node>/autopilot/settings/asel</node>
         <type>integer</type>
         <relative>false</relative>
     </chunk>
 
     
     <chunk>
         <name>Nav1_frq</name>
         <node>/instrumentation/nav/frequencies/selected-mhz</node>
         <type>float</type>
         <relative>false</relative>
     </chunk>
 
 
     <chunk>
         <name>Nav2_frq</name>
         <node>/instrumentation/nav[1]/frequencies/selected-mhz</node>
         <type>float</type>
         <relative>false</relative>
     </chunk>
     
 
    
 
   </input>
 
 
 
</generic>
 
</PropertyList>
 
**/