Primary flight display pour FlightGear avec un ESP32

ELECTRONIQUE PROGRAMMABLE

Théorie et Applications

Horizon artificiel +compas +Altitude +Vitesse + Vt ascensionnelle + réglages de l'autopilot. Avec la puissance de l'ESP32.

Cliquez sur une image ci-dessous pour visualiser l'album. Certaines sont commentées

Table des matières :

1 - Un aperçu en vidéo
2 - Vue d'ensemble de cette réalisation :
3 - Le schéma
4 - Le programme pour l'ESP32 à compiler avec l'IDE Arduino

5 - Le principe
6 - L'afficheur utilisé :
7 - Vidéo - Décollage LFMT
8 - Le Lac du Salagou

9 - Utilité du panel ESP32
10 - Evolution
11 - Circuit imprimé
12 - Documents :

1 Un aperçu en vidéo
	Ceci est un test de la rapidité d'affichage avec des données calculées par des fonctions sinus... La vidéo quant-à-elle est prise en vitesse normale (!) En réalité l'ESP32 se connecte au programme de simulation de vol FlightGear par liaison série USB. L'affichage devient alors plus calme et surtout réaliste.

2 Vue d'ensemble de cette réalisation :
	L'intégration dans un boîtier maison (imprimé en 3D) est prévu, avec peut être d'autres instruments de bord.

3 Le schéma
A noter que les ports GPIO 34 et 35 ne sont pas pourvus de résistances de rappel à VCC (Pull-up) internes dans l'ESP32, d'où l'ajout des deux résistances externes de 10k. La saisie des paramètres pour l'autopilot se fait avec deux classiques encodeurs rotatifs. Il ne reste plus beaucoup de broches libres sur le module ESP32 !

CODE SOURCE en C++

 
/*
	FG_panel.ino  - pour ESP32 - version Afficheur TFT 480x320
 
	avec ligne de séparation inclinée
 
	par Silicium628
 
 
*/
 
 
/**
--------------------------------------------------------
CONCERNANT L'AFFICHAGE TFT : Connections :
 
( Pensez à configurer le fichier User_Setup.h de la bibliothèque ~/Arduino/libraries/TFT_eSPI/ )
 
 
TFT_CS <->  GPIO 27  // Chip select control pin
TFT_DC <->  GPIO 14  // Data Command control pin - must use a pin in the range 0-31
TFT_RST <-> GPIO 26  // Reset pin
 
TFT_WR <->  GPIO 12  // Write strobe control pin - must use a pin in the range 0-31
TFT_RD <->  GPIO 13
 
TFT_D0 <->  GPIO 16  // Must use pins in the range 0-31 for the data bus
TFT_D1 <->  GPIO 4   // so a single register write sets/clears all bits
TFT_D2 <->  GPIO 23
TFT_D3 <->  GPIO 22
TFT_D4 <->  GPIO 21
TFT_D5 <->  GPIO 19
TFT_D6 <->  GPIO 18
TFT_D7 <->  GPIO 17
 
**/
 
 
	String version="4.2";
 
 
#include <stdint.h>
#include <TFT_eSPI.h> // Hardware-specific library
#include "Free_Fonts.h"
 
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 CYAN    	0x07FF
#define BLEU_CLAIR  0x455F
#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 BLANC   	0xFFFF
 
 
// AVIONIQUE : Horizon Artificiel (HA):
 
#define HA_CIEL		0x33FE
#define HA_SOL		0xDB60
 
//position et dimensions de l'horizon artificiel
 
#define HA_x_offset 230
#define HA_y_offset 120
#define HA_w 160 // demi largeur
#define HA_h 100	// demi hauteur
 
 
// Width and height of sprite
#define SPR_W 20
#define SPR_H 20
 
int32_t altitude;
int32_t vitesse;
int16_t cap;
int16_t vspeed; // vitesse verticale
 
float roulis;
float tangage;
 
int16_t hdg1  = 150;  // consigne cap
int16_t asel1 = 30; // consigne altitude
 
