PFD (Primary Flight Display) pour Flightgear - ESP32

Horizon artificiel +Compas, Altitude, Vitesse, réglages autopilot, ILS pour Flightgear, simulateur de vol Open Source. Puissance ESP32.
Table des matières :
1 - Un aperçu en vidéo (LFMT)
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 - Dans la jungle des afficheurs
8 - Utilité du panel ESP32
9 - Evolution
10 - Circuit imprimé
11 - Le boitier imprimé en 3D
12 - Disposition des éléments sur le circuit imprimé
13 - Captures d'écran sur SDcard
14 - Evolution 2
15 - l'ILS est fonctionnel
16 - Affichage de l'orientation de la piste
17 - Fonction Autoland (Atterrissage automatique)
18 - Deuxième instrument : ND (Navigation Display)
19 - Vers un troisième instrument ?
20 - Code source de l'instrument ND (Navigateur Display)
21 - Planche de bord
22 - La voici la planche de bord
23 - Utilisation
24 - Un troisième ESP32 gérant des boutons
25 - Le panel des boutons
26 - Les boutons sont dans la boite
27 - Code source du panel des boutons (SW)
28 - Sérigraphie
29 - Un pas de plus vers une planche de bord
30 - Nouvelle version, nouvelles fonctions...
31 - Ecrans de la version 17.3
32 - Version 18.0
33 - Schéma de la version 18.0 du module ND
34 - Version 19.0
35 - Version 21.0
36 - version 24.0
37 - Version 25.0 - Plan des installations
38 - version 28.0
39 - Un nouveau module ! le MCDU
40 - Détail du MCDU
41 - Code source du MCDU
42 - Le fichier d'entête MCDU.h
43 - Documents et code source complet :
44 - Utiliser Geany comme éditeur
45 - Voici un exemple de l'édition du code source avec Geany
46 - Vidéo - Décollage LFMT
47 - Le Lac du Salagou

