Le but de ce projet est de réaliser le MCP du B737 de PMDG. Il est envisageable dans le cadre d’améliorations futures d’inclure un mode qui le rendrai fonctionnel  avec la version de base de Flight Simulator.

Pour ce projet le choix s’est porté sur la carte Arduino Mega dont le rôle principal sera de dialoguer avec l’ordinateur, de récupérer les différentes commandes et d’afficher les valeurs numériques des paramètres de vols.

Les boutons poussoir, les encodeurs, et les interrupteurs seront directement branchés sur les entrées numériques de l’Arduino.

De quoi aura-t-on besoin?

Cinq boutons de réglage :   

                                                                   codeur alp 1                                   

  • L’altitude (ALT) ;
  • Le bouton course (CRS) ;
  • La vitesse (SPD) ;
  • Le cap (HDG) ;
  • Le taux ascensionnel (V/S).

Pour cette fonction on peut utiliser des potentiomètres  multi tours. Mais ceux-ci présentent  plusieurs inconvénients. Le fait d’avoir un nombre de tours limité pourrait poser problème à la mise sous tension  notamment pendant la phase d’initialisation ; de plus ils sont chers pour l’utilisation qu’on veut en faire.

Cela nous amène naturellement à choisir des codeurs incrémentaux. Il existe plusieurs types d’encodeurs, classés selon leur signal de sortie ou de leur mode de fonctionnement. Nous utiliserons des encodeurs rotatifs incrémentaux bon marché cela devrait suffire, même si ceux-ci sont sujet à des rebonds qui pourraient entraîner des erreurs de fonctionnement. Mais ce défaut peut être atténué par des corrections logicielles.

 

Trois interrupteurs à levier pour commander :          inter levier

  • L’armement des gaz automatique(AT/ARM) ;
  • Le directeur de vol (FD) ;
  • La mise en/hors service du pilote automatique (AP Dis).

Ce type d’interrupteur est très courant et bon marché dans les enseignes de vente de composants électroniques.

 

Des boutons poussoir momentanés pour les commandes de vol :

                                                                    bouton poussoir 2

  • bouton N1
  • bouton LVL/Chg
  • bouton SPD
  • bouton LNAV
  • bouton VNAV
  • bouton HDG Sel
  • bouton Vor/Loc
  • bouton APP
  • bouton ALT/HLD
  • bouton V/S
  • bouton CMDA
  • bouton CWSA
  • bouton CMDB
  • bouton CWSB

La signification des fonctions de tous ces boutons se trouve dans le manuel qui accompagne l’add-on PMDG.

 

On aura aussi besoin d’afficher les paramètres de vol. Pour cela on utilisera des afficheurs sept segments à LED :

                                                           afficheur4seg

  • La vitesse (SPD) sera affichée sur 4 digits ;
  • Le cap (HDG) sera affichée sur 3 digits ;
  • La course (CRS) sur 3 digits ;
  • L’altitude (ALT)sur 5 digits ;
  • Le taux ascensionnel (V/S) sur 5 digits.

 

L’état des boutons et interrupteurs actionnés sera indiqué par différentes LED. On aura seize indicateurs :

  • AT/Arm
  • FD
  • N1
  • Speed
  • LVL Chg
  • VNAV
  • LNAV
  • HDG Sel
  • Vor/Loc
  • APP
  • ALT/HLD
  • V/S
  • CMDA
  • CWSA
  • CMDB
  • CWSB

En outre on aura aussi besoin d’une alimentation +5V.

Certains boutons et afficheurs ne font pas partie de notre MCP pour l’instant : Le CRS du Copilote,  les boutons poussoirs C/O et SPD INTV. Leur absence ne gênera pas les essais simples qu’on aura à réaliser pour tester le MCP.

 

Le montage

Les interrupteurs, boutons poussoirs et encodeurs seront connectés directement sur les ports numériques de la carte Arduino. Les broches 0 à 9 et 22 à 42 serviront à cet effet.  Il faut juste noter que pour la programmation on fera appel aux résistances de « Pull Up » de la carte Arduino.