uint8_t data_ok;
uint8_t attente_data=1;
 
uint8_t premier_passage =1;
 
//const int bouton1 = 25;  // GPIO25
//bool bouton1_etat;
//bool memo_bouton1_etat;
 
 
// deux encodeurs rotatifs pas à pas
const int rot1a = 32;  // GPIO32
const int rot1b = 33;  // GPIO33
 
const int rot2a = 35;  // ATTENTION :  cabler une résistance extérieure de pullup au +3V3 pour ce port
const int rot2b = 34;  // ATTENTION :  cabler une résistance extérieure de pullup au +3V3 pour ce port
 
 
#define TEMPO 50 // tempo anti-rebond pour l'acquisition des encodeurs rotatifs
volatile uint32_t timer1 = 0;
volatile uint32_t timer2 = 0;
 
uint16_t compteur1;
 
/**--------------------------------------------------------
	fonctions AFFICHAGE TFT
--------------------------------------------------------**/    
 
 
/*
 
void dessine_triangles()
{
   int i = 0;
   uint16_t L, H;
   L=TFT.Get_Display_Width();
   H=TFT.Get_Display_Height();
   
   for(i=0; i<H/2; i+=5)
   {
      TFT.Set_Draw_color(0,i+64,i+64);
      TFT.Draw_Triangle(L/2-1,H/2-1-i,L/2-1-i,H/2-1+i,L/2-1+i,H/2-1+i);                   
   }
}
 
*/
 
 
// 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 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 init_affi_HA()
{
	TFT.fillRect(HA_x_offset-HA_w, HA_y_offset-HA_h-1, 2*HA_w, HA_h+1, HA_CIEL);
	TFT.fillRect(HA_x_offset-HA_w, HA_y_offset-HA_h +  HA_h, 2*HA_w, HA_h, HA_SOL);
}
 
 
 
void truc(uint16_t Ax, uint16_t Ay, uint16_t Bx, uint16_t By)
{
	TFT.drawLine(Ax, Ay, Bx, By-1, HA_CIEL);
	TFT.drawLine(Ax, Ay+1, Bx, By+1, HA_SOL);
 
}
 
 
 