Je fais de fréquentes mises à jour des pages. Ce bouton permet de raffraichir la version mise en cache dans votre navigateur (et rien d'autre !!!)

1 Un aperçu en vidéo (LFMT)

L'ESP32 se connecte au programme de simulation de vol FlightGear par liaison série USB et permet, outre l'affichage des paramètres de vol, de gérer le pilote automatique de Flightgear en temps réel, et de contrôler totalement l'approche et atterrissage la piste choisie.

Cette vidéo est un montage montrant, en incrustation, le fonctionnement de cette réalisation et le comportement de l'avion, ici le Citation X, lors d'un vol complet : Décollage de LFMT, mise en palier, engagement de l'autopilot de FG, puis tour de piste vent arrière, approche et posé ILS totalement automatique.



Dans cette troisième vidéo, l'atterrissage se fait en plaçant la caméra devant l'avion, en le précédant, donc sans aucune vue de la piste ! Le but étant de montrer la maturité du programme de pilotage auto qui est à l’œuvre. Les seules choses que j'ai faites en manuel, pour l'attéro : juste après le désengagement du pilote automatique de FlightGear, réduction des gaz puis sortie des AF. L'avion se cabre alors un peu, et l'arrondi se fait, touché en premier du train principal, puis ensuite de la roue avant . Puis freinage manuel aussi. La gouverne de direction (lacet) reste quant à elle actionnée par les ESP32. La précision de la trajectoire au sol, sur la piste, dépend des coordonnées GPS enregistrées dans le programme.

Cette fois l'atterrissage se fait dans un brouillard à couper à la tronçonneuse, le but étant de montrer que l'autopilot supervisé par un ESP32 s'en sort très bien. De quoi réconforter ceux qui craignent l'avion. Le posé est un peu brutal, on va améliorer ça.


.

Les vidéos sont un peu "crénelées" afin d'éviter un fichier trop gros, mais bien entendu, sur le PC sous Linux, avec un écran FUll HD, l'image est bien plus belle. Vous avez quand même intérêt à visionner celle-ci en tout écran.

Concernant les paysages : il en est de bien plus beau (dans Flightgear j'entends) que celui-ci, je pense à la Corse (après mise à jour de la scène), ou Annecy, voire Tarbes, c'est à dire près des montagnes (pour ce qui concerne la France)...

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. Les quatre capas de 10nF sont en cms à souder au au plus près des encodeurs (hors implantation du board donc).

Il ne reste plus beaucoup de broches libres sur le module ESP32 !

4 Le programme pour l'ESP32 à compiler avec l'IDE Arduino

CODE SOURCE du PFD en C++
  1. //
  2. // ==================================
  3. String version="29.1";
  4. // ==================================
  5.  
  6. /*
  7. PFD.ino - Primary Flight Display pour Flightgear et ESP32 - version Afficheur TFT 480x320
  8. Ne concerne pas un avion réel ! (ni ULM...)
  9. Fonctionne avec simulateur FlightGear sous Linux et avec l'avion Citation X (mon préféré!)
  10. Les autres avions ont un autopilot différent et donc une "Property tree" différente, il faudrait adapter le programme
  11. - en particulier ne fonctionne pas tel quel avec les B7xx ni les A3xx
  12.  
  13. par Silicium628
  14.  
  15. */
  16. /**---------------------------------------------------------------------------------------
  17. Logiciel libre et gratuit : Pour les #includes issus de l'univers Arduino (que je ne fournis pas), il faut voir au cas par cas.
  18. (drivers d'affichage en particulier)
  19.  
  20. ---------------------------------------------------------------------------------------
  21. De petites images à placer sur la SDcard centrées sur les aérodromes proviennent de OpenStreetMap
  22.  
  23. OpenStreetMap® est un ensemble de données ouvertes,
  24. disponibles sous la licence libre Open Data Commons Open Database License (ODbL)
  25. accordée par la Fondation OpenStreetMap (OSMF).
  26.  
  27. Voir ce lien pour plus de détails :
  28. https://www.openstreetmap.org/copyright
  29. --------------------------------------------------------------------------------------**/
  30.  
  31. /*=====================================================================================================
  32. CONCERNANT L'AFFICHAGE TFT : connexion :
  33.  
  34. ( Pensez à configurer le fichier User_Setup.h de la bibliothèque ~/Arduino/libraries/TFT_eSPI/ )
  35.  
  36. les lignes qui suivent ne sont q'un commentaire pour vous indiquer la config à utiliser
  37. placée ici, elle ne sont pas fonctionnelles
  38. Il FAUT modifier le fichier User_Setup.h installé par le système Arduino dans ~/Arduino/libraries/TFT_eSPI/
  39.  
  40. // ESP32 pins used for the parallel interface TFT
  41. #define TFT_CS 27 // Chip select control pin
  42. #define TFT_DC 14 // Data Command control pin - must use a pin in the range 0-31
  43. #define TFT_RST 26 // Reset pin
  44.  
  45. #define TFT_WR 12 // Write strobe control pin - must use a pin in the range 0-31
  46. #define TFT_RD 13
  47.  
  48. #define TFT_D0 16 // Must use pins in the range 0-31 for the data bus
  49. #define TFT_D1 4 // so a single register write sets/clears all bits
  50. #define TFT_D2 2 // 23
  51. #define TFT_D3 22
  52. #define TFT_D4 21
  53. #define TFT_D5 15 // 19
  54. #define TFT_D6 25 // 18
  55. #define TFT_D7 17
  56. =====================================================================================================
  57.  
  58. Notes :
  59. - Si les data de FG ne sont pas reçues, il faut vérifier que le PFD est bien connecté sur le port USB0 (et pas USB1 ou autre...)
  60. */
  61.  
  62.  
  63. // v14 la fonction Autoland() utilise le glide pour la descente et non plus une altitude calculée théorique
  64. // v15.2 modif du fichier hardware4.xml (nav-distance)
  65. // v15.3 revu autoland - possibilité de poser auto si localizer seul (aérodrome non équipé de glide de glide).
  66. // v15.6 nombreuses modifs dans tous les fichiers, dont fichier FG_data.h
  67. // v16.0 prise en charge du module "SW" (boutons poussoirs) par WiFi
  68. // v16.2 prise en charge des 2 nouveaux boutons (target_speed) + le fichier "hardware4.xml" a été modifié en conséquence
  69. // v20.0 autoland possible (par GPS au lieu de l'ILS) même pour aérodromes non équipé ILS
  70. // v21.0 autoland toujours calculé par GPS, avec prise en compte de l'altitude de l'aérodrome
  71. // v22.0 modifs fonction autolang & fichier 'hardware4.xml' (prise en charge du trim de profondeur, voir 'desengage_autoland()'
  72. // v24.2 tous les calculs de position et de direction se font directement avec les coordonnées GPS,
  73. // sans passer par système LAMBERT
  74. // v26.0 prise en compte de la longueur de la piste pour l'autolanding
  75. // v26.2 asservissement (facultatif) de la gouverne de direction et de la roue avant au décollage et à l'atterrissage
  76.  
  77. /* le numéro de version doit être identique à celui du ND (Navigation Display) et des autres fichiers sources */
  78.  
  79.  
  80. /** un peu de théorie : ****************************
  81.  
  82. ALTITUDE vs HAUTEUR
  83.  
  84. Une hauteur est la distance verticale entre un aéronef et la surface qu'il survole (terre ou eau).
  85.  
  86. Pour exprimer une hauteur, il est défini les hauteurs AGL (Above Ground Level) ou ASFC (Above Surface).
  87. Il s'agit de la hauteur entre l'avion et le sol juste en dessous de sa position. Elle suit donc le relief.
  88.  
  89. Pour exprimer une hauteur au dessus de l'aérodrome, il est défini la hauteur AAL (Above Aerodrome Level).
  90. Il s'agit de la hauteur entre l'avion et le point de référence de l'aérodrome comme s'il était en dessous de la
  91. position de l'appareil (même s'il n'y est pas). Cette hauteur ne suit pas le relief.
  92.  
  93. source : https://aeroclub-narbonne.com/download/2017/04/BASE_ALT.pdf
  94. IVAO TM © ELH FLA septembre 2014
  95. je conseille de lire et relire l'ensemble de ce PDF.
  96.  
  97. *****************************************************/
  98.  
  99.  
  100. #include "PFD.h"
  101. #include <stdint.h>
  102. #include <TFT_eSPI.h> // Hardware-specific library
  103. #include "Free_Fonts.h"
  104.  
  105. #include "FS.h"
  106. #include "SD.h"
  107. #include "SPI.h"
  108.  
  109. #include "FG_data.h"
  110. #include "Fonctions1.h"
  111.  
  112. #include <WiFi.h> // Ce PFD est un serveur WiFi
  113. #include "ESPAsyncWebServer.h"
  114.  
  115.  
  116. const char* ssid = "PFD_srv";
  117. const char* password = "72r4TsJ28";
  118.  
  119. AsyncWebServer server(80); // Create AsyncWebServer object on port 80
  120.  
  121. String argument_recu1;
  122. String argument_recu2;
  123. String argument_recu3;
  124.  
  125. TFT_eSprite SPR_E = TFT_eSprite(&TFT480); // Declare Sprite object "SPR_11" with pointer to "TFT" object
  126. TFT_eSprite SPR_N = TFT_eSprite(&TFT480);
  127. TFT_eSprite SPR_O = TFT_eSprite(&TFT480);
  128. TFT_eSprite SPR_S = TFT_eSprite(&TFT480);
  129.  
  130. TFT_eSprite SPR_trajectoire = TFT_eSprite(&TFT480);
  131.  
  132. VOYANT voyant_L; // Localizer (azimut)
  133. VOYANT voyant_G; // Glide (hauteur)
  134. VOYANT voyant_APP; // Approche auto (= attéro ILS)
  135. VOYANT voyant_route;
  136. VOYANT voyant_RD; // Auto rudder (asservissement de la gouverne de direction (lacet) et de la roulettes de nez au sol)
  137. VOYANT voyant_ATT; // atterrissage en cours
  138.  
  139. Led Led1;
  140. Led Led2;
  141. Led Led3;
  142. Led Led4;
  143. Led Led5;
  144.  
  145.  
  146. uint16_t hauteur_mini_autopilot = 20; // ou 100 ou 300 ou 500 à tester...
  147.  
  148.  
  149. int16_t Ax_actu, Ay_actu;
  150. int16_t Bx_actu, By_actu;
  151.  
  152. //position et dimensions de l'horizon artificiel
  153. #define HA_x0 210
  154. #define HA_y0 130
  155. #define HA_w 120 // demi largeur
  156. #define HA_h 100 // demi hauteur
  157.  
  158. #define x_autopilot 320
  159.  
  160. // Width and height of sprite
  161. #define SPR_W 14
  162. #define SPR_H 14
  163.  
  164.  
  165. /*
  166. #define taille1 100000 //480*320*2
  167. uint8_t data_ecran[taille1];
  168. */
  169.  
  170. uint32_t memo_micros = 0;
  171. uint32_t temps_ecoule;
  172. uint16_t nb_secondes=0;
  173. uint8_t nb_acqui;
  174.  
  175. String parametre; //garde en mémoire les données reçues par USB entre les passages dans la fonction "void acquisitions()"
  176.  
  177. uint8_t landing_light1=0;
  178. uint8_t landing_light2=0;
  179.  
  180. float roulis;
  181. float tangage;
  182.  
  183.  
  184. float altitude_GPS_float;
  185. int32_t altitude_GPS; // accepte les valeurs négatives (par exemple si QNH mal réglé avant décollage)
  186. int32_t hauteur_AAL; // (Above Aerodrome Level)
  187.  
  188. #define ASL 0
  189. #define AAL 1
  190.  
  191. uint8_t mode_affi_hauteur = ASL;
  192.  
  193. int32_t gnd_elv; // feet
  194. int32_t vitesse; // kts
  195. int32_t memo_vitesse;
  196. int16_t target_speed =180; // consigne de vitesse pour l'autopilot
  197. int16_t dV;
  198. int16_t acceleration;
  199. int16_t vspeed; // vitesse verticale
  200.  
  201. float cap; // en degrés d'angle; direction actuelle du nez de l'avion
  202.  
  203. int16_t hdg1 = 150; // en degrés d'angle; consigne cap = Heading (HDG) Bug
  204. int16_t memo_hdg1;
  205. uint8_t flag_refresh_hdg=0;
  206. uint8_t flag_traiter_SW=0;
  207. uint8_t flag_traiter_MCDU=0;
  208.  
  209.  
  210. float lat_avion; // WGS84
  211. float lon_avion; // WGS84
  212.  
  213. float px_par_km;
  214. float px_par_NM;
  215.  
  216.  
  217. //Les points AA et BB sont les points d'insertion en finale, situés à 10NM de chaque côté dans l'axe de la piste
  218. //Leurs coordonnées sont calculées en fonction de celles de la piste
  219. float lon_pt_AA;
  220. float lat_pt_AA;
  221. float lon_pt_BB;
  222. float lat_pt_BB;
  223.  
  224.  
  225. float GPS_distance_piste; // en NM
  226. float memo_GPS_distance_piste; // servira à savoir si on se rapproche du centre de la piste ou si on s'en éloigne après
  227.  
  228. float GPS_distance_ptAA;
  229. float GPS_distance_ptBB;
  230.  
  231. // l'avoir dépassé (lors du décollage)
  232.  
  233. #define sens_AB 0
  234. #define sens_BA 1
  235. uint8_t sens_app_effectif; // effectif pour l'attero (ne concerne pas le décollage)
  236.  
  237. float lat_centre_pst;
  238. float lon_centre_pst;
  239. float longueur_piste;
  240.  
  241. float orient_pisteAB;
  242. float orient_pisteBA;
  243.  
  244. float GPS_azimut_piste;
  245. float GPS_azimut_ptAA;
  246. float GPS_azimut_ptBB;
  247.  
  248.  
  249. char extremite_pst ='X'; // le bout le plus éloigné lors de l'approche, = 'A' ou 'B' sert aussi au décollage (au roulage)
  250. // ce paramètre est calculé en fonction de la position réelle de l'avion lors de la prise de décision
  251.  
  252.  
  253. uint8_t choix_aleatoire;
  254.  
  255.  
  256. int16_t asel1 = 30; // consigne altitude ('niveau de vol' en centaines de pieds) 30 -> 3000ft (ASL)
  257. float climb_rate=0; // taux de montée (négatif pour descendre - sert pour attérissage automatique)
  258.  
  259. float joystick1; // valeur reçue de Flightgear par la liaison USB (lue dans le properties tree de FG)
  260. float trim_elevator;
  261. float elevator; // valeur à envoyer à FG, qui fixera la position de la gouverne de profondeur (val <0 pour monter)
  262. float throttle;
  263.  
  264. int8_t flaps=0; // 0..4
  265. float speedbrake=0; // 0 = rentré, 1 = sorti
  266.  
  267. float rudder=0;
  268. float rudder_manuel; // fonction direste du potentiomètre
  269. //uint8_t flag_eloignement=0; // du centre de la piste, utilisé au décollage par l'auto_rudder
  270. //uint8_t flag_nav_to_piste=0;
  271. //uint8_t flag_autoland=0;
  272.  
  273. uint8_t view_number=0;
  274.  
  275.  
  276. String locks_type; // "ALT" ou "VS"
  277. String AP_status; // "" ou "AP" permet d'engager ou de désengager l'autopilot de FlightGear
  278. bool speed_ctrl;
  279.  
  280. int16_t num_bali=0;
  281. int16_t memo_num_bali=0;
  282.  
  283. uint8_t flag_SDcardOk=0;
  284. uint32_t data_ok=0; // ce n'est pas un flag
  285. //uint8_t gs_ok=0;
  286. uint8_t QNH_ok=0;
  287.  
  288. uint8_t flag_1er_passage =1;
  289. uint8_t attente_data=1;
  290.  
  291.  
  292. int16_t loc=0; // localizer
  293. int16_t memo_loc=0;
  294.  
  295. //uint8_t take_off_ok =0; // passe à 1 si altitude atteinte = 3000ft
  296.  
  297.  
  298. float memo_R2;
  299. int16_t memo_y0;
  300.  
  301. uint16_t memo_x_avion=0; // pour fonction "affi_approche()"
  302. uint16_t memo_y_avion=0;
  303.  
  304. const int bouton1 = 36; // attention: le GPIO 36 n'a pas de R de pullup interne, il faut en câbler une (10k) au +3V3
  305. bool bouton1_etat;
  306. bool memo_bouton1_etat;
  307.  
  308. const int bouton2 = 39; // attention: le GPIO 39 n'a pas de R de pullup interne, il faut en câbler une (10k) au +3V3
  309. bool bouton2_etat;
  310. bool memo_bouton2_etat;
  311.  
  312. String switches; // boutons connectés au 3eme ESP32 (SW), reçus par WiFi
  313. uint16_t v_switches=0;
  314. uint16_t memo_v_switches=0;
  315.  
  316. String switches_ND; // boutons connectés au 2eme ESP32 (ND), reçus par WiFi
  317. uint16_t v_switches_ND=0;
  318. uint16_t memo_v_switches_ND=0;
  319.  
  320. String bt_MCDU; // boutons connectés au 4eme ESP32 (MCDU), reçus par WiFi
  321. uint16_t v_bt_MCDU=0;
  322. uint16_t memo_v_bt_MCDU=0;
  323.  
  324. uint8_t options_route=0;
  325.  
  326. String msg_to_send = "null";
  327.  
  328.  
  329. String potar1;
  330. int16_t v_potar1=0; // peut être négatif
  331.  
  332. // deux encodeurs rotatifs pas à pas
  333. const int rot1a = 32; // GPIO32 -> câbler une R au +3V3
  334. const int rot1b = 33; // GPIO33 -> câbler une R au +3V3
  335.  
  336. const int rot2a = 35; // GPIO35 -> câbler une R au +3V3
  337. const int rot2b = 34; // GPIO34 -> câbler une R au +3V3
  338.  
  339.  
  340. //const int led1 = 25; // GPIO15
  341.  
  342.  
  343. #define TEMPO 5 // tempo anti-rebond pour l'acquisition des encodeurs rotatifs
  344. volatile uint32_t timer1 = 0;
  345. volatile uint32_t timer2 = 0;
  346.  
  347. uint16_t compteur1;
  348.  
  349. uint8_t heures=0;
  350. uint8_t minutes=0;
  351. uint8_t secondes=0;
  352.  
  353. float v_test1=-1.0;
  354.  
  355. // TFT480.setTextColor(TFT_BLACK, TFT_WHITE);
  356. // TFT480.drawLine(x0, y0, x1, y1, TFT_BLACK);
  357. // TFT480.fillTriangle(x0, y0, x1, y1, x2, y2, TFT_GREEN);
  358. // TFT480.drawRect(5, 3, 230, 119, TFT_BLACK);
  359. // TFT480.fillRect(5, 3, 230, 119, TFT_WHITE);
  360.  
  361.  
  362.  
  363.  
  364. void RAZ_variables()
  365. {
  366. roulis=0;
  367. tangage=0;
  368. altitude_GPS=0;
  369. gnd_elv=0;
  370. vitesse=0;
  371. vspeed=0;
  372. cap=0;
  373. memo_hdg1=0;
  374.  
  375. ////ils_loc=0;
  376. ////ils_glide=0;
  377.  
  378. loc=0;
  379. memo_loc=0;
  380.  
  381.  
  382. }
  383.  
  384.  
  385.  
  386. /** ***********************************************************************************
  387. IMAGE.bmp
  388. ***************************************************************************************/
  389.  
  390. /**
  391. Rappel et décryptage de la fonction Color_To_565 : (elle se trouve dans le fichier LCDWIKI_KBV.cpp)
  392.  
  393. //Pass 8-bit (each) R,G,B, get back 16-bit packed color
  394.  
  395. uint16_t Color_To_565(uint8_t r, uint8_t g, uint8_t b)
  396. {
  397. return ((r & 0xF8) << 8) | ((g & 0xFC) << 3) | ((b & 0xF8) >> 3);
  398. }
  399.  
  400. 0xF8 = 11111000
  401. 0xFC = 11111100
  402.  
  403. (r & 0xF8) -> 5 bit de gauche de r (on ignore donc les 3 bits de poids faible)
  404. (g & 0xFC) -> 6 bit de gauche de g (on ignore donc les 2 bits de poids faible)
  405. (b & 0xF8) -> 5 bit de gauche de b (on ignore donc les 3 bits de poids faible)
  406.  
  407. rrrrr---
  408. gggggg--
  409. bbbbb---
  410.  
  411. après les décallages on obtient les 16 bits suivants:
  412.  
  413. rrrrr---========
  414.   gggggg--===
  415.   ===bbbbb
  416.  
  417. soit après le ou :
  418.  
  419. rrrrrggggggbbbbb
  420.  
  421. calcul de la Fonction inverse :
  422. RGB565_to_888
  423. **/
  424.  
  425.  
  426.  
  427. void RGB565_to_888(uint16_t color565, uint8_t *R, uint8_t *G, uint8_t *B)
  428. {
  429. *R=(color565 & 0xFFFFF800) >> 8;
  430. *G=(color565 & 0x7E0) >> 3;
  431. *B=(color565 & 0x1F) << 3 ;
  432. }
  433.  
  434.  
  435.  
  436. /** -----------------------------------------------------------------------------------
  437. CAPTURE D'ECRAN vers SDcard
  438. /** ----------------------------------------------------------------------------------- */
  439.  
  440. void write_TFT_on_SDcard() // enregistre le fichier .bmp
  441. {
  442.  
  443. //TFT480.setTextColor(VERT, NOIR);
  444. //TFT480.drawString("CP", 450, 300);
  445.  
  446. if (flag_SDcardOk==0) {return;}
  447.  
  448. String s1;
  449. uint16_t ys=200;
  450. TFT480.setFreeFont(FF1);
  451. TFT480.setTextColor(JAUNE, NOIR);
  452.  
  453. uint16_t x, y;
  454. uint16_t color565;
  455. uint16_t bmp_color;
  456. uint8_t R, G, B;
  457.  
  458. if( ! SD.exists("/bmp/capture2.bmp"))
  459. {
  460. TFT480.fillRect(0, 0, 480, 320, NOIR); // efface
  461. TFT480.setTextColor(ROUGE, NOIR);
  462. TFT480.drawString("NO /bmp/capture2.bmp !", 100, ys);
  463. delay(300);
  464. TFT480.fillRect(100, ys, 220, 20, NOIR); // efface
  465. return;
  466. }
  467.  
  468.  
  469. File File1 = SD.open("/bmp/capture2.bmp", FILE_WRITE); // ouverture du fichier binaire (vierge) en écriture
  470. if (File1)
  471. {
  472. /*
  473. Les images en couleurs réelles BMP888 utilisent 24 bits par pixel:
  474. Il faut 3 octets pour coder chaque pixel, en respectant l'ordre de l'alternance bleu, vert et rouge.
  475. */
  476. uint16_t bmp_offset = 138;
  477. File1.seek(bmp_offset);
  478.  
  479.  
  480. TFT480.setTextColor(VERT, NOIR);;
  481.  
  482. for (y=320; y>0; y--)
  483. {
  484. for (x=0; x<480; x++)
  485. {
  486. color565=TFT480.readPixel(x, y);
  487.  
  488. RGB565_to_888(color565, &R, &G, &B);
  489.  
  490. File1.write(B); //G
  491. File1.write(G); //R
  492. File1.write(R); //B
  493. }
  494.  
  495. s1=(String) (y/10);
  496. TFT480.fillRect(450, 300, 20, 20, NOIR);
  497. TFT480.drawString(s1, 450, 300);// affi compte à rebour
  498. }
  499.  
  500. File1.close(); // referme le fichier
  501.  
  502. TFT480.fillRect(450, 300, 20, 20, NOIR); // efface le compte à rebour
  503. }
  504. }
  505.  
  506. /** ----------------------------------------------------------------------------------- */
  507.  
  508.  
  509.  
  510.  
  511. void Draw_arc_elliptique(uint16_t x0, uint16_t y0, int16_t dx, int16_t dy, float alpha1, float alpha2, uint16_t couleur)
  512. // alpha1 et alpha2 en radians
  513. {
  514. /*
  515. REMARQUES :
  516. -cette fonction permet également de dessiner un arc de cercle (si dx=dy), voire le cercle complet
  517. - dx et dy sont du type int (et pas uint) et peuvent êtres négafifs, ou nuls.
  518. -alpha1 et alpha2 sont les angles (en radians) des caps des extrémités de l'arc
  519. */
  520. uint16_t n;
  521. float i;
  522. float x,y;
  523.  
  524. i=alpha1;
  525. while(i<alpha2)
  526. {
  527. x=x0+dx*cos(i);
  528. y=y0+dy*cos(i+M_PI/2.0);
  529. TFT480.drawPixel(x,y, couleur);
  530. i+=0.01; // radians
  531. }
  532. }
  533.  
  534.  
  535. void affi_rayon1(uint16_t x0, uint16_t y0, uint16_t rayon, double angle, float pourcent, uint16_t couleur_i, bool gras)
  536. {
  537. // trace une portion de rayon de cercle depuis 100%...à pourcent du rayon du cercle
  538. // angle en radians - sens trigo
  539. float x1, x2;
  540. float y1, y2;
  541.  
  542. x1=x0+rayon* cos(angle);
  543. y1=y0-rayon* sin(angle);
  544.  
  545. x2=x0+pourcent*rayon* cos(angle);
  546. y2=y0-pourcent*rayon* sin(angle);
  547.  
  548. TFT480.drawLine(x1, y1, x2, y2, couleur_i);
  549. if (gras)
  550. {
  551. TFT480.drawLine(x1, y1-1, x2, y2-1, couleur_i);
  552. TFT480.drawLine(x1, y1+1, x2, y2+1, couleur_i);
  553. }
  554. }
  555.  
  556.  
  557.  
  558. void affi_rayon2(uint16_t x0, uint16_t y0, float r1, float r2, float angle_i, uint16_t couleur_i, bool gras)
  559. {
  560. // trace une portion de rayon de cercle entre les distances r1 et r2 du centre
  561. // angle_i en degrés décimaux - sens trigo
  562.  
  563. float angle =angle_i/57.3; // (57.3 ~ 180/pi)
  564. int16_t x1, x2;
  565. int16_t y1, y2;
  566.  
  567. x1=x0+int16_t(r1* cos(angle));
  568. y1=y0-int16_t(r1* sin(angle));
  569.  
  570. x2=x0+int16_t(r2* cos(angle));
  571. y2=y0-int16_t(r2* sin(angle));
  572.  
  573. if ((x1>0) && (x2>0) && (y1>0) && (y2>0) && (x1<480) && (x2<480) && (y1<320) && (y2<320) )
  574. {
  575. TFT480.drawLine(x1, y1, x2, y2, couleur_i);
  576.  
  577. if (gras)
  578. {
  579. TFT480.drawLine(x1, y1-1, x2, y2-1, couleur_i);
  580. TFT480.drawLine(x1, y1+1, x2, y2+1, couleur_i);
  581. }
  582. }
  583.  
  584. //TFT480.fillCircle(x2, y2, 2, ROUGE);
  585. }
  586.  
  587.  
  588.  
  589.  
  590. void affi_tiret_H(uint16_t x0, uint16_t y0, uint16_t r, double angle_i, uint16_t couleur_i)
  591. {
  592. // trace un tiret perpendiculaire à un rayon de cercle de rayon r
  593. // angle_i en degrés décimaux
  594.  
  595. float angle =angle_i/57.3; // (57.3 ~ 180/pi)
  596. float x1, x2;
  597. float y1, y2;
  598.  
  599. x1=x0+(r)* cos(angle-1);
  600. y1=y0-(r)* sin(angle-1);
  601.  
  602. x2=x0+(r)* cos(angle+1);
  603. y2=y0-(r)* sin(angle+1);
  604.  
  605. TFT480.drawLine(x1, y1, x2, y2, couleur_i);
  606. }
  607.  
  608.  
  609.  
  610. void affi_pointe(uint16_t x0, uint16_t y0, uint16_t r, double angle_i, float taille, uint16_t couleur_i)
  611. {
  612. // trace une pointe de flèche sur un cercle de rayon r
  613. // angle_i en degrés décimaux - sens trigo
  614.  
  615. float angle =angle_i/57.3; // (57.3 ~ 180/pi)
  616. int16_t x1, x2, x3;
  617. int16_t y1, y2, y3;
  618.  
  619. x1=x0+r* cos(angle); // pointe
  620. y1=y0-r* sin(angle); // pointe
  621.  
  622. x2=x0+(r-7)* cos(angle-taille); // base A
  623. y2=y0-(r-7)* sin(angle-taille); // base A
  624.  
  625. x3=x0+(r-7)* cos(angle+taille); // base B
  626. y3=y0-(r-7)* sin(angle+taille); // base B
  627.  
  628. TFT480.fillTriangle(x1, y1, x2, y2, x3, y3, couleur_i);
  629. }
  630.  
  631.  
  632. void affi_rectangle_incline(uint16_t x0, uint16_t y0, uint16_t r, double angle_i, uint16_t couleur_i)
  633. {
  634. //rectangle inscrit dans le cerce de rayon r
  635. // angle_i en degrés décimaux - sens trigo
  636.  
  637. float angle =angle_i/57.3; // (57.3 ~ 180/pi)
  638. int16_t x1, x2, x3, x4;
  639. int16_t y1, y2, y3, y4;
  640. float d_alpha=0.08; // détermine la largeur du rectangle
  641.  
  642. // point 1
  643. x1=x0+r*cos(angle-d_alpha);
  644. y1=y0+r*sin(angle-d_alpha);
  645. // point 2
  646. x2=x0+r*cos(angle+d_alpha);
  647. y2=y0+r*sin(angle+d_alpha);
  648. // point 3
  649. x3=x0+r*cos(M_PI + angle-d_alpha);
  650. y3=y0+r*sin(M_PI + angle-d_alpha);
  651. // point 4
  652. x4=x0+r*cos(M_PI + angle+d_alpha);
  653. y4=y0+r*sin(M_PI + angle+d_alpha);
  654.  
  655. TFT480.drawLine(x1, y1, x2, y2, couleur_i);
  656. TFT480.drawLine(x2, y2, x3, y3, couleur_i);
  657. TFT480.drawLine(x3, y3, x4, y4, couleur_i);
  658. TFT480.drawLine(x4, y4, x1, y1, couleur_i);
  659.  
  660. }
  661.  
  662.  
  663.  
  664. void affi_indexH(uint16_t x, uint16_t y, int8_t sens, uint16_t couleur)
  665. {
  666. // petite pointe de flèche horizontale
  667. // sens = +1 ou -1 pour orienter la pointe vers la droite ou vers la gauche
  668.  
  669. TFT480.fillTriangle(x, y-4, x, y+4, x+8*sens, y, couleur);
  670. }
  671.  
  672.  
  673.  
  674. void affi_indexV(uint16_t x, uint16_t y, int8_t sens, uint16_t couleur)
  675. {
  676. // petite pointe de flèche verticale
  677. // sens = +1 ou -1 pour orienter la pointe vers le haut ou vers le bas
  678.  
  679. TFT480.fillTriangle(x-4, y, x+4, y, x, y+8*sens, couleur);
  680. }
  681.  
  682.  
  683.  
  684. float degTOrad(float angle)
  685. {
  686. return (angle * M_PI / 180.0);
  687. }
  688.  
  689.  
  690.  
  691. void init_affi_HA()
  692. {
  693. TFT480.fillRect(HA_x0-HA_w, HA_y0-HA_h-1, 2*HA_w, HA_h+1, HA_CIEL);
  694. TFT480.fillRect(HA_x0-HA_w, HA_y0-HA_h + HA_h, 2*HA_w, HA_h, HA_SOL);
  695.  
  696. }
  697.  
  698.  
  699.  
  700.  
  701. void dessine_avion() // sous forme d'équerres horizontales noires entourées de blanc
  702. {
  703. // aile gauche
  704. TFT480.fillRect(HA_x0-102, HA_y0-3, 60, 10, BLANC); //H contour en blanc
  705. TFT480.fillRect(HA_x0-42, HA_y0-3, 10, 19, BLANC); //V
  706.  
  707. TFT480.fillRect(HA_x0-100, HA_y0-1, 60, 5, NOIR); //H
  708. TFT480.fillRect(HA_x0-40, HA_y0-1, 5, 15, NOIR); //V
  709.  
  710.  
  711. // aile droite
  712. TFT480.fillRect(HA_x0+28, HA_y0-3, 64, 10, BLANC); //H contour en blanc
  713. TFT480.fillRect(HA_x0+28, HA_y0-3, 10, 19, BLANC); //V
  714.  
  715. TFT480.fillRect(HA_x0+30, HA_y0-1, 60, 5, NOIR); //H
  716. TFT480.fillRect(HA_x0+30, HA_y0-1, 5, 15, NOIR); //V
  717.  
  718. //carré blanc au centre
  719.  
  720. TFT480.fillRect(HA_x0-4, HA_y0-3, 8, 2, BLANC);
  721. TFT480.fillRect(HA_x0-4, HA_y0-3, 2, 8, BLANC);
  722.  
  723. TFT480.fillRect(HA_x0-4, HA_y0+3, 10, 2, BLANC);
  724. TFT480.fillRect(HA_x0+4, HA_y0-3, 2, 8, BLANC);
  725.  
  726. //affi_dst_NAV();
  727.  
  728. }
  729.  
  730.  
  731.  
  732.  
  733. void affiche_chrono()
  734. {
  735. uint16_t x0=200;
  736. uint16_t y0=0;
  737. TFT480.setFreeFont(FM9);
  738. TFT480.setTextColor(JAUNE);
  739. String s1;
  740. ////if(heures<10){s1+="0";}
  741. ////s1+=String(heures);
  742. ////s1+=":";
  743. if(minutes<10){s1+="0";}
  744. s1+=String(minutes);
  745. s1+=":";
  746. if(secondes<10){s1+="0";}
  747. s1+=String(secondes);
  748. TFT480.fillRect(x0, y0, 55, 15, BLEU); //efface
  749. TFT480.drawString(s1, x0, y0);
  750.  
  751. }
  752.  
  753.  
  754. void inc_chrono()
  755. {
  756. secondes++;
  757. if (secondes>59)
  758. {
  759. secondes=0;
  760. minutes++;
  761. if(minutes>59)
  762. {
  763. minutes=0;
  764. heures++;
  765. if (heures>23)
  766. heures=0;
  767. }
  768. }
  769. }
  770.  
  771.  
  772. void RAZ_chrono()
  773. {
  774. heures=0;
  775. minutes=0;
  776. secondes=0;
  777. }
  778.  
  779.  
  780.  
  781. void lign_sep(uint16_t Ax, uint16_t Ay, uint16_t Bx, uint16_t By)
  782. {
  783. // actualise la ligne de séparation ciel-sol
  784.  
  785. TFT480.drawLine(Ax, Ay-1, Bx, By-1, HA_CIEL);
  786. TFT480.drawLine(Ax, Ay, Bx, By, BLANC);
  787. TFT480.drawLine(Ax, Ay+1, Bx, By+1, HA_SOL);
  788. }
  789.  
  790.  
  791.  
  792. void arrondissement_coins()
  793. {
  794.  
  795. // fillTriangle(int32_t x1,int32_t y1, int32_t x2,int32_t y2, int32_t x3,int32_t y3, uint32_t color);
  796.  
  797. //HG
  798. TFT480.fillTriangle(
  799. HA_x0-HA_w, HA_y0-HA_h-1,
  800. HA_x0-HA_w, HA_y0-HA_h+20,
  801. HA_x0-HA_w+20, HA_y0-HA_h-1,
  802. NOIR);
  803.  
  804.  
  805. //----------------------------------------------
  806. //HD
  807. TFT480.fillTriangle(
  808. HA_x0+HA_w, HA_y0-HA_h-1,
  809. HA_x0+HA_w, HA_y0-HA_h+20,
  810. HA_x0+HA_w-20, HA_y0-HA_h-1,
  811. NOIR);
  812.  
  813.  
  814.  
  815. //----------------------------------------------
  816. //BG
  817. TFT480.fillTriangle(
  818. HA_x0-HA_w, HA_y0+HA_h+1,
  819. HA_x0-HA_w, HA_y0+HA_h-20,
  820. HA_x0-HA_w+20, HA_y0+HA_h+1,
  821. NOIR);
  822.  
  823. //----------------------------------------------
  824. //BD
  825. TFT480.fillTriangle(
  826. HA_x0+HA_w, HA_y0+HA_h+1,
  827. HA_x0+HA_w, HA_y0+HA_h-20,
  828. HA_x0+HA_w-20, HA_y0+HA_h+1,
  829. NOIR);
  830.  
  831. }
  832.  
  833.  
  834.  
  835.  
  836.  
  837. void affi_HA() // Horizon Artificiel
  838. {
  839. String s1;
  840.  
  841. ////String s1=(String) roulis;
  842. ////TFT480.drawString(s1, 400, 20);
  843.  
  844.  
  845. // pivot
  846. int16_t x0=0;
  847. int16_t y0=0;
  848.  
  849. //points d'intersection avec le bord du carré
  850. int16_t Ax, Ay; // sur le bord gauche
  851. int16_t Bx, By; // sur le bord droit
  852. // Le dessin consistera à tracer des segments colorés entre les points A et B
  853.  
  854.  
  855. // roulis -> [-90..+90]
  856.  
  857. // normalisation de la valeur R2 -> toujours >0
  858. float R2 = -1*roulis;
  859. if (R2<0) {R2+=360;} // ce qui est un angle identique, de valeur positive (sens trigo)
  860.  
  861. // le pivot reste centré horizontalement mais se déplace verticalement en fonction du tangage
  862. y0 += 2*tangage;
  863.  
  864. //calcul & memorisation de ces deux facteurs, ce qui évitera 2 calculs de tangente à chaque passage dan la fonction
  865. float tgt_moins = tan(degTOrad(90-R2));
  866. float tgt_plus = tan(degTOrad(90+R2));
  867.  
  868. //-----------------------------------------------------------------------------
  869. // CALCUL COTE DROIT (point B)
  870.  
  871. // calcul du point B d'intersection
  872. Bx=HA_w;
  873. By=y0 + HA_w*tan(degTOrad(R2));
  874.  
  875. //test si le point d'intersection se trouve plus haut que le haut du carré :
  876.  
  877. if(By>HA_h)
  878. {
  879. By=HA_h;
  880. Bx = x0 + (HA_h-y0)*tgt_moins;
  881. }
  882.  
  883. if(By< -HA_h)
  884. {
  885. By= -HA_h;
  886. Bx = x0 + (HA_h+y0)*tgt_plus;
  887. }
  888. //-----------------------------------------------------------------------------
  889. // CALCUL COTE GAUCHE (point A)
  890.  
  891. Ax=-HA_w;
  892. Ay=y0 - HA_w*tan(degTOrad(R2));
  893.  
  894. if(Ay> HA_h)
  895. {
  896. Ay= HA_h;
  897. Ax = x0 + (HA_h-y0)*tgt_moins;
  898. }
  899.  
  900. if(Ay< -HA_h)
  901. {
  902. Ay= -HA_h;
  903. Ax = x0 + (HA_h+y0)*tgt_plus;
  904. }
  905.  
  906.  
  907. //-----------------------------------------------------------------------------
  908. // positionnement de l'ensemble sur l'écran
  909.  
  910. Ax += HA_x0;
  911. Ay += HA_y0;
  912.  
  913. Bx += HA_x0;
  914. By += HA_y0;
  915.  
  916. // pour éviter un tracé hors cadre au premier passage :
  917. if (flag_1er_passage == 1)
  918. {
  919. Ax_actu = Ax;
  920. Ay_actu = Ay;
  921.  
  922. Bx_actu = Bx;
  923. By_actu = By;
  924. flag_1er_passage=0;
  925. }
  926.  
  927.  
  928. //-----------------------------------------------------------------------------
  929. // ligne "verticale" d'inclinaison (tangage)
  930.  
  931. affi_rayon2(HA_x0, HA_y0, 85, -memo_y0, 90-memo_R2, HA_CIEL, false); // efface partie supérieure
  932. affi_rayon2(HA_x0, HA_y0, 85, -y0, 90-R2, BLANC, false); // retrace ligne partie supérieure
  933.  
  934. affi_rayon2(HA_x0, HA_y0, -85,-memo_y0, 90-memo_R2, HA_SOL, false); // efface partie inférieure
  935. affi_rayon2(HA_x0, HA_y0, -85,-y0, 90-R2, VERT, false); // retrace ligne partie inférieure
  936.  
  937. affi_pointe(HA_x0, HA_y0, 85, 90-memo_R2, 0.1, HA_CIEL); // efface
  938. affi_pointe(HA_x0, HA_y0, 85, 90-R2, 0.1, BLANC); // retrace
  939.  
  940.  
  941. //-----------------------------------------------------------------------------
  942. // graduation fixe
  943. TFT480.setFreeFont(FF1);
  944. TFT480.setTextColor(BLANC, GRIS_AF);
  945. TFT480.drawString("30", HA_x0-70, HA_y0-98);
  946. TFT480.drawString("60", HA_x0-120, HA_y0-55);
  947.  
  948. TFT480.drawString("30", HA_x0+60, HA_y0-98);
  949. TFT480.drawString("60", HA_x0+100, HA_y0-55);
  950.  
  951. //-----------------------------------------------------------------------------
  952. // animation de la ligne de séparation horizontale
  953.  
  954. while ((Bx_actu != Bx) || (By_actu != By) || (Ax_actu != Ax) || (Ay_actu != Ay))
  955. {
  956. // déplacements successifs de 1 pixel de chaque extrémités de la ligne
  957.  
  958. //TFT480.drawLine(Bx, By, x2, y2, BLANC);
  959.  
  960. if (Bx_actu < Bx) { Bx_actu++; lign_sep(Ax_actu, Ay_actu, Bx_actu, By_actu); }
  961. if (Bx_actu > Bx) { Bx_actu--; lign_sep(Ax_actu, Ay_actu, Bx_actu, By_actu); }
  962.  
  963. if (Ax_actu < Ax) { Ax_actu++; lign_sep(Ax_actu, Ay_actu, Bx_actu, By_actu); }
  964. if (Ax_actu > Ax) { Ax_actu--; lign_sep(Ax_actu, Ay_actu, Bx_actu, By_actu); }
  965.  
  966. if (By_actu < By) { By_actu++; lign_sep(Ax_actu, Ay_actu, Bx_actu, By_actu); }
  967. if (By_actu > By) { By_actu--; lign_sep(Ax_actu, Ay_actu, Bx_actu, By_actu); }
  968.  
  969. if (Ay_actu < Ay) { Ay_actu++; lign_sep(Ax_actu, Ay_actu, Bx_actu, By_actu); }
  970. if (Ay_actu > Ay) { Ay_actu--; lign_sep(Ax_actu, Ay_actu, Bx_actu, By_actu); }
  971.  
  972. }
  973.  
  974.  
  975. // graduation roulis qui se déplace angulairement avec la ligne de tangage
  976. for (int8_t n=0; n<4; n++)
  977. {
  978. 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
  979. Draw_arc_elliptique(HA_x0, HA_y0, 20*n, 20*n, degTOrad(80-R2+n), degTOrad(100-R2-n), BLANC); // trace bas
  980.  
  981. 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
  982. Draw_arc_elliptique(HA_x0, HA_y0, 20*n, 20*n, degTOrad(260-R2+n), degTOrad(280-R2-n), BLANC); // trace haut
  983. }
  984.  
  985. memo_R2 = R2;
  986. memo_y0 = y0;
  987.  
  988.  
  989.  
  990.  
  991. //-----------------------------------------------------------------------------
  992. arrondissement_coins();
  993.  
  994. if (read_bit(flags, bit_autoland) == 0)
  995. {
  996. affi_distance_piste();
  997. }
  998.  
  999. }
  1000.  
  1001.  
  1002.  
  1003. void affi_acceleration()
  1004. {
  1005. // POUR TEST **********
  1006. ////String s2= (String) acceleration;
  1007. ////TFT480.fillRect(100, 50, 200, 20, TFT_BLACK);
  1008. ////TFT480.setFreeFont(FF5);
  1009. ////TFT480.setTextColor(BLANC, NOIR);
  1010. ////TFT480.drawString("Acceleration=", 100, 50);
  1011. ////TFT480.drawString(s2, 250, 50);
  1012. // ********************
  1013.  
  1014. //barres verticales colorées juste à droite de la vitesse indiquant sa variation
  1015. uint16_t x0=60;
  1016. uint16_t Y_zero=162;
  1017.  
  1018. int16_t dy=0;
  1019.  
  1020. //"fleche" haute
  1021. TFT480.fillRect(x0, 40, 8, Y_zero, GRIS_TRES_FONCE); // efface haut
  1022. if (acceleration > 1)
  1023. {
  1024. dy= acceleration;
  1025.  
  1026. TFT480.fillRect(x0, Y_zero-dy, 8, dy, VERT); // fleche
  1027. }
  1028.  
  1029.  
  1030. //"fleche" basse
  1031. TFT480.fillRect(x0, Y_zero, 8, 150, GRIS_TRES_FONCE); // efface bas
  1032. if (acceleration < -1)
  1033. {
  1034. dy= -acceleration;
  1035.  
  1036. TFT480.fillRect(x0, Y_zero, 8, dy, JAUNE); // fleche
  1037. }
  1038.  
  1039. TFT480.fillRect(x0, Y_zero, 10, 2, BLANC); // tiret horizontal blanc
  1040.  
  1041. TFT480.fillRect(x0, 310, 8, 20, NOIR);
  1042.  
  1043. }
  1044.  
  1045.  
  1046. void bride(int16_t *valeur)
  1047. {
  1048. int16_t y_min =40;
  1049. int16_t y_max =310;
  1050. if (*valeur<y_min) {*valeur=y_min;}
  1051. if (*valeur>y_max) {*valeur=y_max;}
  1052. }
  1053.  
  1054.  
  1055. void affi_switches() // en haut à droite
  1056. {
  1057. TFT480.setTextFont(1);
  1058. TFT480.setTextColor(GRIS);
  1059.  
  1060. TFT480.fillRect(430, 0, 25, 10, NOIR); // efface le nombre précédemment affiché
  1061. TFT480.drawString(switches, 430, 0);
  1062.  
  1063. TFT480.fillRect(430, 10, 25, 10, NOIR); // efface le nombre précédemment affiché
  1064. TFT480.drawString(switches_ND, 430, 10);
  1065.  
  1066.  
  1067. }
  1068.  
  1069.  
  1070.  
  1071. void affi_elevator()
  1072. {
  1073. bargraph_V_float(elevator, 340, 130, JAUNE);
  1074. }
  1075.  
  1076.  
  1077.  
  1078. void affi_rudder()
  1079. {
  1080. TFT480.setTextFont(1);
  1081. TFT480.fillRect(430, 20, 25, 8, NOIR); // efface le nombre précédemment affiché
  1082. TFT480.setTextColor(ORANGE);
  1083. TFT480.drawString(potar1, 430, 20); // nombre orange en haut à droite
  1084.  
  1085. float v1 = rudder;
  1086. bargraph_H_float(v1, 210, 235, JAUNE); // barre horizontale sous l'horizon artificiel
  1087.  
  1088. //throttle = v1; // POUR TEST !!! (OK)
  1089. }
  1090.  
  1091.  
  1092. void affi_flags() // nombre jaune en haut à droite
  1093. {
  1094. TFT480.fillRect(430, 30, 25, 8, NOIR); // efface le nombre précédemment affiché
  1095. TFT480.setTextFont(1);
  1096. TFT480.setTextColor(JAUNE);
  1097. String s1 = String(flags);
  1098. TFT480.drawString(s1, 430, 30);
  1099.  
  1100. }
  1101.  
  1102.  
  1103. void affi_etats_bt_MCDU() // nombre vert en haut à droite
  1104. {
  1105. TFT480.fillRect(430, 40, 25, 8, NOIR); // efface le nombre précédemment affiché
  1106. TFT480.setTextFont(1);
  1107. TFT480.setTextColor(VERT);
  1108. String s1 = String(v_bt_MCDU);
  1109. TFT480.drawString(s1, 430, 38);
  1110. }
  1111.  
  1112.  
  1113. void affi_extremite() // en haut à droite
  1114. {
  1115. TFT480.fillRect(430, 50, 25, 6, NOIR); // efface le nombre précédemment affiché
  1116. TFT480.setTextFont(1);
  1117. TFT480.setTextColor(BLEU_CLAIR);
  1118. String s1 = String(extremite_pst); // 'A' ou 'B' (la plus éloignée de l'avion)
  1119. TFT480.drawString(s1, 430, 45);
  1120. }
  1121.  
  1122.  
  1123. void affi_sens_APP() // en haut à droite
  1124. {
  1125. TFT480.fillRect(445, 50, 35, 6, NOIR); // efface le nombre précédemment affiché
  1126. TFT480.setTextFont(1);
  1127. TFT480.setTextColor(VERT);
  1128. String s1;
  1129. if (sens_app_effectif == sens_AB) {s1 = "A->B";} else {s1 = "B->A";}
  1130. TFT480.drawString(s1, 445, 48);
  1131. }
  1132.  
  1133.  
  1134. void affi_vitesse()
  1135. {
  1136. uint16_t x1;
  1137. String s1;
  1138.  
  1139. int16_t y_min =40;
  1140. int16_t y_max =300;
  1141.  
  1142. TFT480.setTextColor(BLANC); // Background is not defined so it is transparent
  1143.  
  1144. //---------------------------------------------------------------------------------------
  1145. //bande verticale multicolore
  1146.  
  1147. #define vitesse_sol 40
  1148. int16_t vitesse_mini1 =90;
  1149. int16_t vitesse_mini2 =130;
  1150. int16_t vitesse_maxi1 =200;
  1151. int16_t vitesse_maxi2 =280;
  1152.  
  1153.  
  1154.  
  1155. //calcul de la position des limites entre les différentes couleurs verticales
  1156.  
  1157. int16_t d1, d2, d3, d4, d5;
  1158.  
  1159. d1=(int16_t)(100 + 3.2*((vitesse - vitesse_sol)));
  1160. d2=(int16_t)(100 + 3.2*((vitesse - vitesse_mini1)));
  1161. d3=(int16_t)(100 + 3.2*((vitesse - vitesse_mini2)));
  1162. d4=(int16_t)(100 + 3.2*((vitesse - vitesse_maxi1)));
  1163. d5=(int16_t)(100 + 3.2*((vitesse - vitesse_maxi2)));
  1164.  
  1165. bride(&d1);
  1166. bride(&d2);
  1167. bride(&d3);
  1168. bride(&d4);
  1169. bride(&d5);
  1170.  
  1171. int16_t h1, h2, h3, h4, h5;
  1172.  
  1173. h1 = y_max-(int16_t)d1;
  1174. h2 = d1-d2;
  1175. h3 = d2-d3;
  1176. h4 = d3-d4;
  1177. h5 = d4-d5;
  1178.  
  1179. TFT480.fillRect(50, 40, 6, (int16_t)d5, ORANGE);
  1180. TFT480.fillRect(50, d5, 6, h5, JAUNE);
  1181. TFT480.fillRect(50, d4, 6, h4, VERT);
  1182. TFT480.fillRect(50, d3, 6, h3, ORANGE);
  1183. TFT480.fillRect(50, d2, 6, h2, ROUGE);
  1184. TFT480.fillRect(50, d1, 6, 300-(int16_t)d1, GRIS);
  1185.  
  1186. TFT480.fillRect(50, 300, 6, 20, NOIR);
  1187.  
  1188. //---------------------------------------------------------------------------------------
  1189. //échelle verticale graduée glissante
  1190.  
  1191. uint16_t y0;
  1192.  
  1193. int16_t vit1;
  1194. float d6;
  1195.  
  1196. TFT480.setFreeFont(FF1);
  1197.  
  1198. y0=3.2*(vitesse%10);
  1199.  
  1200. TFT480.fillRect(0, y_min, 50, y_max-30, GRIS_AF); // bande verticale à gauche
  1201. for(int n=0; n<10; n++)
  1202. {
  1203. d6 =2+y0+32.0*n; // 24 pixels verticalement entre chaque trait -> 10*24 = 240px (hauteur de l'affiur)
  1204. {
  1205. if ( (d6>y_min) && (d6<y_max-10) && (vit1>=0) && (vit1<1000) )
  1206. {
  1207. TFT480.fillRect(45, (int16_t)d6, 10, 2, BLANC); // petits tirets horizontaux
  1208. }
  1209.  
  1210. vit1 = vitesse -10*(n-5);
  1211. vit1 /= 10;
  1212. vit1 *= 10;
  1213. s1=(String) vit1;
  1214.  
  1215. if ( (d6>y_min) && (d6<y_max-10) && (vit1>=0) && (vit1<1000) )
  1216. {
  1217. TFT480.setTextColor(BLANC, GRIS_AF);
  1218. //TFT480.drawString(" ", 9, d6);
  1219. x1=0;
  1220. if(vit1<100){x1=7;} // pour affichage centré
  1221. if(vit1<10){x1=14;}
  1222. if (vit1>=10)
  1223. {
  1224. TFT480.drawString(s1, x1, (uint16_t)d6-5); // Graduation (tous les 20kts)
  1225. }
  1226. }
  1227. }
  1228. }
  1229. TFT480.fillRect(0, 38, 68, 2, NOIR); // efface ; BLEU pour test
  1230.  
  1231. //---------------------------------------------------------------------------------------
  1232. // affichage de la valeur principale
  1233.  
  1234. uint16_t VP_y0 = 150;
  1235.  
  1236. TFT480.setTextColor(BLANC, NOIR);
  1237. TFT480.setFreeFont(FF18);
  1238. s1=(String)vitesse;
  1239.  
  1240. TFT480.fillRect(3, VP_y0, 42, 26, NOIR); //efface le nombre précédemment affiché (pour le cas où on passe de 3 à 2 chiffres)
  1241.  
  1242. if ((vitesse>=0) && (vitesse <1000))
  1243. {
  1244. x1=3;
  1245. if(vitesse<100){x1=10;} // pour affichage centré
  1246. if(vitesse<10){x1=20;}
  1247. TFT480.drawString(s1, x1, VP_y0+3); // affi le nombre
  1248. } // affi en gros à mi-hauteur de l'écran
  1249. else
  1250. { TFT480.fillRect(3, VP_y0, 42, 26, GRIS); }
  1251.  
  1252. TFT480.drawRoundRect(1, VP_y0-1, 45, 28, 5, BLANC); // encadrement de la valeur centrale affichée
  1253.  
  1254. TFT480.fillTriangle(45, VP_y0+7, 45, VP_y0+17, 55, VP_y0+12, NOIR); // petit triangle (curseur) noir
  1255. }
  1256.  
  1257.  
  1258.  
  1259. void affi_asel(int16_t asel_i)
  1260. {
  1261. // consigne ALTITUDE de l'autopilot
  1262. uint16_t x1 =360;
  1263. TFT480.setFreeFont(FF5);
  1264.  
  1265. if(asel_i >=0)
  1266. {
  1267. // ( chiffres en roses en haut à droite)
  1268. String s2 =(String)(asel_i);
  1269. TFT480.setTextColor(ROSE, NOIR);
  1270.  
  1271. TFT480.fillRect(x1, 0, 77, 20, NOIR); // efface
  1272. if(asel_i<10000){x1+=7;}
  1273. if(asel_i<1000){x1+=7;} // pour affichage centré
  1274. if(asel_i<100){x1+=7;}
  1275. if(asel_i<10){x1+=7;}
  1276.  
  1277. TFT480.drawString(s2, x1, 5);
  1278. }
  1279.  
  1280. }
  1281.  
  1282.  
  1283. void affi_target_speed()
  1284. {
  1285. // consigne de vitesse de l'autopilot
  1286. // ( chiffres en rose en haut à gauche )
  1287.  
  1288. String s2 =(String)(target_speed);
  1289. TFT480.setTextColor(ROSE, NOIR);
  1290. TFT480.setFreeFont(FF5);
  1291. uint8_t x1=7;
  1292. TFT480.fillRect(x1, 20, 60, 15, NOIR); // efface
  1293. TFT480.drawString(s2, x1, 20);
  1294. }
  1295.  
  1296.  
  1297.  
  1298.  
  1299. void affi_vt_verticale()
  1300. {
  1301. // affichage analogique sur la droite de l'écran
  1302.  
  1303. uint16_t x0=435;
  1304. uint16_t y0=165;
  1305.  
  1306. float y1;
  1307.  
  1308. uint16_t x1;
  1309. String s1;
  1310.  
  1311. TFT480.fillRect(x0, y0-90, 45, 180, GRIS_AF); // barre grise
  1312. TFT480.fillRect(x0, y0, 25, 2, BLEU_CLAIR); // centre
  1313.  
  1314. // ------------------------
  1315. // graduations sur un arc vertical
  1316. TFT480.setFreeFont(FF1);
  1317.  
  1318. TFT480.setTextColor(BLANC, NOIR);
  1319. TFT480.drawString("ft/mn", x0-8, y0+125);
  1320.  
  1321.  
  1322. TFT480.setTextColor(BLANC, GRIS_AF);
  1323.  
  1324.  
  1325.  
  1326. float angle;
  1327. for(uint8_t n=0; n<7; n++ )
  1328. {
  1329. angle =135+ n*15; // 1 tiret tous les 15 degrés
  1330. affi_rayon1(HA_x0+340, y0, 110, degTOrad(angle), 0.9, BLANC, false); // tirets de graduation
  1331. }
  1332.  
  1333.  
  1334. TFT480.drawString("3", x0+9, y0-90);
  1335. TFT480.drawString("2", x0-3, y0-65);
  1336. TFT480.drawString("1", x0-8, y0-35);
  1337. TFT480.drawString("0", x0-3, y0-5 + 0);
  1338. TFT480.drawString("1", x0-8, y0+25);
  1339. TFT480.drawString("2", x0-3, y0+50);
  1340. TFT480.drawString("3", x0+9, y0+75);
  1341.  
  1342. // ------------------------
  1343. // aiguille à droite de l'écran
  1344. float angle2;
  1345.  
  1346. TFT480.setFreeFont(FF1);
  1347. s1=(String) (vspeed*60);
  1348.  
  1349. angle2 = 180.0 - vspeed *0.92;
  1350.  
  1351. TFT480.fillRect(x0-10, y0-110, 55, 15, GRIS_TRES_FONCE); // efface haut
  1352. TFT480.fillRect(x0-10, y0+105, 55, 15, GRIS_TRES_FONCE); // efface bas
  1353.  
  1354. if ((vspeed > -50) && (vspeed < 50))
  1355. {
  1356. affi_rayon1(HA_x0+330, y0, 100, degTOrad(angle2), 0.7, JAUNE, true);
  1357.  
  1358. TFT480.setTextColor(JAUNE, NOIR);
  1359. }
  1360. else if (vspeed > 50)
  1361. {
  1362. affi_rayon1(HA_x0+330, y0, 110, degTOrad(132), 0.7, JAUNE, true);
  1363. TFT480.setTextColor(JAUNE, NOIR);
  1364.  
  1365. TFT480.drawString(s1, x0-10, y0-110);
  1366. }
  1367. else if (vspeed < -50)
  1368. {
  1369. affi_rayon1(HA_x0+330, y0, 110, degTOrad(228), 0.7, JAUNE, true);
  1370. TFT480.setTextColor(JAUNE, NOIR);
  1371.  
  1372. TFT480.drawString(s1, x0-10, y0+105);
  1373. }
  1374.  
  1375.  
  1376. // affichage digital de la valeur
  1377.  
  1378.  
  1379. /*
  1380. // = vitesse ascensionnelle, sous forme de barres verticales vertes, à droite, près de l'echelle d'altitude
  1381. uint16_t x0=405;
  1382. uint16_t y0=40;
  1383.  
  1384. int16_t dy=0;
  1385.  
  1386. //fleche haute
  1387. TFT480.fillRect(x0, 0, 10, 140, GRIS_FONCE); // efface haut
  1388. if (vspeed > 1)
  1389. {
  1390. dy= vspeed;
  1391.  
  1392. TFT480.fillRect(x0, y0+100-dy, 10, dy, VERT); // fleche
  1393. }
  1394.  
  1395.  
  1396. //fleche basse
  1397. TFT480.fillRect(x0, y0+150, 10, 135, GRIS_FONCE); // efface bas
  1398. if (vspeed < -1)
  1399. {
  1400. dy= -vspeed;
  1401.  
  1402. TFT480.fillRect(x0, y0+150, 10, dy, VERT); // fleche
  1403. }
  1404. */
  1405.  
  1406. }
  1407.  
  1408.  
  1409.  
  1410.  
  1411. void affi_cap()
  1412. {
  1413. // cercle tournant de CAP gradué en bas au centre de l'écran
  1414. // Les lettres 'N' 'S' 'E' 'O' pour Nord Sud Est Ouset sont initialisées sous forme de sprites dans la fonction setup()
  1415.  
  1416. uint16_t x02 = 200;
  1417. uint16_t y02 = 350;
  1418. float angle; // en radians
  1419. //float cap_RD; // en radians (le cap fourni par FG étant en degrés d'angle)
  1420. uint16_t x_spr;
  1421. uint16_t y_spr;
  1422.  
  1423. uint16_t x_hdg;
  1424. uint16_t y_hdg;
  1425.  
  1426. uint8_t R =70;
  1427. uint8_t R2 =R-6;
  1428. /**
  1429. 360° =2 pi rad
  1430. 1° = 2 pi/360 rad = pi/180 rad
  1431. **/
  1432.  
  1433. TFT480.fillCircle(x02,y02, R, GRIS_AF);
  1434.  
  1435. for(uint8_t n=0; n<24; n++ )
  1436. {
  1437. angle = (int16_t)cap+15 + n*15; // 1 tiret tous les 15 degrés
  1438. affi_rayon1(x02, y02, (R-5), degTOrad(angle), 0.9, BLANC, false); // tirets de graduation
  1439. }
  1440. x_hdg = x02 + R2*cos(degTOrad(hdg1-90-cap));
  1441. y_hdg = y02 + R2*sin(degTOrad(hdg1-90-cap));
  1442.  
  1443. TFT480.drawLine(x02, y02, x_hdg, y_hdg, VERT);
  1444. TFT480.drawCircle(x_hdg, y_hdg, 5, VERT); // rond vert sur le cercle = consigne de cap de l'autopilot
  1445.  
  1446. x_spr = x02+R2 * cos(degTOrad(angle));
  1447. y_spr = y02-R2 * sin(degTOrad(angle));
  1448. TFT480.setPivot(x_spr, y_spr);
  1449. SPR_E.pushRotated(-cap+90, TFT_BLACK); // Plot rotated Sprite, black = transparent
  1450.  
  1451. x_spr = x02+R2* cos(degTOrad(angle+90));
  1452. y_spr = y02-R2 * sin(degTOrad(angle+90));
  1453. TFT480.setPivot(x_spr, y_spr);
  1454. SPR_N.pushRotated(-cap, TFT_BLACK);
  1455.  
  1456. x_spr = x02+R2 * cos(degTOrad(angle+180));
  1457. y_spr = y02-R2 * sin(degTOrad(angle+180));
  1458. TFT480.setPivot(x_spr, y_spr);
  1459. SPR_O.pushRotated(-cap-90, TFT_BLACK);
  1460.  
  1461. x_spr = x02+R2 * cos(degTOrad(angle-90));
  1462. y_spr = y02-R2 * sin(degTOrad(angle-90));
  1463. TFT480.setPivot(x_spr, y_spr);
  1464. SPR_S.pushRotated(-cap, TFT_BLACK);
  1465.  
  1466.  
  1467. // petite "maison" dans le cercle (valeur du cap)
  1468.  
  1469. #define a 170 // x général
  1470. #define b a+30
  1471. #define c b+30
  1472. #define d 288 // y général
  1473. #define e d+10
  1474. #define f e+20
  1475.  
  1476. TFT480.drawLine(a, f, c, f, BLANC); // sol
  1477. TFT480.drawLine(a, f, a, e, BLANC); // mur de gauche
  1478. TFT480.drawLine(c, f, c, e, BLANC); // mur de droite
  1479. TFT480.drawLine(a, e, b, d, BLANC); // toit pente gauche
  1480. TFT480.drawLine(c, e, b, d, BLANC); // toit pente droite
  1481.  
  1482.  
  1483. // affi la valeur
  1484. String s1;
  1485. uint16_t x0 = a+1;
  1486. uint16_t y0 = e;
  1487.  
  1488. uint16_t x1= x0;
  1489. if(cap<100){x1+=5;} // pour affichage centré
  1490. if(cap<10){x1+=5;}
  1491.  
  1492. s1=String (cap, 1);
  1493.  
  1494. TFT480.fillRect(x0, y0, 57, 20, NOIR); // efface le nombre précédemment affiché
  1495. TFT480.setTextColor(BLANC, NOIR);
  1496. TFT480.setFreeFont(FM9);
  1497. TFT480.drawString(s1, x1, y0);
  1498.  
  1499.  
  1500. }
  1501.  
  1502.  
  1503.  
  1504. void affi_hauteur()
  1505. {
  1506. /**
  1507. Pour exprimer une hauteur au dessus de l'aérodrome, il est définie la hauteur AAL (Above Aerodrome Level).Il
  1508. s'agit de la hauteur entre l'avion et le point de référence de l'aérodrome comme s'il était en dessous de la
  1509. position de l'appareil (même s'il n'y est pas). Cette hauteur ne suit pas le relief.
  1510. On la calculera ici en retranchant [l'altitude de l'aéroport sélectionné] à [l'altitude GPS].
  1511.  
  1512. En conséquense, il faut impérativement penser à sélectionner dans le module SD le bon aérodrome, celui d'où l'on décolle,
  1513. puis en cas de voyage, celui où l'on va se poser (se qui renseignera son altitude) sinon l'affichage sera faux.
  1514.  
  1515. par exemple si l'on choisit "Montpellier" en étant à Clermont-Ferrand, l'erreur sera de 1089 ft
  1516.  
  1517. Les altitudes des aérodromes sont enregistées ici dans le fichier FG_data.h
  1518. */
  1519.  
  1520. String s1;
  1521. uint16_t x0 =365;
  1522. //---------------------------------------------------------------------------------------
  1523. //échelle verticale graduée glissante
  1524.  
  1525. uint16_t x1;
  1526. uint16_t y0;
  1527. uint16_t hauteur;
  1528. int16_t alt1;
  1529. float d5;
  1530.  
  1531. if (mode_affi_hauteur == AAL) {hauteur = hauteur_AAL;}
  1532. if (mode_affi_hauteur == ASL) {hauteur = altitude_GPS;}
  1533.  
  1534. TFT480.setFreeFont(FF1);
  1535.  
  1536.  
  1537. y0=3.2*(hauteur_AAL%10);
  1538.  
  1539. TFT480.fillRect(x0, 20, 60, 319, GRIS_AF); //efface bande verticale à droite
  1540.  
  1541.  
  1542. for(int n=0; n<10; n++)
  1543. {
  1544. d5 =0+y0+32.0*n; // pixels verticalement entre chaque trait -> 10*24 = 240px (hauteur de l'affi)
  1545. {
  1546. if (d5>=20) // marge en haut
  1547. {
  1548. TFT480.fillRect(x0, (int16_t)d5+5, 5, 2, BLANC); // petits tirets horizontaux
  1549.  
  1550. alt1 = hauteur -10*(n-5);
  1551. alt1 /= 10;
  1552. alt1 *= 10;
  1553. s1=(String) alt1;
  1554.  
  1555. if(alt1>=0)
  1556. {
  1557. TFT480.setTextColor(BLANC, GRIS_AF);
  1558. //TFT480.drawString(" ", 9, d5);
  1559. x1=x0;
  1560. if(alt1<10000){x1+=7;} // pour affichage centré
  1561. if(alt1<1000){x1+=7;}
  1562. if(alt1<100){x1+=7;}
  1563. if(alt1<10){x1+=7;}
  1564. TFT480.drawString(s1, x1, (uint16_t)d5); // Graduation (tous les 20kts)
  1565. }
  1566. }
  1567. }
  1568. }
  1569.  
  1570.  
  1571. //---------------------------------------------------------------------------------------
  1572. // affichage de la valeur principale
  1573.  
  1574. uint16_t x2;
  1575. uint16_t y0b = 155;
  1576. TFT480.fillRect(x0-20, y0b, 80, 25, NOIR); // efface le nombre précédemment affiché
  1577. TFT480.setTextColor(BLANC, NOIR);
  1578. TFT480.setFreeFont(FF18);
  1579.  
  1580. if ((1) && (hauteur < 60000))
  1581. {
  1582. s1=(String) hauteur;
  1583. }
  1584. else {s1="----";}
  1585. x2=x0-20;
  1586. if(hauteur<10000){x2+=10;} // pour affichage centré
  1587. if(hauteur<1000){x2+=10;}
  1588. if(hauteur<100){x2+=10;}
  1589. if(hauteur<10){x2+=10;}
  1590.  
  1591. if(hauteur<0)
  1592. {
  1593. TFT480.setTextColor(ROUGE);
  1594. x2=x0-20; // si valeur négative affichée avec signe "-"
  1595. }
  1596.  
  1597.  
  1598. TFT480.drawString(s1, x2, y0b);
  1599. uint16_t couleur1=GRIS;
  1600. if (mode_affi_hauteur == ASL) {couleur1=BLEU;}
  1601. if (mode_affi_hauteur == AAL) {couleur1=VERT;}
  1602.  
  1603. TFT480.drawRoundRect(x0-20, y0b-3, 75, 28, 5, couleur1); // encadrement de la valeur centrale affichée
  1604.  
  1605. }
  1606.  
  1607.  
  1608.  
  1609.  
  1610. void affi_distance_piste()
  1611. {
  1612. String s1;
  1613. uint16_t x0=190;
  1614. uint16_t y0=255;
  1615. float nav_nm;
  1616. // rappel: 1 mile marin (NM nautical mile) = 1852m
  1617. //ils_nm = (float)ils_dst / 1852.0;
  1618. //if (ils_nm >99) {ils_nm=0;}
  1619.  
  1620. TFT480.drawRect(x0-47, y0-15, 190, 35, GRIS_FONCE); //encadrement
  1621.  
  1622. TFT480.setTextFont(1);
  1623. TFT480.setTextColor(BLANC, NOIR);
  1624. TFT480.drawString("distance", x0, y0-12);
  1625.  
  1626. TFT480.setFreeFont(FM9);
  1627. TFT480.setTextColor(JAUNE, NOIR);
  1628. TFT480.drawString("RWY", x0-45, y0-12);
  1629.  
  1630. TFT480.setTextColor(BLANC, NOIR);
  1631. uint8_t nb_decimales;
  1632. if(GPS_distance_piste>99) {nb_decimales =0;} else {nb_decimales =1;}
  1633. s1 = String(GPS_distance_piste, nb_decimales);
  1634. if (data_ok == 0) {s1=" --";}
  1635. TFT480.fillRect(x0, y0, 52, 18, NOIR); // efface
  1636. TFT480.setFreeFont(FM9);
  1637. TFT480.drawString(s1, x0, y0);
  1638. TFT480.drawRoundRect(x0, y0-2, 50, 18, 5, GRIS_FONCE); // encadrement de la valeur affichée
  1639.  
  1640. //affi_float_test(GPS_distance_piste_new, 100, 3, VERT, NOIR);
  1641.  
  1642.  
  1643. TFT480.setTextColor(JAUNE, NOIR);
  1644. TFT480.drawString("NM", x0+55, y0);
  1645.  
  1646. //affi_direction_piste // direction de la piste vue de l'avion
  1647. TFT480.setTextFont(1);
  1648. TFT480.setTextColor(BLANC, NOIR);
  1649. TFT480.drawString("direction", x0+80, y0-12);
  1650.  
  1651. TFT480.setTextColor(BLANC, NOIR);
  1652. s1 = String(GPS_azimut_piste, 0); // 0 -> 0 décimales
  1653. if (data_ok == 0) {s1=" --";}
  1654. TFT480.fillRect(x0+90, y0, 52, 18, NOIR); // efface
  1655. TFT480.setFreeFont(FM9);
  1656. TFT480.drawString(s1, x0+90, y0);
  1657. TFT480.drawRoundRect(x0+90, y0-2, 40, 18, 5, GRIS_FONCE); // encadrement de la valeur affichée
  1658.  
  1659. TFT480.drawCircle(x0+135, y0, 2, JAUNE); // caractère 'degré'
  1660.  
  1661. }
  1662.  
  1663.  
  1664.  
  1665. void affi_distance_ptAA()
  1666. {
  1667. String s1;
  1668. uint16_t x0=260;
  1669. uint16_t y0=280;
  1670.  
  1671. TFT480.setTextFont(1);
  1672. TFT480.setTextColor(BLANC, NOIR);
  1673. TFT480.drawString("AA", x0, y0);
  1674.  
  1675. s1 = String(GPS_distance_ptAA, 1);
  1676. TFT480.fillRect(x0, y0+10, 45, 12, NOIR); // efface
  1677. TFT480.setFreeFont(FM9);
  1678. TFT480.setTextColor(VERT, NOIR);
  1679. TFT480.drawString(s1, x0, y0+10);
  1680.  
  1681. TFT480.drawRoundRect(x0-2, y0+8, 52, 18, 5, GRIS_FONCE);
  1682.  
  1683. TFT480.setTextColor(JAUNE, NOIR);
  1684. TFT480.drawString("NM", x0+55, y0+10);
  1685. }
  1686.  
  1687.  
  1688. void affi_distance_ptBB()
  1689. {
  1690. String s1;
  1691. uint16_t x0=260;
  1692. uint16_t y0=280;
  1693.  
  1694. TFT480.setTextFont(1);
  1695. TFT480.setTextColor(BLANC, NOIR);
  1696. TFT480.drawString("BB", x0, y0);
  1697.  
  1698. s1 = String(GPS_distance_ptBB, 1);
  1699. TFT480.fillRect(x0, y0+10, 45, 12, NOIR); // efface
  1700. TFT480.setFreeFont(FM9);
  1701. TFT480.setTextColor(VERT, NOIR);
  1702. TFT480.drawString(s1, x0, y0+10);
  1703.  
  1704. TFT480.drawRoundRect(x0-2, y0+8, 52, 18, 5, GRIS_FONCE);
  1705.  
  1706. TFT480.setTextColor(JAUNE, NOIR);
  1707. TFT480.drawString("NM", x0+55, y0+10);
  1708. }
  1709.  
  1710.  
  1711.  
  1712.  
  1713. ////void affi_indicateurs()
  1714. ////{
  1715.  
  1716. ////TFT480.setFreeFont(FSS9);
  1717.  
  1718.  
  1719. ////}
  1720.  
  1721.  
  1722. void affi_Airport()
  1723. {
  1724. uint16_t n;
  1725. float v1;
  1726. String s1;
  1727.  
  1728.  
  1729. TFT480.fillRect(255, 280, 108, 20, NOIR); // efface - BLEU pour test
  1730. TFT480.setTextFont(1);
  1731.  
  1732. TFT480.setTextColor(BLEU_CLAIR, NOIR);
  1733. s1= liste_bali[num_bali].ID_OACI;
  1734. TFT480.drawString(s1, 255, 280);
  1735.  
  1736. s1= (String)liste_bali[num_bali].altitude;
  1737. s1 +=" ft";
  1738. TFT480.setTextColor(VIOLET2, NOIR);
  1739. TFT480.drawString(s1, 300, 280);
  1740.  
  1741. TFT480.fillRect(270, 300, 60, 30, NOIR); // efface - GRIS pour test
  1742. s1= liste_bali[num_bali].nom;
  1743. TFT480.setTextColor(BLEU_CLAIR, NOIR);
  1744. TFT480.drawString(s1, 255, 290);
  1745.  
  1746. }
  1747.  
  1748.  
  1749. void affi_mode_affi_hauteur()
  1750. {
  1751. if (mode_affi_hauteur == AAL)
  1752. {
  1753. TFT480.setFreeFont(FF1);
  1754. TFT480.setTextColor(VERT, GRIS_AF); // Autolanding en cours, ok
  1755. TFT480.drawString("AAL", 290, 0);
  1756. }
  1757. if (mode_affi_hauteur == ASL)
  1758. {
  1759. TFT480.setFreeFont(FF1);
  1760. TFT480.setTextColor(BLEU_CLAIR, GRIS_AF); // Autolanding en cours, ok
  1761. TFT480.drawString("ASL", 290, 0);
  1762. }
  1763. }
  1764.  
  1765.  
  1766. void calcul_ptA_ptB() // situé à 12NM de la piste
  1767. {
  1768. float lat_A = liste_bali[num_bali].lat_A; // extrémité de la piste
  1769. float lon_A = liste_bali[num_bali].lon_A; // extrémité de la piste
  1770.  
  1771. float lat_B = liste_bali[num_bali].lat_B; // extrémité de la piste
  1772. float lon_B = liste_bali[num_bali].lon_B; // extrémité de la piste
  1773.  
  1774. float d_lat = lat_A - lat_B;
  1775. float d_lon = lon_A - lon_B;
  1776.  
  1777. lat_pt_AA = lat_centre_pst + (1852 * 12 /longueur_piste) * d_lat; // point situé à 12NM de la piste
  1778. lon_pt_AA = lon_centre_pst + (1852 * 12 /longueur_piste) * d_lon; // point situé à 12NM de la piste
  1779.  
  1780. //affi_float_test(lat_pt_AA, 120, 2, VERT, NOIR);
  1781. //affi_float_test(lon_pt_AA, 120, 3, JAUNE, NOIR);
  1782.  
  1783. lat_pt_BB = lat_centre_pst - (1852 * 12 /longueur_piste) * d_lat; // point situé à 12NM de la piste
  1784. lon_pt_BB = lon_centre_pst - (1852 * 12 /longueur_piste) * d_lon; // point situé à 12NM de la piste
  1785.  
  1786. //affi_float_test(lat_pt_BB, 120, 4, VERT, NOIR);
  1787. //affi_float_test(lon_pt_BB, 120, 5, JAUNE, NOIR);
  1788. }
  1789.  
  1790.  
  1791.  
  1792. void calculs_piste() // lors du choix de l'Airport
  1793. {
  1794.  
  1795. float lat_A = liste_bali[num_bali].lat_A;
  1796. float lon_A = liste_bali[num_bali].lon_A;
  1797.  
  1798. float lat_B = liste_bali[num_bali].lat_B;
  1799. float lon_B = liste_bali[num_bali].lon_B;
  1800.  
  1801. longueur_piste = 1000.0* distance_AB(lat_A, lon_A, lat_B, lon_B); // en m
  1802.  
  1803. orient_pisteAB = azimut_AB(lat_A, lon_A, lat_B, lon_B);
  1804.  
  1805. orient_pisteBA = orient_pisteAB + 180.0;
  1806. if (orient_pisteBA > 360.0) {orient_pisteBA -= 360.0;}
  1807.  
  1808. lat_centre_pst=(lat_A +lat_B)/2.0;
  1809. lon_centre_pst=(lon_A +lon_B)/2.0;
  1810.  
  1811. }
  1812.  
  1813.  
  1814.  
  1815. void calculs_GPS() // temps réel
  1816. {
  1817.  
  1818. // calculs de la position de l'avion / piste (distance et direction)
  1819.  
  1820. // DISTANCE (variable globale)
  1821. // voir la fonction "distance_AB()" dans le fichier "Fonctions1.h"
  1822. GPS_distance_piste = distance_AB(lat_avion, lon_avion, lat_centre_pst, lon_centre_pst) / 1.852; // du centre de la piste, en NM
  1823. GPS_distance_ptAA = distance_AB(lat_avion, lon_avion, lat_pt_AA, lon_pt_AA) / 1.852;
  1824. GPS_distance_ptBB = distance_AB(lat_avion, lon_avion, lat_pt_BB, lon_pt_BB) / 1.852;
  1825.  
  1826. // DIRECTION (variable globale)
  1827. GPS_azimut_piste = azimut_AB(lat_avion, lon_avion, lat_centre_pst, lon_centre_pst);// latitudes et longitudes en degrés décimaux
  1828. GPS_azimut_ptAA = azimut_AB(lat_avion, lon_avion, lat_pt_AA, lon_pt_AA);
  1829. GPS_azimut_ptBB = azimut_AB(lat_avion, lon_avion, lat_pt_BB, lon_pt_BB);
  1830. }
  1831.  
  1832.  
  1833.  
  1834.  
  1835. void find_sens_approche() // en fonction de la position réelle de l'avion
  1836. {
  1837. //détermination du sens de l'approche pour l'autoland (en vol)
  1838.  
  1839. ////float delta_1 = orient_pisteBA - GPS_azimut_piste;
  1840. ////if (delta_1<0) {delta_1+=360.0;}
  1841. ////if (delta_1>360) {delta_1-=360.0;}
  1842.  
  1843. ////if ((delta_1 >90.0) && (delta_1 <270.0)) {sens_app_effectif = sens_AB;} else {sens_app_effectif = sens_BA;}
  1844. find_END_RWY_dst();
  1845.  
  1846. if(extremite_pst=='A') {sens_app_effectif = sens_BA;}
  1847. if(extremite_pst=='B') {sens_app_effectif = sens_AB;}
  1848.  
  1849. }
  1850.  
  1851.  
  1852.  
  1853.  
  1854. void find_END_RWY_dst() //le pt le plus ELOIGNE en face de nous, en bout de piste (= A ou B )
  1855. {
  1856.  
  1857. // calcul basé sur les distances
  1858. // en vue de guider (en lacet) l'avion au roulage lors de l'atterrissage
  1859. // on visera le point le plus éloigné
  1860. // attention: lors d'un touch and go, si l'avion a dépassé le centre de la piste lors de la remise des gaz, le sens sera FAUX !
  1861.  
  1862. float lat_A=liste_bali[num_bali].lat_A;
  1863. float lon_A=liste_bali[num_bali].lon_A;
  1864. float lat_B=liste_bali[num_bali].lat_B;
  1865. float lon_B=liste_bali[num_bali].lon_B;
  1866.  
  1867. float dst_A = distance_AB(lat_avion, lon_avion, lat_A, lon_A);
  1868. float dst_B = distance_AB(lat_avion, lon_avion, lat_B, lon_B);
  1869.  
  1870. if((dst_A) > (dst_B)) {extremite_pst='A';} else {extremite_pst='B';}
  1871.  
  1872. }
  1873.  
  1874.  
  1875. void find_END_RWY_angl() //le pt le plus ELOIGNE en face de nous, en bout de piste (= A ou B )
  1876. {
  1877. // calcul par les angles
  1878. // en vue de guider (en lacet) l'avion au roulage lors du décollage
  1879. // on visera le point le plus éloigné
  1880.  
  1881.  
  1882. float delta = cap - orient_pisteAB;
  1883.  
  1884. if (delta < -180) {delta += 360;}
  1885. if (delta > 180) {delta -= 360;}
  1886.  
  1887. if(abs(delta) > 90) {extremite_pst='A';} else {extremite_pst='B';}
  1888.  
  1889. //affi_string_test((String)extremite_pst, 130, 4, BLANC, NOIR);
  1890. }
  1891.  
  1892.  
  1893.  
  1894.  
  1895. void auto_rudder_deco() // on passera en boucle dans cette fonction
  1896. {
  1897. // losrqu'on est bien positionné sur la piste, on doit voir l'extrémité de la piste, en face, au loin
  1898. // dans la même direction que l'orientation physique de la piste
  1899.  
  1900. float d_alpha;
  1901. float lat_i, lon_i;
  1902.  
  1903. affi_extremite(); // l'extrémité concernée est déterminée par la fonction "find_END_RWY_angl()"
  1904.  
  1905. if (extremite_pst == 'A')
  1906. {
  1907. lat_i=liste_bali[num_bali].lat_A;
  1908. lon_i=liste_bali[num_bali].lon_A;
  1909. }
  1910.  
  1911. if (extremite_pst == 'B')
  1912. {
  1913. lat_i=liste_bali[num_bali].lat_B;
  1914. lon_i=liste_bali[num_bali].lon_B;
  1915. }
  1916.  
  1917. float az1 = azimut_AB(lat_avion, lon_avion, lat_i, lon_i); // direction dans laquelle on voit le bout de la piste au loin...
  1918.  
  1919. d_alpha = az1 - cap;
  1920.  
  1921. borne_in (&d_alpha, -5.0, 5.0);
  1922.  
  1923. if (vitesse < 20) { rudder =0;}
  1924.  
  1925. //else if (is_in(vitesse, 20, 50)) {rudder = d_alpha /60.0;}
  1926. //else if (is_in(vitesse, 50, 120)) {rudder = d_alpha / 40.0;}
  1927. //else if (is_in(vitesse, 120, 170)) {rudder = d_alpha / 20.0;}
  1928.  
  1929. /**
  1930. CALCUL: système 2 équations à 2 inconnues :
  1931. y=ax+b
  1932.  
  1933. 60=20a+b
  1934. 20=170a+b
  1935.  
  1936. 40=(20-170)a
  1937. 40=-150a
  1938. a= -40/150 = -0.26
  1939.  
  1940. b = 60-20a
  1941. = 60+5.2
  1942. = 65.2
  1943.  
  1944. y = -0.26 x + 70 environ
  1945. **/
  1946.  
  1947. float facteur = -0.26 * vitesse +65.2;
  1948.  
  1949.  
  1950. rudder = rudder_manuel + d_alpha / facteur;
  1951.  
  1952.  
  1953. if (vitesse > 170) { rudder =0;}
  1954.  
  1955.  
  1956. }
  1957.  
  1958.  
  1959.  
  1960. void auto_rudder_attero() // on passera en boucle dans cette fonction
  1961. {
  1962. // losrqu'on est bien positionné sur la piste, on doit voir le l'extrémité de la piste, en face, au loin
  1963. // dans la même direction que l'orientation physique de la piste
  1964.  
  1965. float d_alpha;
  1966. float lat_i, lon_i;
  1967.  
  1968. affi_extremite(); // déterninée en une seule fois lors de la fin de la phase d'autoland
  1969. // voir dans la fonction "void auto_landing()"
  1970. // ne plus la re-déterminer par la suite parce du'une fois dépassé le centre de la piste, le résultat serait faux !
  1971.  
  1972. if (extremite_pst == 'A')
  1973. {
  1974. lat_i=liste_bali[num_bali].lat_A;
  1975. lon_i=liste_bali[num_bali].lon_A;
  1976. }
  1977.  
  1978. if (extremite_pst == 'B')
  1979. {
  1980. lat_i=liste_bali[num_bali].lat_B;
  1981. lon_i=liste_bali[num_bali].lon_B;
  1982. }
  1983.  
  1984. float az1 = azimut_AB(lat_avion, lon_avion, lat_i, lon_i); // direction dans laquelle on voit le bout de la piste au loin...
  1985.  
  1986.  
  1987. d_alpha = az1 - cap;
  1988.  
  1989.  
  1990.  
  1991. borne_in (&d_alpha, -5.0, 5.0); // -3 3
  1992.  
  1993. if (is_in(vitesse, 100, 140)) {rudder = d_alpha / 20.0;}
  1994. else if (is_in(vitesse, 80, 100)) {rudder = d_alpha / 25.0;} //30
  1995. else if (is_in(vitesse, 50, 80)) {rudder = d_alpha / 30.0;} //40
  1996. else if (is_in(vitesse, 20, 50)) {rudder = d_alpha / 50.0;} //80
  1997. else if (vitesse < 10)
  1998. {
  1999. rudder =0;
  2000. //raz_bit(&flags, bit_rudder_attero); // afin de pouvoir manoeuvrer sur les taxiways
  2001. }
  2002.  
  2003. // OK, garde l'axe de la piste, heu... lorsque la roue avant touche le sol...
  2004. // lorsque seul le train principal touche et la vitesse est faible et donc la gouverne de direction peu efficace... pas top !
  2005. // on pourrait jouer en différentiel sur les freins gauche-droite, mais ça complique pas mal l'affaire !
  2006. // toutefois si on freine rapidement (dans la seconde qui suit le toucher initial) la roue avant touche à son tour, et c'est OK
  2007.  
  2008. }
  2009.  
  2010.  
  2011. void nav_to_centre_piste()
  2012. {
  2013. voyant_APP.affiche(BLANC, BLEU);
  2014. hdg1 = round(GPS_azimut_piste);
  2015. if(GPS_distance_piste < 2) // on désengage tout, il faut un appui sur touche pour décider de la suite du vol
  2016. {
  2017. raz_bit(&flags, bit_nav_to_piste);// ce qui signe la fin des appel de cette fonction
  2018. raz_bit(&flags, bit_nav_to_ptAA);
  2019. raz_bit(&flags, bit_nav_to_ptBB);
  2020. raz_bit(&flags, bit_route);
  2021. raz_bit(&flags, bit_autoland);
  2022. raz_bit(&flags, bit_atterrissage);
  2023. raz_bit(&flags, bit_au_sol);
  2024. raz_bit(&flags, bit_decollage);
  2025.  
  2026.  
  2027. for (int n=0; n<4; n++)
  2028. {
  2029. TFT480.setFreeFont(FF6);
  2030. affi_message("verticale RWY", 130, 200, 200, 1000, BLEU_CLAIR, HA_SOL, 1); // ici
  2031. }
  2032.  
  2033. // rien de plus, on repasse en auto-pilotage manuel
  2034.  
  2035. set_bit(&flags, bit_FG_AP);
  2036.  
  2037. }
  2038. }
  2039.  
  2040.  
  2041. void nav_to_ptAA() // on passera en boucle dans cette fonction
  2042. {
  2043. // point situé à 12NM dans l'axe de la piste (d'un côté)
  2044.  
  2045. voyant_APP.affiche(BLANC, VIOLET1);
  2046. hdg1 = round(GPS_azimut_ptAA);
  2047.  
  2048. affi_distance_ptAA();
  2049.  
  2050. if(GPS_distance_ptAA < 2.8)
  2051. {
  2052. raz_bit(&flags, bit_nav_to_piste);
  2053. raz_bit(&flags, bit_nav_to_ptAA); // ce qui signe la fin des appel de cette fonction
  2054. raz_bit(&flags, bit_nav_to_ptBB);
  2055. raz_bit(&flags, bit_route);
  2056.  
  2057. for (int n=0; n<4; n++)
  2058. {
  2059. TFT480.setFreeFont(FF6);
  2060. affi_message("verticale ptA", 130, 200, 200, 1000, BLEU_CLAIR, HA_SOL, 1); // ici
  2061. }
  2062.  
  2063. TFT480.setFreeFont(FF6);
  2064. affi_message("Finale ILS", 130, 200, 200, 1000, BLEU_CLAIR, HA_SOL, 1); // ici
  2065.  
  2066. efface_cadre_bas(NOIR);
  2067. find_END_RWY_dst(); // la plus éloignée (= 'A' ou = 'B')
  2068. set_bit(&flags, bit_autoland); // on passe en finale
  2069. //set_bit(&flags, bit_rudder_attero);
  2070. }
  2071. }
  2072.  
  2073.  
  2074. void nav_to_ptBB() // on passera en boucle dans cette fonction
  2075. {
  2076. // point situé à 12NM dans l'axe de la piste (de l'autre côté)
  2077.  
  2078. voyant_APP.affiche(BLANC, VIOLET2);
  2079. hdg1 = round(GPS_azimut_ptBB);
  2080.  
  2081. affi_distance_ptBB();
  2082.  
  2083.  
  2084. if(GPS_distance_ptBB < 2.8)
  2085. {
  2086. raz_bit(&flags, bit_nav_to_piste);
  2087. raz_bit(&flags, bit_nav_to_ptAA);
  2088. raz_bit(&flags, bit_nav_to_ptBB); // ce qui signe la fin des appel de cette fonction
  2089. raz_bit(&flags, bit_route);
  2090. efface_cadre_bas(NOIR);
  2091.  
  2092. for (int n=0; n<4; n++)
  2093. {
  2094. TFT480.setFreeFont(FF6);
  2095. affi_message("verticale ptB", 130, 200, 200, 500, BLEU_CLAIR, HA_SOL, 1); // ici
  2096.  
  2097. }
  2098.  
  2099. TFT480.setFreeFont(FF6);
  2100. affi_message("Finale ILS", 130, 200, 200, 1000, BLEU_CLAIR, HA_SOL, 1); // ici
  2101.  
  2102. efface_cadre_bas(NOIR);
  2103. find_END_RWY_dst(); // la plus éloignée (= 'A' ou = 'B')
  2104. set_bit(&flags, bit_autoland); // on passe en finale
  2105. //set_bit(&flags, bit_rudder_attero);
  2106. }
  2107. }
  2108.  
  2109.  
  2110.  
  2111. /*
  2112. void nav_to_pt1() // on passera en boucle dans cette fonction
  2113. {
  2114. // vers point d'entrée en finale (situé un peu de côté par rapport à l'axe de la piste)
  2115. voyant_APP.affiche(BLANC, VERT_FONCE);
  2116.  
  2117. float alpha1;
  2118. char c1 = liste_bali[num_bali].sens_app_requis;
  2119. if ( c1=='A')
  2120. {
  2121. alpha1= orient_pisteAB + 5.0; // les 5° de côté laissent la place pour faire un 180° vers la piste
  2122. }
  2123. if (c1 == 'B')
  2124. {
  2125. alpha1= orient_pisteBA + 5.0;
  2126. }
  2127.  
  2128. if (c1 == 'X')
  2129. {
  2130. if(choix_aleatoire == 0)//ce choix aléatoire n'est calculé qu'une fois lors du positionnement du flag 'bit_nav_to_piste'
  2131. {
  2132. alpha1= orient_pisteAB + 5.0;
  2133. }
  2134. if(choix_aleatoire == 1)
  2135. {
  2136. alpha1= orient_pisteBA + 5.0;
  2137. }
  2138. }
  2139.  
  2140. if (alpha1 > 360) {alpha1 -= 360;}
  2141. hdg1 = round(alpha1);
  2142.  
  2143. if(GPS_distance_piste > 10){raz_bit(&flags, bit_nav_to_pt1);} // ce qui signe la fin des appel de cette fonction
  2144. }
  2145. */
  2146.  
  2147.  
  2148. void auto_landing()
  2149. {
  2150. // on passera en boucle dans cette fonction
  2151. /**
  2152.  voir: https://en.wikipedia.org/wiki/Autoland
  2153.  
  2154.  Approche automatique
  2155.  CAPTURE l'avion et le POSE !
  2156.  
  2157.  LES CONSEILS QUI SUIVENT ne concernent que l'utilisation du simulateur de vol FlightGear connecté aux ESP32
  2158.  et le choix du Citation X comme avion.
  2159.  c'est à dire qu'ils ne doivent en aucun cas servir pour le pilotage d'un avion réel.
  2160.  
  2161.  
  2162.  -vitesse conseillée : 140kts, 160kts max
  2163.  -distance conseillée : entre 20 et 10 nautiques
  2164.  -avec une trajectoire qui recoupe l'axe de la piste, < 90°
  2165.  (si capture à moins de 10 NM, la trajectoire sera difficilement corrigée -> remise des gaz ou crash au choix !)
  2166.  -hauteur conseillée : 3000ft à 10NM (= niveau 30)
  2167.  
  2168.  -volets sortis 2 puis 3
  2169.  à priori pas d'AF si vitesse correcte
  2170.  
  2171.  -sortir le train !
  2172.  -allumer feux d'atterrissage
  2173.  
  2174.  notes: l'autopilot se désengage automatiquement (par FlightGear) sous 100ft de hauteur
  2175.  (réglable, voir la variable 'hauteur_mini_autopilot' au début de ce programme)
  2176.  
  2177. ce qui suit est actuellement devenu automatique dans les nouvelles versions :
  2178.  
  2179.  (Donc garder le manche en main pour l'arrondi et le touché final, en surveillant
  2180.  - la hauteur
  2181.  - la vitesse
  2182.  - le pitch
  2183.  - position des volets
  2184.  - éventuellement petit coup d'AF (aérofreins -> CTRL + B au clavier)
  2185.  - si piste très courte, inverseurs de poussée (au sol) + gaz (touche 'suppr')
  2186.  - toutefois si approche visiblement trop courte ou trop longue, pas d'attéro kamikaze ! -> remise des gaz !!
  2187.  - si système visuel "papi" présent, le respecter !!
  2188.  
  2189.  TOUTEFOIS :
  2190.  - on peut obtenir un posé 100% auto en anticipant un cabrage de l'avion pour faire l'arrondi dans les règles de l'art
  2191.  avec posé du train principal en premier, puis ensuite la roulette de nez. Pour cela :
  2192.  - en fin de finale, à une hauteur de 100 feet, dès le désengagement de l'autopilot de FlightGear:
  2193.  -gaz au mini et sortir les AF. La vitesse diminue, et l'avion se cabre un peu
  2194.  pour ne pas plonger... et il finit par poser le train principal.
  2195.  - dès que ce touché est fait, freiner légèrement -> la roue avant va alors à son tour toucher la piste, ce qui permet
  2196.  à l'auto-rudder de guider la trajectoire suivant l'axe de la piste.
  2197.  ( Tant que la roue avant ne touche pas, l'auto-rudder, qui n'agit alors qu'aérodynamiquement sur la gouverne de direction,
  2198.  n'est pas assezefficace).
  2199.  
  2200.  Le tout suivi d'un freinage, on pose avec arrêt complet sur 850m (sans faire craquer la structure...).
  2201.  Avec les inverseurs de poussée, on doit pouvoir faire bien mieux encore. Quant au porte-avion, il est normalement
  2202.  équipé d'un câble de retenue qu'on accroche avec une perche (sur un jet militaire, sans doute pas avec notre Cessna Citation X)
  2203.  
  2204. **/
  2205.  
  2206. String s1;
  2207. float alti1;
  2208. float GPS_distance_seuil_piste;
  2209.  
  2210. TFT480.setFreeFont(FSS9);
  2211.  
  2212. TFT480.setTextColor(GRIS_FONCE, NOIR);
  2213. //TFT480.fillRect(180, 0, 20, 16, JAUNE); // JAUNE pour test. efface 1/2 le bandeau d'information en haut
  2214.  
  2215. voyant_L.affiche(BLANC, GRIS_TRES_FONCE);
  2216.  
  2217. voyant_G.affiche(BLANC, GRIS_TRES_FONCE);
  2218.  
  2219. voyant_APP.affiche(BLANC, GRIS_TRES_FONCE);
  2220.  
  2221. uint8_t AZ =0; // flag azimut OK
  2222. uint8_t GL =0; // flag glide OK
  2223.  
  2224.  
  2225.  
  2226. //voyant_descente_GPS.affiche(BLANC, GRIS_TRES_FONCE);
  2227.  
  2228.  
  2229. //--------------------- (si autoland engagé (par le bouton 'APP ILS' du module SW), sinon on ne fait rien de plus)--------------
  2230.  
  2231. //TFT480.fillRect(HA_x0-40, HA_y0+80, 87, 15, HA_SOL); // efface "APP"
  2232.  
  2233. if (read_bit(flags, bit_autoland) == 1)
  2234. {
  2235. if (GPS_distance_piste > 20.0)
  2236. {
  2237. return; // rien de plus
  2238. }
  2239. else
  2240. {
  2241. //affi_float_test(liste_bali[num_bali].orient_pisteAB,110, 2, BLANC, BLEU); // pour test
  2242. //affi_float_test(GPS_azimut_piste,110, 3, BLANC, GRIS_FONCE); // pour test
  2243.  
  2244. voyant_APP.affiche(NOIR, JAUNE);
  2245.  
  2246.  
  2247. // -------------------- AZIMUT -----------------------------------------------------------------
  2248.  
  2249. float op1;
  2250. find_sens_approche();
  2251. affi_sens_APP(); // en haut à droite
  2252.  
  2253. if (sens_app_effectif == sens_AB) {op1 = orient_pisteAB;}
  2254. if (sens_app_effectif == sens_BA) {op1 = orient_pisteBA;}
  2255. //s1 = String(op1,1);
  2256. //TFT480.drawString(s1, 0, 250);
  2257.  
  2258.  
  2259. float delta_AZM = op1 -GPS_azimut_piste;
  2260.  
  2261. //affi_float_test(delta_AZM,110, 2, VERT, GRIS_FONCE); // pour test
  2262.  
  2263. delta_AZM *= 20.0;
  2264. borne_in(&delta_AZM, -35.0, 35.0);
  2265.  
  2266. //if((delta_AZM >-10.0)&&(delta_AZM <10.0))
  2267. if (is_in(delta_AZM, -10.0, 10.0)==1)
  2268. {
  2269. voyant_L.affiche(NOIR, VERT);
  2270. AZ=1;
  2271. }
  2272.  
  2273. affi_localizer(delta_AZM * -2.5);
  2274.  
  2275. hdg1 = round(op1 - delta_AZM);
  2276.  
  2277.  
  2278. //affi_float_test(hdg1,110, 5, VERT, GRIS_FONCE); // pour test
  2279.  
  2280. // -------------------- VITESSE -----------------------------------------------------------------
  2281.  
  2282. if ( (GPS_distance_piste < 20.0) && (target_speed>160) ) {target_speed =160;}
  2283. if ( (GPS_distance_piste < 10.0) && (target_speed>150) ) {target_speed =150;}
  2284. if ( (GPS_distance_piste < 5.0) && (target_speed>140) ) {target_speed =140;}
  2285. if ( (GPS_distance_piste < 2.0) && (target_speed>130) ) {target_speed =130;}
  2286.  
  2287. // -------------------- HAUTEUR -----------------------------------------------------------------
  2288.  
  2289. //voyant_descente_GPS.affiche(NOIR, JAUNE);
  2290. float longueur_piste_NM = longueur_piste / 1852.0;
  2291. GPS_distance_seuil_piste = GPS_distance_piste - (longueur_piste_NM/2.0) + 0.1;
  2292. // todo : ajouter la longueur des pistes dans le fichier FG_data.h afin de'affiner ce paramètre
  2293. // Rappel : "GPS_distance_piste" est la distance au point CENTRAL de la piste
  2294.  
  2295. TFT480.setFreeFont(FM12);
  2296. TFT480.setTextColor(BLANC);
  2297. s1=String(GPS_distance_seuil_piste, 1);
  2298. s1+= " NM";
  2299. TFT480.fillRect(150, 300, 100, 25, GRIS_AF); // efface
  2300. TFT480.drawString(s1, 150, 300);
  2301.  
  2302.  
  2303. //affi_float_test(GPS_distance_seuil_piste, 110, 2, BLANC, BLEU); // pour test
  2304.  
  2305. float alti_correcte = liste_bali[num_bali].altitude + 300.0 * GPS_distance_seuil_piste;
  2306.  
  2307. affi_asel(alti_correcte);
  2308.  
  2309. // soit 3000ft pour 10 nautiques -> pente 5%
  2310. //sachant que la ref de position est située au milieu de la longueur de la piste
  2311.  
  2312. //affi_float_test(alti_correcte, 110, 2, BLANC, BLEU); // pour test
  2313.  
  2314. float erreur_altitude = altitude_GPS - alti_correcte;
  2315. //affi_float_test(erreur_altitude, 110, 3, BLANC, BLEU); // pour test
  2316.  
  2317. if((erreur_altitude > -20)&& (erreur_altitude < 20))
  2318. {
  2319. //voyant_G.affiche(NOIR, VERT);
  2320. }
  2321.  
  2322. affi_index_lateral( - erreur_altitude / 3.0); // affiche les triangles roses latéraux
  2323.  
  2324. /**Rappels :
  2325. 1 NM (nautical mile ou 'nautique') = 1852 m
  2326. 1 feet = 0,3048 m
  2327. 1 NM = 1852/0.3048 = 6076.12 feet
  2328. 1 noeud (nd) = 1NM/h = 1852/3600 = 0.51444 m/s
  2329.  
  2330. début de descente (5%) vers la piste : 3000ft à 10NM, vitesse 150 nd (par exemple)
  2331. v=150*0.51444 = 77.17m/s
  2332. temps pour parcourir la distance : v=d/t
  2333. t=d/v = 10*1852m / 77.17 = 240 s (soit 4 minutes)
  2334.  
  2335. taux de descente = 3000ft/240s = 12.5 fps
  2336. **/
  2337. if ((GPS_distance_piste < 15) && (hauteur_AAL > 1500) && (hauteur_AAL <= 6000))
  2338. {
  2339. // initialisation de l'approche auto (palier puis descente)
  2340. //voyant_descente_GPS.affiche(NOIR, VERT);
  2341.  
  2342. locks_type = "VS"; // bascule le pilote auto de FG en mode vertical speed
  2343.  
  2344. //climb_rate = -5.0;
  2345.  
  2346. }
  2347.  
  2348. if ((GPS_distance_piste < 15) && (hauteur_AAL < 6000))
  2349. {
  2350. // descente
  2351. // correction du taux de descente (climb_rate) pour respecter la pente à 3° (=5%)
  2352. voyant_G.affiche(NOIR, VERT);
  2353. GL=1;
  2354.  
  2355. //if (erreur_altitude > 4) {climb_rate -= 5; }
  2356. //if (erreur_altitude < -4) {climb_rate += 5; }
  2357.  
  2358. climb_rate = erreur_altitude * -1.0;
  2359. if (climb_rate > +20) {climb_rate = +20;}
  2360. if (climb_rate < -40) {climb_rate = -40;}
  2361.  
  2362. //affi_float_test( erreur_altitude, 110, 4, NOIR, JAUNE); // pour test
  2363. }
  2364.  
  2365. if (GPS_distance_piste < 8)
  2366. {
  2367. flaps = 2;
  2368. }
  2369.  
  2370.  
  2371. if (GPS_distance_piste < 3)
  2372. {
  2373. flaps = 3; // participe grandement au freinage de l'avion en fin de finale
  2374. }
  2375.  
  2376.  
  2377. if (hauteur_AAL < hauteur_mini_autopilot) // signe la fin des appels de catte fonction
  2378. {
  2379.  
  2380. raz_bit(&flags, bit_rudder_decol);
  2381. set_bit(&flags, bit_rudder_attero);// la trajectoire près du sol -> par gouverne de direction
  2382.  
  2383.  
  2384. throttle = 1.0; // gaz au minimum
  2385. target_speed = 0;
  2386. //trim_elevator = 0.0;
  2387.  
  2388. raz_bit(&flags, bit_FG_AP);
  2389. desengage_autoland(); // donc on ne repassera plus dans la fonction (ici)
  2390.  
  2391. set_bit(&flags, bit_atterrissage); // on passera dorénavant en boucle dans la fonction "atterrissage()"
  2392.  
  2393. affiche_etats_flags();
  2394. }
  2395.  
  2396. if( (AZ==1) && (GL==1) ) {voyant_APP.affiche(NOIR, VERT);}
  2397.  
  2398. /**
  2399. alti1 = 3.0*GPS_distance_piste + gnd_elv/100.0 -1;
  2400. if (alti1 < asel1) //empêche de (re)monter lors de la capture ILS, reste en palier le cas échéant
  2401. {
  2402. asel1 = alti1;
  2403. }
  2404. **/
  2405. }
  2406.  
  2407. // =============================================================================================================================
  2408. }
  2409.  
  2410. //------------------------------------------------------------------------------------------------------------------------------
  2411.  
  2412. }
  2413.  
  2414.  
  2415.  
  2416. void prepare_decollage()
  2417. {
  2418. raz_bit(&flags, bit_atterrissage);
  2419. raz_bit(&flags, bit_FG_AP);
  2420. raz_bit(&flags, bit_autoland);
  2421. raz_bit(&flags, bit_route);
  2422.  
  2423. set_bit(&flags, bit_nav_to_piste); // par défaut
  2424.  
  2425. //raz_bit(&flags, bit_nav_to_pt1);
  2426. raz_bit(&flags, bit_nav_to_ptAA);
  2427. raz_bit(&flags, bit_nav_to_ptBB);
  2428.  
  2429. raz_bit(&flags, bit_rudder_attero);
  2430.  
  2431. set_bit(&flags, bit_au_sol);
  2432.  
  2433. locks_type = "ALT";
  2434. asel1 = 30;
  2435. target_speed = 180;
  2436.  
  2437. find_END_RWY_angl();
  2438.  
  2439. set_bit(&flags, bit_rudder_decol);
  2440.  
  2441. set_bit(&flags, bit_decollage);
  2442. flaps = 3;
  2443.  
  2444. msg_to_send="OK to take-off";
  2445.  
  2446. }
  2447.  
  2448.  
  2449.  
  2450.  
  2451. void decollage()
  2452. // on passera en boucle dans cette fonction ; voir aussi la fonction "prepare_decollage()"
  2453. {
  2454.  
  2455. asel1 = liste_bali[num_bali].niveau_de_vol_mini;
  2456.  
  2457. speedbrake =0;
  2458. throttle = -1.0;
  2459.  
  2460. trim_elevator = -0.3; // bonne valeur pour décoller
  2461. if (hauteur_AAL >10){trim_elevator=-0.20;} // pour ne pas grimper aux arbres
  2462. if (hauteur_AAL >70){trim_elevator=-0.15;}
  2463.  
  2464. affi_elevator();
  2465.  
  2466.  
  2467. if (hauteur_AAL > 50)
  2468. {
  2469. raz_bit(&flags, bit_rudder_decol);
  2470. rudder=0;
  2471. }
  2472.  
  2473.  
  2474. if (hauteur_AAL > 200)
  2475. {
  2476. trim_elevator =0.0;
  2477. flaps = 0;
  2478. raz_bit(&flags, bit_decollage); // fin des appels de cette fonction
  2479. set_bit(&flags, bit_FG_AP); // engage Autopilot de FlightGear
  2480. speed_ctrl=true;
  2481.  
  2482. msg_to_send = "engage AP";
  2483. TFT480.setFreeFont(FF6);
  2484. affi_message (msg_to_send, 130, 200, 200, 300, VERT, HA_SOL, 1); // ici
  2485. }
  2486.  
  2487. }
  2488.  
  2489.  
  2490. void atterrissage()
  2491. // on passera en boucle dans cette fonction
  2492. {
  2493.  
  2494. // premier terme = léger cabré pour l'arrondi
  2495. // deuxième terme diminue ce cabré tant que la hauteur est grande
  2496. // troisième terme = asservissement de l'angle de tangage de façon à stabiliser l'ensemble
  2497.  
  2498. //trim_elevator = -0.5+ (float)hauteur_AAL/1500.0 + (tangage / 20.0);
  2499.  
  2500. trim_elevator = -0.5 + (tangage / 20.0);
  2501.  
  2502. //trim_elevator = -0.1;
  2503.  
  2504. //throttle = 0.95; // gaz presqu'au mini
  2505. //if (hauteur_AAL < 50 ){throttle = 1.0;} // ralenti total (évite de manger toute la piste en rase motte)
  2506.  
  2507. throttle = 1.0; // gaz au mini
  2508.  
  2509. if(hauteur_AAL < 20) {speedbrake = 1.0;}
  2510.  
  2511. set_bit(&flags, bit_rudder_attero);
  2512. }
  2513.  
  2514.  
  2515.  
  2516. void roulage()
  2517. // sur taxiways
  2518. // on passera en boucle dans cette fonction
  2519. {
  2520. // throttle = 0.80; // 1.0 -> ralentit; 0 -> mi-gaz ; -1.0 -> plein gaz
  2521. if (vitesse < 15) {throttle -= 0.01;}
  2522. if (vitesse > 15) {throttle += 0.01;}
  2523.  
  2524. borne_in(&throttle, 0.5, 1.0);
  2525.  
  2526.  
  2527. }
  2528.  
  2529.  
  2530.  
  2531. void affi_localizer(float valeur)
  2532. {
  2533. //ILS (maintenant GPS) dans le plan horizontal; affiche l'erreur de position par rapport à l'axe de la piste
  2534.  
  2535. uint16_t y1 = HA_y0-HA_h-14;
  2536.  
  2537. uint16_t couleur1 = ROSE;
  2538.  
  2539. loc = HA_x0 + valeur;
  2540.  
  2541. if ( loc < (HA_x0-HA_w+5)) {loc = HA_x0-HA_w+5; couleur1 = GRIS;}
  2542. if ( loc > (HA_x0+HA_w-5)) {loc= HA_x0+HA_w-5; couleur1 = GRIS;}
  2543.  
  2544.  
  2545. TFT480.fillRect(HA_x0-HA_w, y1, 2*HA_w, 9, GRIS_TRES_FONCE);
  2546. TFT480.drawLine(HA_x0, y1-5, HA_x0, y1+5, BLANC);
  2547.  
  2548. affi_indexV(loc, y1, 1, couleur1); // petit triangle rose en haut, se déplaçant horizontalement
  2549.  
  2550. memo_loc=loc;
  2551. }
  2552.  
  2553.  
  2554.  
  2555. void affi_index_lateral(uint16_t position_i)
  2556. {
  2557. // petits triangles roses de chaque côtés du PFD
  2558. // (à mi-hauteur du PFD si =0)
  2559.  
  2560. uint16_t x1 = 75;
  2561. uint16_t x2 = 332;
  2562.  
  2563. uint16_t position_V = HA_y0 - position_i;
  2564.  
  2565. TFT480.fillRect(x1, 30, 9, 2*HA_h, GRIS_TRES_FONCE); // efface
  2566. TFT480.fillRect(x2, 30, 9, 2*HA_h, GRIS_TRES_FONCE); // efface
  2567.  
  2568. TFT480.drawRect(x1, HA_y0, 12, 5, BLANC);
  2569. TFT480.drawRect(x2, HA_y0, 12, 5, BLANC);
  2570.  
  2571. uint16_t couleur1 = ROSE;
  2572. if ( position_V < (HA_y0-HA_h+5)) {position_V = HA_y0-HA_h+5; couleur1 = GRIS;}
  2573. if ( position_V > (HA_y0+HA_h-5)) {position_V = HA_y0+HA_h-5; couleur1 = GRIS;}
  2574.  
  2575. affi_indexH(x1, position_V, 1, couleur1);
  2576. affi_indexH(x2+8, position_V, -1, couleur1);
  2577. }
  2578.  
  2579.  
  2580.  
  2581. void trace_arc_gradu()
  2582. {
  2583. //arc gradué en haut au centre, indiquant la valeur de l'inclinaison
  2584.  
  2585. float angle;
  2586. //Draw_arc_elliptique(HA_x0, 120, 120, 80, 0.6, 2.6, BLANC);
  2587.  
  2588.  
  2589. for(uint8_t n=0; n<9; n++ )
  2590. {
  2591. angle =30+ n*15; // 1 tiret tous les 15 degrés
  2592. float pourcent = 0.9;
  2593. if (((n+2)%2) == 0) {pourcent = 0.8;}
  2594.  
  2595. affi_rayon1(HA_x0, HA_y0+10, 110, degTOrad(angle), pourcent, BLANC, false); // tirets de graduation
  2596. }
  2597. }
  2598.  
  2599.  
  2600.  
  2601. void rotation1()
  2602. {
  2603. // consigne de cap
  2604. // acquisition de l'encodeur pas à pas (1)
  2605. if ( millis() - TEMPO >= timer1 )
  2606. {
  2607. timer1 = millis();
  2608. bool etat = digitalRead(rot1b);
  2609. if(etat == 0) { hdg1+=1;} else { hdg1-=1;}
  2610. if (hdg1<0){hdg1=359;}
  2611.  
  2612. if (hdg1>359){hdg1=0;}
  2613. }
  2614. }
  2615.  
  2616.  
  2617.  
  2618. void rotation2()
  2619. {
  2620. // consigne d'altitude
  2621. // acquisition de l'encodeur pas à pas (2)
  2622. if ( millis() - TEMPO >= timer2 )
  2623. {
  2624. timer2 = millis();
  2625. bool etat = digitalRead(rot2b);
  2626. if(etat == 0) { asel1+=1; } else { asel1-=1; }
  2627. if (asel1<1){asel1=1;} // 100 pieds -> 30m
  2628. if (asel1>600){asel1=600;}
  2629. }
  2630. }
  2631.  
  2632.  
  2633.  
  2634. void init_SDcard()
  2635. {
  2636. String s1;
  2637.  
  2638. TFT480.fillRect(0, 0, 480, 320, NOIR); // efface
  2639. TFT480.setTextColor(BLANC, NOIR);
  2640. TFT480.setFreeFont(FF1);
  2641.  
  2642. uint16_t y=0;
  2643.  
  2644. TFT480.drawString("PRIMARY FLIGHT DISPLAY", 0, y);
  2645. y+=20;
  2646.  
  2647. s1="version " + version;
  2648. TFT480.drawString(s1, 0, y);
  2649.  
  2650. y+=40;
  2651. TFT480.setTextColor(VERT, NOIR);
  2652. TFT480.drawString("Init SDcard", 0, y);
  2653. y+=20;
  2654.  
  2655.  
  2656. if(!SD.begin())
  2657. {
  2658. TFT480.drawString("Card Mount Failed", 0, y);
  2659. delay (2000);
  2660. TFT480.fillRect(0, 0, 480, 320, NOIR); // efface
  2661. return;
  2662. }
  2663.  
  2664.  
  2665. uint8_t cardType = SD.cardType();
  2666.  
  2667. if(cardType == CARD_NONE)
  2668. {
  2669. TFT480.drawString("No SDcard", 0, y);
  2670. delay (2000);
  2671. TFT480.fillRect(0, 0, 480, 320, NOIR); // efface
  2672. return;
  2673. }
  2674.  
  2675. flag_SDcardOk=1;
  2676.  
  2677. TFT480.drawString("SDcard Type: ", 0, y);
  2678. if(cardType == CARD_SD) {TFT480.drawString("SDSC", 150, y);}
  2679. else if(cardType == CARD_SDHC) {TFT480.drawString("SDHC", 150, y);}
  2680.  
  2681. y+=20;
  2682.  
  2683. uint32_t cardSize = SD.cardSize() / (1024 * 1024);
  2684. s1=(String)cardSize + " GB";
  2685. TFT480.drawString("SDcard size: ", 0, y);
  2686. TFT480.drawString(s1, 150, y);
  2687.  
  2688. // listDir(SD, "/", 0);
  2689.  
  2690. //Serial.printf("Total space: %lluMB\n", SD.totalBytes() / (1024 * 1024));
  2691. //Serial.printf("Used space: %lluMB\n", SD.usedBytes() / (1024 * 1024));
  2692.  
  2693. delay (1000);
  2694. TFT480.fillRect(0, 0, 480, 320, NOIR); // efface
  2695.  
  2696. }
  2697.  
  2698.  
  2699. void init_sprites()
  2700. {
  2701. // sprites représentant les lettres 'N' 'S' 'E' 'O' qui seront affichées sur un cercle, inclinées donc.
  2702.  
  2703. SPR_E.setFreeFont(FF1);
  2704. SPR_E.setTextColor(JAUNE);
  2705. SPR_E.createSprite(SPR_W, SPR_H);
  2706. SPR_E.setPivot(SPR_W/2, SPR_H/2); // Set pivot relative to top left corner of Sprite
  2707. SPR_E.fillSprite(GRIS_TRES_FONCE);
  2708. SPR_E.drawString("E", 2, 1 );
  2709.  
  2710. SPR_N.setFreeFont(FF1);
  2711. SPR_N.setTextColor(JAUNE);
  2712. SPR_N.createSprite(SPR_W, SPR_H);
  2713. SPR_N.setPivot(SPR_W/2, SPR_H/2);
  2714. SPR_N.fillSprite(GRIS_TRES_FONCE);
  2715. SPR_N.drawString("N", 2, 1 );
  2716.  
  2717. SPR_O.setFreeFont(FF1);
  2718. SPR_O.setTextColor(JAUNE);
  2719. SPR_O.createSprite(SPR_W, SPR_H);
  2720. SPR_O.setPivot(SPR_W/2, SPR_H/2);
  2721. SPR_O.fillSprite(GRIS_TRES_FONCE);
  2722. SPR_O.drawString("W", 2, 1 );
  2723.  
  2724. SPR_S.setFreeFont(FF1);
  2725. SPR_S.setTextColor(JAUNE);
  2726. SPR_S.createSprite(SPR_W, SPR_H);
  2727. SPR_S.setPivot(SPR_W/2, SPR_H/2);
  2728. SPR_S.fillSprite(GRIS_TRES_FONCE);
  2729. SPR_S.drawString("S", 2, 1 );
  2730.  
  2731. SPR_trajectoire.setFreeFont(FF1);
  2732. SPR_trajectoire.setTextColor(JAUNE);
  2733. SPR_trajectoire.createSprite(292, 88);
  2734. SPR_trajectoire.fillSprite(TFT_BLACK);
  2735. SPR_trajectoire.drawString("DESCENTE 5%", 170, 1 );
  2736. }
  2737.  
  2738.  
  2739. void init_Leds() // pour l'affichage des données, voir la fonction "affi_data_piste()"
  2740. {
  2741. uint16_t x0 = 464;
  2742. uint16_t y0 = 0;
  2743. uint16_t xi=x0;
  2744. uint16_t yi=y0;
  2745.  
  2746.  
  2747. Led1.init(xi,yi, 10, 10);
  2748. Led1.set_couleur(ROUGE);
  2749. Led1.allume();
  2750.  
  2751. yi+=10;
  2752.  
  2753. Led2.init(xi,yi, 10, 10);
  2754. Led2.set_couleur(JAUNE);
  2755. Led2.allume();
  2756.  
  2757. yi+=10;
  2758.  
  2759. Led3.init(xi,yi, 10, 10);
  2760. Led3.set_couleur(VERT);
  2761. Led3.allume();
  2762.  
  2763. yi+=10;
  2764.  
  2765. Led4.init(xi,yi, 10, 10);
  2766. Led4.set_couleur(BLEU);
  2767. Led4.allume();
  2768.  
  2769. yi+=10;
  2770.  
  2771. Led5.init(xi,yi, 10, 10);
  2772. Led5.set_couleur(VIOLET1);
  2773. Led5.allume();
  2774.  
  2775. delay(100);
  2776.  
  2777. }
  2778.  
  2779.  
  2780.  
  2781. void int16_to_array(int16_t valeur_i)
  2782. {
  2783. // prépare la chaine de caract à zéro terminal pour l'envoi
  2784. // Remarque : 2^16 -1 = 65535 -> 5 caractères)
  2785.  
  2786. String s1= (String) valeur_i;
  2787. uint8_t len1 = s1.length();
  2788. for(int n=0; n<len1; n++)
  2789. {
  2790. var_array16[n]=s1[n];
  2791. }
  2792. var_array16[len1]=0; // zéro terminal -> chaine C
  2793. }
  2794.  
  2795.  
  2796.  
  2797. void int32_to_array(int32_t valeur_i)
  2798. {
  2799. // prépare la chaine de caract à zéro terminal pour l'envoi
  2800. // Remarque : 2^32 -1 = 4294967295 -> 10 caractères
  2801.  
  2802. String s1= (String) valeur_i;
  2803. uint8_t len1 = s1.length();
  2804. for(int n=0; n<len1; n++)
  2805. {
  2806. var_array32[n]=s1[n];
  2807. }
  2808. var_array32[len1]=0; // zéro terminal -> chaine C
  2809. }
  2810.  
  2811.  
  2812. void string_to_array(String str_i)
  2813. {
  2814. // prépare la chaine de caract à zéro terminal pour l'envoi
  2815.  
  2816. uint8_t len1 = str_i.length();
  2817. for(int n=0; n<len1; n++)
  2818. {
  2819. var_array32[n]=str_i[n];
  2820. }
  2821. var_array32[len1]=0; // zéro terminal -> chaine C
  2822. }
  2823.  
  2824.  
  2825. void annule_tout()
  2826. {
  2827. msg_to_send = "RAZ";
  2828. raz_bit(&flags, bit_decollage);
  2829. raz_bit(&flags, bit_atterrissage);
  2830. raz_bit(&flags, bit_FG_AP);
  2831. raz_bit(&flags, bit_autoland);
  2832. raz_bit(&flags, bit_route);
  2833. raz_bit(&flags, bit_nav_to_piste);
  2834. //raz_bit(&flags, bit_nav_to_pt1);
  2835. raz_bit(&flags, bit_nav_to_ptAA);
  2836. raz_bit(&flags, bit_nav_to_ptBB);
  2837. raz_bit(&flags, bit_rudder_decol);
  2838. //raz_bit(&flags, bit_rudder_attero);
  2839. locks_type = "ALT";
  2840. speed_ctrl=false;
  2841. trim_elevator=0;
  2842. throttle = 1.0;
  2843. speedbrake=0;
  2844.  
  2845. }
  2846.  
  2847.  
  2848.  
  2849.  
  2850. void setup()
  2851. {
  2852. Serial.begin(38400); // 19200
  2853.  
  2854. locks_type ="ALT";
  2855. raz_bit(&flags, bit_FG_AP); // pas d'engagement de l'autopilot de FlightGear à ce stade
  2856. WiFi.persistent(false);
  2857. WiFi.softAP(ssid, password); // Crée un réseau WiFi en mode privé (indépendant de celui de la box internet...)
  2858. IPAddress IP = WiFi.softAPIP();
  2859.  
  2860.  
  2861. server.on("/switch", HTTP_GET, [](AsyncWebServerRequest *request) // lecture des boutons de l'ESP du module SW
  2862. {
  2863. // attention: ce code est appelé par une interruption WiFi qui intervient hors timing. Donc pas d'affichage ici !!
  2864.  
  2865. argument_recu1 = request->arg("sw1"); // réception de l'argument n°1 de la requête
  2866. switches=argument_recu1; // réception des boutons du module SW
  2867. v_switches=switches.toInt();
  2868. flag_traiter_SW=1; //positionne ce drapeau afin que le traitement se fasse dans le timming général, pas ici !
  2869.  
  2870. int16_to_array(0);
  2871.  
  2872. argument_recu2 = request->arg("pot1"); // réception de l'argument n°2 de la requête
  2873. potar1=argument_recu2; // = "0".."255"
  2874. v_potar1 = -128 + potar1.toInt(); // centre autour de 0
  2875.  
  2876. float valeur1 = v_potar1 * v_potar1; // au carré pour avoir une bonne précision aux faibles débattements,
  2877. //et une bonne réponse à fond (taxi au sol)
  2878.  
  2879. //if (abs(v_potar1) > 100) {raz_bit(&flags, bit_rudder_attero);} // afin de pouvoir manoeuvrer sur les taxiways}
  2880.  
  2881. if (v_potar1<0) {valeur1 = -valeur1;} // because un carré est toujours positif, or on veut conserver le signe
  2882.  
  2883. if ((read_bit(flags, bit_rudder_decol) == 0) && (read_bit(flags, bit_rudder_decol) == 0)) // on est donc en manuel pour la "dérive"
  2884. {
  2885. rudder_manuel = valeur1 / 20000.0; // 10000.0 détermine la sensibilité de la gouverne de direction (lacet)
  2886. }
  2887. //cet array because la fonction "request->send_P()" n'accèpte pas directement le string
  2888. //rappel :
  2889. //void send_P(int code, const String& contentType, const uint8_t * content, size_t len, AwsTemplateProcessor callback=nullptr);
  2890. //void send_P(int code, const String& contentType, PGM_P content, AwsTemplateProcessor callback=nullptr);
  2891.  
  2892. request->send_P(200, "text/plain", var_array16); // envoie comme réponse au client
  2893. });
  2894.  
  2895.  
  2896. server.on("/hdg", HTTP_GET, [](AsyncWebServerRequest *request) // consigne de cap
  2897. {
  2898. // attention: ce code est appelé par une interruption WiFi qui intervient hors timing. Donc pas d'affichage ici !!
  2899.  
  2900. argument_recu1 = request->arg("a1"); // reception de l'argument n°1 de la requête
  2901. num_bali=argument_recu1.toInt();
  2902.  
  2903. argument_recu2 = request->arg("swND");
  2904. flag_traiter_SW=1; //positionne ce drapeau afin que le traitement se fasse dans le timming général, pas ici !
  2905.  
  2906. v_switches_ND = argument_recu2.toInt();
  2907. switches_ND = String(v_switches_ND);
  2908.  
  2909.  
  2910. int16_to_array(hdg1);
  2911.  
  2912. //cet array because la fonction "request->send_P()" n'accèpte pas directement le string
  2913. //rappel :
  2914. //void send_P(int code, const String& contentType, const uint8_t * content, size_t len, AwsTemplateProcessor callback=nullptr);
  2915. //void send_P(int code, const String& contentType, PGM_P content, AwsTemplateProcessor callback=nullptr);
  2916.  
  2917. request->send_P(200, "text/plain", var_array16); // envoie hdg1 comme réponse au client
  2918. });
  2919.  
  2920. // réponses aux requêtes :
  2921. // VOIR la fonction "void interroge_WiFi()" dans le code du ND (l'affichage de la carte...)
  2922. // pour la réception des données qui suivent
  2923. server.on("/cap", HTTP_GET, [](AsyncWebServerRequest *request)
  2924. {
  2925. int16_to_array(cap); // prépare la chaine de caract à zéro terminal pour l'envoi
  2926. request->send_P(200, "text/plain", var_array16); // envoie réponse au client
  2927. });
  2928.  
  2929.  
  2930. server.on("/latitude", HTTP_GET, [](AsyncWebServerRequest *request) // latitude de l'avion
  2931. {
  2932. int32_t lati1 = (int32_t) (lat_avion * 10000.0);
  2933.  
  2934. int32_to_array(lati1);
  2935. request->send_P(200, "text/plain", var_array32); // envoie réponse au client
  2936. });
  2937.  
  2938.  
  2939. server.on("/longitude", HTTP_GET, [](AsyncWebServerRequest *request) // longitude de l'avion
  2940. {
  2941. int32_t longi1 = (int32_t) (lon_avion * 10000.0);
  2942.  
  2943. int32_to_array(longi1);
  2944. request->send_P(200, "text/plain", var_array32); // envoie réponse au client
  2945. });
  2946.  
  2947.  
  2948. server.on("/hauteur", HTTP_GET, [](AsyncWebServerRequest *request) // hauteur de l'avion / sol
  2949. {
  2950. int32_t haut1 = (int32_t) (hauteur_AAL * 10.0);
  2951.  
  2952. int32_to_array(haut1);
  2953. request->send_P(200, "text/plain", var_array32); // envoie réponse au client
  2954. });
  2955.  
  2956.  
  2957. server.on("/flags", HTTP_GET, [](AsyncWebServerRequest *request) // paramètres divers PFD -> ND & MCDU
  2958. {
  2959. argument_recu3 = request->arg("btMCDU"); // valeur reçue du module MCDU en tant qu'argument
  2960.  
  2961. v_bt_MCDU = argument_recu3.toInt();
  2962. flag_traiter_MCDU=1;
  2963.  
  2964. int32_to_array(flags); // valeur à envoyer
  2965. request->send_P(200, "text/plain", var_array32); // envoie réponse au client
  2966. });
  2967.  
  2968. server.on("/msg", HTTP_GET, [](AsyncWebServerRequest *request) // paramètres divers PFD -> ND & MCDU
  2969. {
  2970. string_to_array(msg_to_send); // valeur à envoyer
  2971. request->send_P(200, "text/plain", var_array32); // envoie réponse au client
  2972. msg_to_send="null";
  2973. });
  2974.  
  2975.  
  2976. server.on("/num_bali", HTTP_GET, [](AsyncWebServerRequest *request) // PFD -> MCDU
  2977. {
  2978. int32_t num1 = (int32_t) num_bali;
  2979. int32_to_array(num1);
  2980. request->send_P(200, "text/plain", var_array32); // envoie réponse au client
  2981. });
  2982.  
  2983. server.begin();
  2984.  
  2985.  
  2986. pinMode(bouton1, INPUT);
  2987. pinMode(bouton2, INPUT);
  2988.  
  2989. //pinMode(led1, OUTPUT);
  2990.  
  2991. pinMode(rot1a, INPUT_PULLUP);
  2992. pinMode(rot1b, INPUT_PULLUP);
  2993. pinMode(rot2a, INPUT_PULLUP);
  2994. pinMode(rot2b, INPUT_PULLUP);
  2995.  
  2996. attachInterrupt(rot1a, rotation1, RISING);
  2997. attachInterrupt(rot2a, rotation2, RISING);
  2998.  
  2999. TFT480.init();
  3000. TFT480.setRotation(3); // 0..3 à voir, suivant disposition
  3001. TFT480.fillScreen(TFT_BLACK);
  3002.  
  3003. init_SDcard();
  3004.  
  3005. init_sprites();
  3006.  
  3007. delay(100);
  3008.  
  3009.  
  3010.  
  3011. TFT480.setTextColor(NOIR, BLANC);
  3012.  
  3013. //TFT480.setFreeFont(FF19);
  3014.  
  3015. init_affi_HA();
  3016.  
  3017. delay(100);
  3018.  
  3019. //TFT480.fillRect(48, 0, 6, 100, 0xFFE0);
  3020.  
  3021. // TFT480.fillRect(0, 0, 479, 30, NOIR);
  3022. TFT480.setTextColor(BLANC, NOIR);
  3023. TFT480.setFreeFont(FF19);
  3024. String s1 = "PFD v";
  3025. s1+= version;
  3026. //TFT480.drawString(s1, 70, 3);
  3027.  
  3028. Ay_actu=120;
  3029. By_actu=120;
  3030.  
  3031. altitude_GPS =0;
  3032. vitesse =0;
  3033. roulis =0;
  3034. tangage =0;
  3035. cap=0;
  3036. vspeed=0; // vitesse verticale
  3037.  
  3038. //vor_frq=123500;
  3039.  
  3040. //vor_dst=1852*102; // 102km
  3041. //vor_actual_deg=45;
  3042. //vor_actual=45.0 * 100.0;
  3043. // affichages();
  3044.  
  3045. bouton1_etat = digitalRead(bouton1);
  3046. memo_bouton1_etat = bouton1_etat;
  3047.  
  3048. bouton2_etat = digitalRead(bouton2);
  3049. memo_bouton2_etat = bouton2_etat;
  3050. if (bouton2_etat==0)
  3051. {
  3052. mode_affi_hauteur = AAL;
  3053. affi_mode_affi_hauteur();
  3054. }
  3055. if (bouton2_etat==1)
  3056. {
  3057. mode_affi_hauteur = ASL;
  3058. affi_mode_affi_hauteur();
  3059. }
  3060.  
  3061. init_FG_bali();
  3062.  
  3063. //init_affi_autopilot();
  3064. //affi_indicateurs();
  3065.  
  3066. affi_distance_piste();
  3067.  
  3068. affi_Airport();
  3069.  
  3070. voyant_L.init(0,0,30,20);
  3071. voyant_L.caract1 ='L';
  3072. voyant_L.caract2 =' ';
  3073.  
  3074. voyant_G.init(35,0,30,20);
  3075. voyant_G.caract1 ='G';
  3076. voyant_G.caract2 =' ';
  3077.  
  3078. voyant_APP.init(70,0,30,20);
  3079. voyant_APP.caract1 ='A';
  3080. voyant_APP.caract2 ='P';
  3081.  
  3082. voyant_route.init(105,0,30,20);
  3083. voyant_route.caract1 ='G';
  3084. voyant_route.caract2 ='T';
  3085.  
  3086. voyant_RD.init(145,0,30,20);
  3087. voyant_RD.caract1 ='R';
  3088. voyant_RD.caract2 ='D';
  3089.  
  3090. voyant_ATT.init(177,0,15,20);
  3091. voyant_ATT.caract1 ='A';
  3092.  
  3093.  
  3094. init_Leds();
  3095.  
  3096. ////raz_bit(&flags, bit_atterrissage);
  3097. ////raz_bit(&flags, bit_FG_AP);
  3098. ////raz_bit(&flags, bit_autoland);
  3099. ////raz_bit(&flags, bit_route);
  3100. ////raz_bit(&flags, bit_nav_to_piste);
  3101. ////raz_bit(&flags, bit_nav_to_pt1);
  3102. ////raz_bit(&flags, bit_nav_to_ptAA);
  3103. ////raz_bit(&flags, bit_nav_to_ptBB);
  3104. ////raz_bit(&flags, bit_rudder_attero);
  3105. ////raz_bit(&flags, bit_decollage);
  3106.  
  3107. annule_tout();
  3108.  
  3109.  
  3110. //find_END_RWY_angl();// pour le 1er décollage, on ne repassera plus ici
  3111. //prepare_decollage();
  3112.  
  3113.  
  3114. //TFT480.fillRect(0, 0, 479, 319, BLEU); // pour test parties libres
  3115.  
  3116. }
  3117.  
  3118.  
  3119.  
  3120. uint8_t p1;
  3121.  
  3122. int32_t number = 0;
  3123.  
  3124.  
  3125. String s1;
  3126. String s2;
  3127.  
  3128.  
  3129. void acquisitions()
  3130. {
  3131. // cette fonction reçoit les données de Flightgear par la liaison USB, voir le fichier "hardware4.xml" pour le protocole
  3132.  
  3133. // Remarque : les données des autres modules (ND et SW) sont reçues par WiFi,
  3134. // voir les sous-fonctions ("server.on(...)") dans la fonction setup()
  3135.  
  3136. char buf[50];
  3137. int32_t valeur;
  3138. TFT480.setFreeFont(FM9);
  3139. TFT480.setTextColor(VERT, NOIR);
  3140.  
  3141. if(Serial.available() > 14) // 14
  3142. {
  3143. parametre="";
  3144. s1="";
  3145. char octet_in;
  3146.  
  3147. while(octet_in != '=')
  3148. {
  3149. octet_in = Serial.read();
  3150. if(octet_in != '=') {parametre += octet_in; }
  3151. }
  3152. while(octet_in != '\n')
  3153. {
  3154. octet_in = Serial.read();
  3155. if(octet_in != '\n') {s1 += octet_in; }
  3156. }
  3157.  
  3158.  
  3159. if(parametre == "joystick1" )
  3160. {
  3161. s1.toCharArray(buf, 50);
  3162. valeur = atol(buf);
  3163. joystick1 = (float)valeur / 1000.0;
  3164. data_ok |= 1; // positionne bit0
  3165. }
  3166.  
  3167.  
  3168. if(parametre == "alti" )
  3169. {
  3170. /*
  3171.  ALTITUDE GPS (et pas 'altimetre', volontairement, voir le fichier hardware4.xml)
  3172.  voir la ligne '<node>/instrumentation/gps/indicated-altitude-ft</node>'
  3173.  marre des QFE, QNH, AGL, ASFC, AMSL, STD...
  3174.  j'ai joué avec tout ça, mais finalement je décide d'utiliser le GPS,
  3175.  ce qui est contraire aux recommandations aéronautiques,
  3176.  sans doute parce que le jour où le GPS mondial viendrait à tomber en panne, c'est 275643 avions qui iraient se poser
  3177.  dans le Triangle des Bermudes.
  3178.  mais ici on est dans FlightGear, on ne risque rien !
  3179.  Et puis on a Galiléo et le système EGNOS développé à l'origine par le cnes puis sur la planète B612 à Toulouse (ESSP)...
  3180. */
  3181. s1.toCharArray(buf, 50);
  3182.  
  3183. valeur = atol(buf);
  3184. altitude_GPS_float = (float)valeur / 1000.0;
  3185. altitude_GPS = valeur/1000; // integer
  3186. hauteur_AAL = altitude_GPS - liste_bali[num_bali].altitude;
  3187.  
  3188. data_ok |= 1<<1; // positionne bit1
  3189. }
  3190.  
  3191. if(parametre == "gnd_elv" )
  3192. {
  3193. s1.toCharArray(buf, 50);
  3194. gnd_elv = atol(buf);
  3195. if (gnd_elv <0) {gnd_elv =0;}
  3196. data_ok |= 1<<2; // positionne bit2
  3197. }
  3198.  
  3199. if(parametre == "speed" )
  3200. {
  3201. s1.toCharArray(buf, 50);
  3202. vitesse = atol(buf);
  3203. data_ok |= 1<<3; // positionne bit3
  3204. }
  3205.  
  3206. if(parametre == "pitch" )
  3207. {
  3208. //char buf[50];
  3209. s1.toCharArray(buf, 50);
  3210. tangage = atol(buf);
  3211. data_ok |= 1<<4; // positionne bit4
  3212. }
  3213.  
  3214. if(parametre == "roll" )
  3215. {
  3216. s1.toCharArray(buf, 50);
  3217. roulis = atol(buf);
  3218. data_ok |= 1<<5; // positionne bit5
  3219. }
  3220.  
  3221.  
  3222.  
  3223. if(parametre == "heading" ) // /orientation/heading-deg = cap actuel de l'avion ; ne pas confondre avec HDG bug !
  3224. {
  3225. s1.toCharArray(buf, 50);
  3226. valeur = atol(buf);
  3227. cap= (float) valeur / 100.0;
  3228. data_ok |= 1<<6; // positionne bit6
  3229. }
  3230.  
  3231.  
  3232. if(parametre == "vspeed" )
  3233. {
  3234. s1.toCharArray(buf, 50);
  3235. vspeed = atol(buf);
  3236. data_ok |= 1<<7; // positionne bit7
  3237. }
  3238.  
  3239.  
  3240. if(parametre == "latitude" )
  3241. {
  3242. s1.toCharArray(buf, 50);
  3243. valeur = atol(buf);
  3244. lat_avion = (float)valeur / 100000.0;
  3245. data_ok |= 1<<8; // positionne bit8
  3246. }
  3247.  
  3248.  
  3249. if(parametre == "longitude" )
  3250. {
  3251. s1.toCharArray(buf, 50);
  3252. valeur = atol(buf);
  3253. lon_avion = (float)valeur / 100000.0;
  3254. data_ok |= 1<<9; // positionne bit9
  3255. }
  3256.  
  3257. nb_acqui=10; // erreur non permise !!!
  3258.  
  3259.  
  3260. }
  3261.  
  3262. delay(3); // 3 important sinon ne recevra pas la totalité des données (qui se fait en plusieurs passes)
  3263.  
  3264.  
  3265. ////// pour test
  3266. ////TFT480.drawString("data= ", 90, 50);
  3267. ////s2= (String) data_ok;
  3268. ////TFT480.fillRect(140,50, 50, 15, TFT_BLACK);
  3269. ////TFT480.drawString(s2, 150, 50);
  3270.  
  3271. }
  3272.  
  3273.  
  3274.  
  3275. void data_out()
  3276. {
  3277. // à destination de FlightGear par la liaison série USB
  3278. // voir le fichier "hardware4.xml" pour le protocole et les paramètres
  3279.  
  3280. Serial.print(hdg1); // consigne de Cap -> autopilot
  3281. Serial.print(',');
  3282.  
  3283. Serial.print(asel1); // consigne d'altitude -> autopilot
  3284. Serial.print(',');
  3285.