Quant aux afficheurs et LED indicatrices, ont utilisera pour gagner en nombre de broches disponibles sur la carte, un circuit intégré le MAX7219. Ce composant présente l’avantage d’être commandé par un bus série (SPI), ce qui offre la possibilité de «brancher en chaîne » plusieurs MAX7219. On en utilisera 4 de ces circuits.

Les connexions côté Arduino

 

arduino mega fsx

 

Les deux sorties A et B des encodeurs sont reliées au connecteur J3, tant dis que les boutons poussoirs et interrupteurs sont reliés à J1.

Schéma de l'affichage

 

afficheurs max7219

 

Le connecteur J1 sera connecté au connecteur J2 de la carte Arduino. Les sorties restantes du troisième MAX7219, peuvent servir à alimenter des indicateurs, avec 3 digits de disponibles on a la possibilité de piloter 24 LED. Pour ma part je me suis infligé la peine de rajouter un MAX7219 exclusivement réservé aux LED, sachant que ce n’est  pas une version définitive du projet; en tout cas il sera amené à évoluer.

 

Réalisation

Pour réaliser le montage d'essai, nous avons utilisé une carte de prototype rapide, sur laquelle les supports des composants boutons poussoirs et LED ont été soudés ;  les liaisons sont faites par des fils rigides sur la face  pastillée, et quelques fils souples ont été ajoutés pour compléter le reste de connexions.

 

Côté composants

 

proto mcp composants1

 

Côté soudure

 

proto mcp cuivre1

 

Pour les liaisons avec la carte Arduino, nous avons opté pour des connecteurs pour câbles plats ; cette solution nous a semblée intéressante étant donné le nombre de fils nécessaires. Ce qui au final donne le résultat ci-après :

 

connectiques arduino fsx

 

Ce n’est pas si mal que ça pour un prototype réalisé uniquement pour des essais.

 

Afin de rendre l'ensemble rigide, la plaque a été vissée sur un support en plexiglas. Les boutons et certains composants récupérés  de divers dispositifs électroniques ont été réutilisés.  Au final on a la disposition suivante:

proto mcp final1

 

Programmation

Pour contrôler ou commander divers composants (interrupteurs, capteurs, afficheurs,...) avec Arduino, il faut se rendre  sur le site arduino.cc;  on peut y trouver grand nombre d’exemples.  Sur ce même site on a téléchargé la librairie Ledcontrol, qui permet de piloter les circuits MAX7219, pour l’affichage 7 segments.

Pour réaliser les programmes de tests, je me suis inspiré du formidable article de Benoît Campeau sur l'utilisation de Link2fs et Arduino. Le lien de son site se trouve dans l'article "Motivation du projet Flight"  (Merci pour ce grand boulot).

Pour lire ou écrire des variables dans Flight Simulator, on a besoin d'une application qui récupère ces variables , puis les envoie sur la carte Arduino. Depuis quelques années, Peter Dowson a développé une application très utilisée par la communauté nommée FSUIPC, aux innombrables fonctionnalités qu'on n'énumérera pas ici. Pour avoir plus de renseignements sur cette application, il faut se rendre sur son site, cité lui aussi dans l’article « Motivation du projet Flight » de ce site. 

Jim a quant à lui consacré 10 ans de boulot pour mettre au point Link2fs particulièrement dédiée aux cartes Arduino. Cette application simplifie énormément le travail de récupération des variables depuis FSUIPC; un grand avantage c'est que la configuration se fait par interface graphique, nul besoin d'être programmeur pour l'utiliser. Pour avoir plus de renseignements, aller sur l'article "Motivation du projet Flight" de ce site pour trouver son lien, ou alors on peut faire une recherche directe dans Google avec le mot clé Link2fs.  Une possibilité très importante de Link2fs est qu’il est capable de gérer plusieurs cartes Arduino.

Pour les essais du MCP, on aura aussi besion des ressources suivantes:

  • FSUIPC
  • Link2fs (Link2fs_Multi_FSX_v6f : Expert Version)
  • Sans oublier l'IDE de la carte Arduino
  • A noter aussi que le PMDG 737NGX SDK doit être installé.

La partie du travail qui reste à faire consistera au développement du micro logiciel de la carte Arduino ; ce sketch a pour rôle de récupérer les données présentes sur le port USB, de les traiter, les afficher ou encore d'envoyer les commandes des boutons sous forme de données formatées sur le même port USB.