void trace_HA()
{
	////String s1=(String) roulis;
	////TFT.drawString(s1, 400, 20, 4);
 
 
// 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 = 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 += 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_x_offset;
	Ay += HA_y_offset;
 
	Bx += HA_x_offset;
	By += HA_y_offset;
 
// pour éciter 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;
	}
 
	//while ((Bx_actu != Bx) || (x2_actu != x2) || (By_actu != By) || (y2_actu != y2)  )
	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++; truc(Ax_actu, Ay_actu, Bx_actu, By_actu); }
		if (Bx_actu > Bx) { Bx_actu--; truc(Ax_actu, Ay_actu, Bx_actu, By_actu); }
 
		if (Ax_actu < Ax) { Ax_actu++; truc(Ax_actu, Ay_actu, Bx_actu, By_actu); }
		if (Ax_actu > Ax) { Ax_actu--; truc(Ax_actu, Ay_actu, Bx_actu, By_actu); }
 
		if (By_actu < By) { By_actu++; truc(Ax_actu, Ay_actu, Bx_actu, By_actu); }
		if (By_actu > By) { By_actu--; truc(Ax_actu, Ay_actu, Bx_actu, By_actu); }
 
		if (Ay_actu < Ay) { Ay_actu++; truc(Ax_actu, Ay_actu, Bx_actu, By_actu); }
		if (Ay_actu > Ay) { Ay_actu--; truc(Ax_actu, Ay_actu, Bx_actu, By_actu); }	
 
 
	}
	dessine_avion(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_maxi =280;
 
//calcul de la position des limites	entre les différentes couleurs verticales
	float d1=HA_y_offset+HA_w/2 + 3.2*((vitesse - vitesse_sol));		if (d1<0) {d1=0;} if (d1>319) {d1=319;}
	float d2=HA_y_offset+HA_w/2 + 3.2*((vitesse - vitesse_mini1));	if (d2<0) {d2=0;} if (d2>319) {d2=319;}
	float d3=HA_y_offset+HA_w/2 + 3.2*((vitesse - vitesse_mini2));	if (d3<0) {d3=0;} if (d3>319) {d3=319;}
	float d4=HA_y_offset+HA_w/2 + 3.2*((vitesse - vitesse_maxi));	if (d4<0) {d4=0;} if (d4>319) {d4=319;}
 
 
	TFT.fillRect(50, 0, 6, (int16_t)d4,  ORANGE);
	TFT.fillRect(50, (int16_t)d4, 6, d3, VERT); 
	TFT.fillRect(50, (int16_t)d3, 6, d2, ORANGE);
	TFT.fillRect(50, (int16_t)d2, 6, d1, ROUGE);
	TFT.fillRect(50, (int16_t)d1, 6, 239, GRIS);
 
//---------------------------------------------------------------------------------------
//échelle verticale graduée glissante
 
	uint16_t y0;
	int16_t vit1;
	float d5;
 
	TFT.setFreeFont(FF1);
 
	y0=3.2*(vitesse%10);
 
	TFT.fillRect(0, 0, 50, 319, GRIS_FONCE); // bande verticale à gauche
	for(int n=0; n<10; n++)
	{
		d5 =5+y0+32.0*n; // 24 pixels verticalement entre chaque trait -> 10*24 = 240px (hauteur de l'afficheur)
		{
			TFT.fillRect(45, (int16_t)d5+5, 10, 2, BLANC); // petits tirets horizontaux
 
			vit1 = vitesse -10*(n-5);
			vit1 /= 10;
			vit1 *= 10;
			s1=(String) vit1;
 
			if ( /*(n%2==0) &&*/ (vit1>=0) && (vit1<1000) ) 
			{
				TFT.setTextColor(BLANC, GRIS_FONCE);
				//TFT.drawString("    ", 9, d5, 1);
				x1=0; 
				if(vit1<100){x1=7;} // pour affichage centré
				if(vit1<10){x1=14;}
				TFT.drawString(s1, x1, (uint16_t)d5, 1); // Graduation (tous les 20kts)
			}
		}
	}
 
//---------------------------------------------------------------------------------------
// affichage de la valeur principale
 
	TFT.setTextColor(BLANC, NOIR);
	TFT.setFreeFont(FF19);
	s1=(String)vitesse;
 
	TFT.fillRect(3, 160, 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, 160, 4); // affiche le nombre
	} // affiche en gros à mi-hauteur de l'écran
	else
	{ TFT.fillRect(3, 160, 42, 26, GRIS); }
 
	TFT.drawRoundRect(1, 159, 45, 28, 5, BLANC); // encadrement de la valeur centrale affichée
 
	TFT.fillTriangle(45, 167, 45, 177, 55, 172, NOIR); // petit triangle (curseur) noir
}
 
 
 
void affiche_asel()
{
	String s2 =(String)(asel1*100);      // consigne ALTITUDE de l'autopilot
	TFT.setTextColor(ROSE, NOIR); //
	TFT.setFreeFont(FF5);
	uint16_t x1;
	x1=405;
	if(asel1<10000){x1+=7;}
	if(asel1<1000){x1+=7;} 
	if(asel1<100){x1+=7;} // pour affichage centré
	if(asel1<10){x1+=7;}
	TFT.fillRect(x1, 0, 70, 20, NOIR); // efface
	TFT.drawString(s2, x1, 5, 1);	
}
 
 
 
void affi_vt_verticale()
{
// = 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_rayon(uint16_t x0, uint16_t y0, uint16_t rayon, double angle)
{
// angle en radians
	float x1, x2;
	float y1, y2;
 
	x1=x0+rayon* cos(angle);
	y1=y0-rayon* sin(angle);
 
	x2=x0+0.9*rayon* cos(angle);
	y2=y0-0.9*rayon* sin(angle);
 
	TFT.drawLine(x1, y1, x2, y2, BLANC);
}
 
 
float degTOrad(float angle)
{
	return (angle * M_PI / 180.0);
}
 
 
 
void affi_cap()
{
 
// cercle de CAP gradué
 
	uint16_t x02 = 230;
	uint16_t y02 = 350;
	float angle; // en radians
	//float cap_RD; // en radians (le cap fourni par FG estant en degrés d'angle)
	uint16_t x_spr;
	uint16_t y_spr;
 
	uint16_t x_hdg;
	uint16_t y_hdg;	
/**
360° =2 pi rad
1° = 2 pi/360 rad = pi/180 rad
**/
	//cap_RD = cap * 2*M_PI / 360;
 
	TFT.fillRect(150, 250, 200, 70, NOIR); // efface
 
	TFT.drawCircle(x02, y02, 85, BLANC);
 
 
	for(uint8_t n=0; n<24; n++ )
	{
		angle = cap+15 + n*15;  // 1 tiret tous les 15 degrés
		affi_rayon(x02, y02, 80, degTOrad(angle)); // tirets de graduation
	}
	x_hdg =  x02 + 80*cos(degTOrad(hdg1-90-cap));
	y_hdg =  y02 + 80*sin(degTOrad(hdg1-90-cap));
 
	TFT.drawLine(x02, y02, x_hdg, y_hdg, GRIS_CLAIR);
	TFT.drawCircle(x_hdg, y_hdg, 5, BLEU_CLAIR); // rond vert sur le cercle = consigne de cap	de l'autopilot
 
	x_spr = x02+80 * cos(degTOrad(angle));
	y_spr = y02-80 * sin(degTOrad(angle));
	TFT.setPivot(x_spr, y_spr);
	SPR_E.pushRotated(-cap+90, TFT_BLACK); // Plot rotated Sprite, black = transparent
 
	x_spr = x02+80 * cos(degTOrad(angle+90));
	y_spr = y02-80 * sin(degTOrad(angle+90));
	TFT.setPivot(x_spr, y_spr);
	SPR_N.pushRotated(-cap, TFT_BLACK); 
 
	x_spr = x02+80 * cos(degTOrad(angle+180));
	y_spr = y02-80 * sin(degTOrad(angle+180));
	TFT.setPivot(x_spr, y_spr);
	SPR_O.pushRotated(-cap-90, TFT_BLACK); 
 
	x_spr = x02+80 * cos(degTOrad(angle-90));
	y_spr = y02-80 * sin(degTOrad(angle-90));
	TFT.setPivot(x_spr, y_spr);
	SPR_S.pushRotated(-cap, TFT_BLACK); 
 
 
// petite "maison" en bas (valeur du cap)
	#define a 200
	#define b a+30
	#define c b+30
	#define d 280
	#define e d+10
	#define f e+26
 
	TFT.drawLine(a, f, c, f, BLANC); // sol
	TFT.drawLine(a, f, a, e, BLANC); // mur de gzuche
	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
 
 
// affiche la valeur	
	String s1;
	uint16_t x0 = a+10;
	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, 42, 20, NOIR); // efface le nombre précédemment affiché
	TFT.setTextColor(BLANC, NOIR);
	TFT.setFreeFont(FF19);
	TFT.drawString(s1, x1, y0, 4);
 
 
}
 
 
 
void affi_altitude()
{
	String s1;
	uint16_t x0 =420;
//---------------------------------------------------------------------------------------
//é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_FONCE); //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'afficheur)
		{
			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_FONCE);
				//TFT.drawString("    ", 9, d5, 1);
				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, 1); // 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(FF19);
 
	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, 4);
	TFT.drawRoundRect(x0-20, y0b-3, 75, 28, 5, BLANC); // encadrement de la valeur centrale affichée
 
 
}
 
 
 