Dans la version de base de Flight Simulator, les variables sont appelées  « Offsets ». Ces « Offsets » peuvent indifféremment être lus ou écrit. 

Ce mode de gestion est différent avec le B737 de PMDG.  Les variables sont scindées en deux catégories; les variables de lecture et les variables d'écriture.

Les variables de lecture, en d'autres termes les indicateurs, sont appelés les Offsets et les variables d'écriture,  qu'on peut qualifier de commandes,  sont les Events.

La liste de ces variables se trouve dans le fichier d'entête "PMDG_NGX_SDK.h" qu'on peut retrouver dans le PMDG 737NGX SDK.

Pour lire les données du PMDG 737NGX avec FSUIPC, le concepteur de l'add-on PMDG recommande d'aller sur le répertoire:

PMDG\PMDG 737 NGX\;  puis éditer le ficheir 737NGX_Options.ini.

Ajouter à la fin de ce fichier ou repérer la section  [SDK],  puis EnableDataBroadcast = 1

Une fois les modifications faites, redémarrer Flight et le B737 de PMDG.

Le format d'affichage des données ou des Offsets établi par Link2fs, est formé d'un identificateur composé d' un "#", suivi d' une lettre (a, b, c, d,....par exemple).  Le format des commandes ou des Events est formé soit d'un "Y" ou un "ZZ" ou un "#", suivit d'une commande.  Tout ceci a donc été pris en compte dans le programme de la carte Arduino.

Dans PMDG pour changer un paramètre comme le cap par exemple, il est possible soit d'envoyer des commandes qui imitent la souris, soit de changer directement la valeur affichée. Tous les détails sur ce type de fonctionnement, se trouvent dans le fichier PMDG_NGX_SDK.h.  Pour notre part, nous avons choisi dans le sketch Arduino d'imiter les clics de la souris.

Les tests

Dans un premier temps on va commencer par lancer Flight Simulator, puis on choisit le type d'appareil : le B737 NGX de PMDG, après avoir lancé un vol par défaut, nous avons mis le jeu en pause.  

Puis  lancé Link2fs;  un clic sur le bouton Expert, nous permet de choisir l'onglet FSUIPC(1), dans ce menu on configure tous les offsets dont nous avions besoins.  Pour finir un clic sur le bouton de connexion à la carte, et nous obtenons les deux exemples de captures d'écran suivants:

 

Pour Link2fs

capture linktofs1 

 

En comparaison voici ce que le tableau de bord affiche :

 

affichage b737 pmdg1

 

On constate pour ce test que les données du MCP du PMDG 737NGX, sont bien transmises, à Link2fs.   Nous avons aussi réalisé quelques tests en vol, et on constate bien que les paramètres changent en même temps sur Link2fs et sur le MCP.

En somme cela prouve que la carte d’essai  et l’Arduino, dialoguent bien avec Flight Simulator.

Pour ce premier test, nous avons eu des problèmes avec l'affichage de l'altitude, même en changeant de type de variable. Link2fs n'a pas prévu un affichage complet des variables de type « int »; conséquence l'altitude s'affiche sans problème jusqu'à 37000 pieds; mais au delà ce sont des nombres négatifs  qui apparaissent. Ceci est justifié, car nous avons comme type de variable, le type « Short ». Ce problème a été finalement résolu à la fois dans le sketch Arduino en apportant de petites modifications au programme de départ et dans la configuration Link2fs en codant l'altitude sur deux variables d'offset chacune codées sur 1 octet.

A présent que les variables sont lues correctement, le deuxième test consiste, à envoyer des commandes à partir des boutons poussoirs et des Switch vers Flight. Tous  fonctionnent correctement.

En poursuivant les tests voici ce que donne le MCP avec l’avion en plein vol :

 

affichage mcp envol1

 

On constate juste des problèmes de différence de luminosité sur les afficheurs, cela est dû au fait que ces composants ont été récupérés sur diverses cartes électroniques récyclées, et par conséquent ne proviennent pas du même fabricant.

Pour un essai complet on va effectuer le vol LONDRE Heathrow vers BEAUVAIS Tillé.

 

Il reste encore beaucoup de choses à faire sur ce MCP.