void dessine_avion(uint16_t couleur_i)
{
	TFT.fillRect(HA_x_offset-20, 120, 40, 5, couleur_i);
	TFT.fillCircle(HA_x_offset, 120, 5, couleur_i);
}
 
 
 
 
void trace_arc_gradu()
{
	Draw_arc_elliptique(HA_x_offset, 120, 60, 60, 0.6, 2.6, BLANC);
}
 
 
 
void rotation1()
{
// consigne de cap
	if ( millis() - TEMPO  >= timer1 )
	{
		timer1 = millis();
		bool etat = digitalRead(rot1b);
		if(etat == 0) { hdg1+=5;} else { hdg1-=5;}
		if (hdg1<0){hdg1=355;}
 
		if (hdg1>359){hdg1=0;}		
		affi_autopilot();
	}
}
 
 
void rotation2()
{
// consigne d'altitude
	if ( millis() - TEMPO  >= timer2 )
	{
		timer2 = millis();
		bool etat = digitalRead(rot2b);
		if(etat == 0)
		{
			asel1+=5;
		}
		else
		{
			asel1-=5;
		}
		if (asel1<5){asel1=5;}
		if (asel1>600){asel1=600;}
		affi_autopilot();
	}
 
}
 
 
void setup()
{
	Serial.begin(9600);
 
	//pinMode(bouton1, INPUT_PULLUP);
 
	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); // 0..3 à voir, suivant disposition de l'afficheur
 
	TFT.fillScreen(TFT_BLACK);
 
	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_FONCE);
	SPR_E.setTextColor(JAUNE);
	SPR_E.setFreeFont(FF19);
	SPR_E.drawString("E", 0, 0, 4);
 
	SPR_N.createSprite(SPR_W, SPR_H);
	SPR_N.setPivot(SPR_W/2, SPR_H/2);
	SPR_N.fillSprite(GRIS_FONCE);
	SPR_N.setTextColor(ROUGE);
	SPR_N.setFreeFont(FF19);
	SPR_N.drawString("N", 0, 0, 4);
 
	SPR_O.createSprite(SPR_W, SPR_H);
	SPR_O.setPivot(SPR_W/2, SPR_H/2);
	SPR_O.fillSprite(GRIS_FONCE);
	SPR_O.setTextColor(JAUNE);
	SPR_O.setFreeFont(FF19);
	SPR_O.drawString("W", 0, 0, 4);
 
	SPR_S.createSprite(SPR_W, SPR_H);
	SPR_S.setPivot(SPR_W/2, SPR_H/2);
	SPR_S.fillSprite(GRIS_FONCE);
	SPR_S.setTextColor(VERT);
	SPR_S.setFreeFont(FF19);
	SPR_S.drawString("S", 0, 0, 4);
 
	delay(100);
 
 
 
	TFT.setTextColor(NOIR, BLANC);
 
	//TFT.setFreeFont(FF19);
	//TFT.drawString("FlightGear motor", 0, 0, 4);
 
	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, 2);
 
 
	Ay_actu=120;
	By_actu=120;
 
	altitude =0;
	vitesse =0;
	roulis =0;
	tangage =0;
	cap=0;
	vspeed=0; // vitesse verticale
 
 
//	affichages();
 
	//bouton1_etat = digitalRead(bouton1);
	//memo_bouton1_etat = bouton1_etat;
 
	init_affi_autopilot();
 
}
 
 
 
 
//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()
{
 
	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);
			data_ok |= 1; // positionne bit0
 
 
			////TFT.drawString("Altitude", 0, 40, 4);
			////s2= (String) altitude;
			////TFT.fillRect(120, 40, 100, 30, TFT_BLACK);
			////TFT.drawString(s2, 120, 40, 4);
		}
 
		if(parametre == "speed" )
		{
			char buf[50];
			s1.toCharArray(buf, 50);
			vitesse = atol(buf);
			data_ok |= 2; // positionne bit1
 
 
			////TFT.drawString("Vitesse", 0, 70, 4);
			////s2= (String) vitesse;
			////TFT.fillRect(120, 70, 100, 30, TFT_BLACK);
			////TFT.drawString(s2, 120, 70, 4);
		}
 
		if(parametre == "pitch" )
		{
			char buf[50];
			s1.toCharArray(buf, 50);
			tangage = atol(buf);
			data_ok |= 4; // positionne bit2
 
			////TFT.drawString("Tangage", 0, 100, 4);
			////s2= (String) tangage;
			////TFT.fillRect(120, 100, 100, 30, TFT_BLACK);
			////TFT.drawString(s2, 120, 100, 4);
		}
 
		if(parametre == "roll" )
		{
			char buf[50];
			s1.toCharArray(buf, 50);
			roulis = atol(buf);
			data_ok |= 8; // positionne bit3
 
			////TFT.drawString("Roulis", 0, 130, 4);
			////s2= (String) roulis;
			////TFT.fillRect(120, 130, 100, 30, TFT_BLACK);
			////TFT.drawString(s2, 120, 130, 4);
		}
 
 
 
		if(parametre == "heading" )
		{
			char buf[50];
			s1.toCharArray(buf, 50);
			cap = atol(buf);
			data_ok |= 16; // positionne bit4
 
			////TFT.drawString("Cap", 0, 160, 4);
			////s2= (String) roulis;
			////TFT.fillRect(120, 160, 100, 30, TFT_BLACK);
			////TFT.drawString(s2, 120, 160, 4);
		}
 
 
		if(parametre == "vspeed" )
		{
			char buf[50];
			s1.toCharArray(buf, 50);
			vspeed = atol(buf);
			data_ok |= 32; // positionne bit5
 
			////TFT.drawString("vspeed", 0, 170, 4);
			////s2= (String) vspeed;
			////TFT.fillRect(120, 170, 100, 30, TFT_BLACK);
			////TFT.drawString(s2, 120, 170, 4);
		}	
 
	}
 
	delay(1); // important sinon ne recevra pas la totalité des données (qui se fait en plusieurs passes)
 
// pour test	
////TFT.drawString("data= ", 90, 40, 4);
////s2= (String) data_ok;
////TFT.fillRect(140, 40, 50, 30, TFT_BLACK);
////TFT.drawString(s2, 150, 40, 4);
 
}
 
 
 
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'alititude -> autopilot
	Serial.print('\n');  
 
}
 
 
 
void affichages()
{
	trace_HA();
	affi_vitesse();
	affi_altitude();
	trace_arc_gradu();
	affi_cap();
	affi_vt_verticale();
	affi_autopilot();
	affiche_asel();
 
}
 
 
void affi_nop()
{
	TFT.drawLine(HA_x_offset-HA_w, HA_y_offset-HA_h, HA_x_offset +HA_w, HA_y_offset +HA_h, JAUNE);
	TFT.drawLine(HA_x_offset-HA_w, HA_y_offset+HA_h, HA_x_offset +HA_w, HA_y_offset -HA_h, JAUNE);
 
 
	//TFT.fillRect(0, 0, 239, 30, NOIR);
	TFT.setTextColor(JAUNE, BLEU);
	TFT.setFreeFont(FF19);
	TFT.drawString("No Data", 180, 140, 4);
}
 
 
 
 
void init_affi_autopilot()
{
	uint16_t x0;
	TFT.setFreeFont(FF1);
	TFT.setTextColor(JAUNE, GRIS_FONCE);
 
 
// ALT
	x0=355;
	TFT.drawString("ALT", x0, 260, 1);
	TFT.drawRoundRect(x0-4, 255, 45, 42, 5, BLANC);
 
}
 
 
 
void affi_autopilot()
{
// HDG (cap)
 
	uint16_t x0=70; // 70
	uint16_t y0=245; // 255
 
	TFT.setFreeFont(FF1);
 
	TFT.fillRect(x0, y0, 70, 80, NOIR); // efface
	//TFT.drawLine(105, 255, 105, 319, BLEU);
	//TFT.drawLine(75, 289, 135, 289, BLEU);
 
	TFT.setTextColor(JAUNE, NOIR);
	TFT.drawString("HDG", x0+20, y0+15, 1);
	//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, 1);
 
	TFT.setTextColor(BLANC, NOIR);
	TFT.drawString("N", x0+30, y0-5, 1);
 
	TFT.setTextColor(BLANC, NOIR);
	TFT.drawString("S", x0+30, y0+60, 1);
 
	TFT.setTextColor(BLANC, NOIR);
	TFT.drawString("E", x0+60, y0+27, 1);
	TFT.drawString("W", x0, y0+27, 1);
 
	uint16_t x1,y1;
	x1= x0+35 + 30*cos((hdg1-90)/57.3); // =360/2pi
	y1= y0+34 + 30*sin((hdg1-90)/57.3);
	TFT.fillCircle(x1, y1, 3, VERT); // rond vert sur le cercle = cap
	TFT.drawLine(x0+35, y0+34, x1, y1, VERT);
 
 
// ALTITUDE
	uint16_t x2=355;
 
// 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(x2, 280, 40, 15, NOIR); // efface
	TFT.drawString(s2, x2, 278, 1);
 
	affiche_asel();
 
	data_out();
 
}
 
 
 
void loop()
{
 
/*
	bouton1_etat = digitalRead(bouton1);
 
	if (bouton1_etat != memo_bouton1_etat)
	{
		memo_bouton1_etat = bouton1_etat;
 
		if (bouton1_etat == 0)
		{
			TFT.fillCircle(70, 20, 10, VERT);
			data_out();
			delay(300);
			TFT.fillCircle(70, 20, 10, NOIR);
 
		}	
	}
*/
 
 
// #define TEST_AFFI // commenter cette ligne pour un fonctionnement normal; décommenter pour tester les affichages et la fluidité
 
 
//---------------------------------------------------------------------------------------
#ifdef TEST_AFFI  // ne pas toucher cette ligne
 
// pour test des affichages:
 
	uint8_t octet_i;
	uint16_t t=0; // temps -> rebouclera si dépassement
 
 
	while(1) // boucle infinie
	{
 
// les valeurs de ces paramètres peuvent être modifiées afin de tester tel ou tel point particulier
		vitesse = 100 - 100*cos(t/50.0);
		altitude = 1000 - 10*cos(t/80.0);
 
		vspeed = 100*sin(t/30.0);
 
		tangage =80.0*sin(t/82.0);
		roulis = 65.0*sin(t/35.0);
 
		cap =180.0+180.0*sin(t/20.0);
		data_ok=63;
 
 
		affichages();
 
		t++;
 
		TFT.setTextColor(JAUNE, BLEU);
		TFT.setFreeFont(FF19);
		TFT.drawString("TEST AFFI", 150, 180, 4);
 
		delay(20);
 
 
	}
 
//---------------------------------------------------------------------------------------
#else // ne pas toucher cette ligne
 
	compteur1+=1;
	if (compteur1 >= 100)  // tous les 1000 passages dans la boucle 
	{
		compteur1=0;
		affi_autopilot();
	}		
 
 
	acquisitions();
 
	if (data_ok == 63) // 63 cete valeur = 1+2+4+8+16+32 - voir fonction "acquisitions()"
	{
		TFT.fillCircle(390, 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(390, 310, 5, ROUGE);
		if(attente_data==1)
		{
			affi_nop();
			affichages();
			delay(300);
		}
	}
 
//---------------------------------------------------------------------------------------
#endif // ne pas toucher cette ligne
 
 
 
 
}
 
 
 
/**
-----------------------------------------------------------------------------------------------------------
  contenu du fichier (sous Linux) "/usr/share/games/protocol/hardware4.xml" qui va bien pour ce programme
  
 
  * FG doit en conséquence être lancé avec les paramètres *
 
	--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>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>
 
        
 
    </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>
 
   </input>
 
 
 
</generic>
 
</PropertyList>
 
 
 
**/

J'ai fait un effort pour commenter en détail le code source.

A noter : dans la boucle principale (loop) figure cette ligne que l'on doit gérer absolument. (C'est une directive de compilation conditionnelle) :


#define TEST_AFFI // commenter cette ligne pour un fonctionnement normal; dé-commenter pour tester les affichages et la fluidité

Pour la commenter, il suffit d'ajouter // en début de ligne afin d'obtenir un fonctionnement normal à la place d'un affichage (agité !) de test

5 Le principe
Le simulateur FlightGear Open-source, gratuit, (pour Linux) comprend outre un serveur html, des serveurs de protocoles série (telnet, mais aussi "générique" qui nous intéresse ici). Encore faut-il définir ce protocole générique précisément. Il faut pour cela créer un fichier xml et le placer dans le répertoire de "protocol" de FlightGear. Sous linux ça donne ça : `/usr/share/games/protocol/hardware4.xml` J'ai recopié le contenu de ce fichier au bas du code source. Il comprend deux parties, "output" et "input". Ce n'est pas tout : pour que le programme FG tienne compte de ce fichier, il faut le lancer avec les deux options suivantes (les 2 options sont indispensables afin d'obtenir un fonctionnement bidirectionnel): `--generic=serial,in,2,/dev/ttyUSB0,9600,hardware4 --generic=serial,out,2,/dev/ttyUSB0,9600,hardware4` La partie "output" permet de publier, à destination de l'ESP : l'altitude la vitesse le tangage le roulis le cap la vitesse verticale La partie "input" permet de régler à l'aide de deux encodeurs rotatifs pas à pas reliés à l'ESP, les consignes d'altitude et de cap du pilote automatique de FG. (avant de décoller, on doit aller dans la fenêtre de paramétrage de l'autopilot avec la touche de fonction F11, et sélectionner HDG et ALT. ensuite après prise d'altitude minimale, on peut lancer l'autopilot avec par exemple un bouton de la manette de jeux...)

6 L'afficheur utilisé :

C'est un TFT LCD 480 x 320 que l'on pilote ici par son interface parallèle, d'où la très grande rapidité.

7 Vidéo - Décollage LFMT

8 Le Lac du Salagou

J'ai plaqué une texture image sur le relief de la presqu’île ce qui donne un rendu bien plus réaliste, avec la couleur rouge caractéristique des roches, qu'on appelle dans l'Hérault la "ruffe".

9 Utilité du panel ESP32

Cela permet de piloter l'avion calmement, en pilotage automatique, sans afficher le tableau de bord sur la moité de l'écran de l'ordinateur, ou même en affichage extérieur sans le tableau de bord, par exemple, et profiter de la vue. Parce que oui, FlightGear bien configuré et très beau, comme on peut le constater avec les copies d'écran que j'ai rajoutées au début de cet article. J'ai blenderisé en 3D pas mal de choses pour FGFS.

10 Evolution
Cette réalisation est en pleine phase d'évolution, par exemple j'améliore l'affichage chaque jour...

11 Circuit imprimé
	9 mai 2021 : Je prépare en ce moment, sous Kicad, un circuit imprimé (en jaune sur cette vue) qui assemblera facilement le module ESP32 et l'afficheur TFT. Je publierai ici le tout dès que ce sera fait, et que le fonctionnement sera correct (j'ai créé les composants, il est assez facile de se gourer dans la numérotation des pins voire de dessiner en image miroir... surtout avec ces écrans TFT pour lesquels on hésite parfois à déterminer quelle est la face composants et quelle est la face cuivre, je vous laisse méditer la chose...)

12 Documents :
FG_panel.zip

13 -

Liens...

Me contacter à propos de cet article :

Réponses à certaines de vos questions...

120

[ Retour Accueil ]

Ce site est développé en PHP avec des LOGICIELS LIBRES sous LINUX

Me contacter à propos de cet article :

Question mathématique :