X-plane : Mise en place d'instruments de bord sur tablette/SmartPhone Android

Dans cet article, je vous propose d'installer et d'utiliser le programme de Ville Ranki pour déporter des instruments de cockpit sur une tablette android.

Mais d'abord, voici un aperçu des instruments qui sont disponibles  :

Installation :

plugin Xplane :

Suivant le type de votre système d'exploitation sur lequel tourne Xplane, télécharger le plugin.
depuis gitHub ExtPlane-Panel dans la section téléchargement ou directement ici :

linux 64 bit

 Ext-Plane_plugin_lin64.xpl

MacOS

 Ext-Plane_plugin_mac64.xpl

Windows 64 bit

 Ext-Plane_plugin_win64.xpl



puis ajouter le fichier  Ext-Plane_plugin_[os].xpl dans le répertoire Resources/Plugins d'xplane.

Pour tester si le plugin fonctionne, lancer xplane. Ensuite créer une connexion telnet sur le port 51000. Exemple, depuis le même ordi qui exécute xplane:
telnet localhost 51000.
doit afficher
EXTPLANE 1

pour sortir de telnet, taper
disconnect

Tablette Android :

une fois le plugin installé, il ne reste plus qu'à télécharger le programme sur votre tablette ou smartphone. Malheureusement, je ne l'ai pas mis sur le GooglePlay (ou playStore) car c'est une option payante pour le développeur.
Donc pour installer le programme, essayez de le télécharger directement en cliquant sur le lien suivant :
android-build-debug.apk

Si tout se passe bien, le système Androïd doit vous demander votre autorisation pour installer le programme, sinon aller dans les paramètres du système et vérifier que androïd autorise l'installation de programme non signé.

Une fois le programme 'android-build-debug.apk' installé sur votre appareil android, télécharger le fichier 'ExtPlane-Panel-Default.ini' dans le répertoire 'Mes Documents'. Ce fichier sert à enregistrer la configuration du Panel (tableau de bord). Ainsi, en démarrant programme Panel, vous aurez quelques instruments affichés.
Si vous ne téléchargez pas ce fichier, le programme en créera un 'vide'. Vous devrez alors aller dans le menu pour ajouter des instruments.

Paramétrage de l'application Androïd

remarque préalable : l'application ne se redimensionne pas automatiquement en fonction de la résolution de l'écran. Ainsi, vous serez parfois obligé de jongler avec l'orientation de l'écran pour afficher le bas du menu ou la partie droite du Panel.

Le menu de l'appli :

'cliquer' dans le coin gauche pour afficher le menu :

Dans le Menu, cliquer sur 'App Settings'

Renseigner l'adresse IP de l'ordinateur exécutant Xplane. Garder 51000 comme numéro de port :

Ajout/modification/suppression d'un instrument :

Passer en mode édition en cochant 'Edit Panel' dans le menu principal :

modification :

Double clic sur l'instrument permet d'afficher ses propriétés (Nous détaillerons plus tard certaines d'entre elles).

Ajout nouveau instrument :
cliquer sur add-itemet choisir l'instrument dans la liste puis OK.

Sauvegarde de la configuration :
Pour enregistrer les modifications, cliquer sur 'save profile' dans le menu principal. Vous pouvez également sauvegarder la config dans un nouveau fichier 'Save Profile as ...' et l'appeler par la suite en faisant 'load profile'.

Les propriétés des instruments :
Ces propriétés sont propres à chaque instrument. (hormis la rotation, la position dessus/dessous (Z-value) et la taille de la police (Relative font size).

Par exemple, prenons les propriété de l'instrument 'generic_little_gauge' :
Cet instrument est dit "générique" car il permet de récupérer n'importe quel indicateur xplane et de l'afficher sous forme de cadran circulaire.
Pour définir l'indicateur à afficher, il faut indiquer dans la propriété 'dataRef string' de l'instrument la dataref correspondant à l'indicateur. (dans l'exemple ici, la température en degré de la sortie des gaz d'échappement EGT).

Pour savoir quelle 'dataRef String' mettre, il faut aller sur la page web
http://www.xsquawkbox.net/xpsdk/docs/DataRefs.html
et chercher dans le fichier la ligne correspondante au capteur souhaité.
Je vous recommande de chercher dans le chapitre 'sim/cockpit2'

Une fois la dataref trouvée, renseigner la dans la propriété Dataref String' en mettant le chemin complet.
exemple : sim/cockpit2/engine/indicators/EGT_deg_C

Enfin, cocher la propriété 'datarefs values are in table' si les valeurs sont dans un tableau indicé et renseigner le numéro d'indice du tableau ( propriété 'selected index for value'). Souvent l'indice correspond au numéro du capteur. Exemple 0: réservoir principal, 1: réservoir aile gauche, etc...)

Pour savoir si les valeurs sont sous forme de tableau, il suffit de regarder dans le fichier dataRefs.html si le 'type' est suivi de crochés dans lesquels le nombre d'index du tableau est indiqué.

Donc revenons à nos propriétés de l'instrument générique.

• 'Designation line 1/2' : texte affiché au milieu haut du cadran
• 'Designation line 2/2' : texte affiché au milieu bas du cadran
• 'DataRef String' : chemin et nom de l'indicateur xplane (cf dataRefs.html)
• 'accuracy' : Précision de l'indicateur (en gros une valeur sera considérée à rafraîchir dans l'indicateur si la donnée a diminué ou augmenté d'une valeur supérieure à la précision indiquée).
• 'Datarefs values are in table' : indique que la valeur est a prendre dans un tableau.
• 'selected index for value' : si la valeur est dans un tableau, alors dans quel numéro de case est elle. La première case ayant l'indice zéro.
• 'number of big graduations' : nombre de graduations principales avec indication des chiffres
• 'number of thin graduations' : nombre de graduations intermédiaires
• 'display values' : afficher les chiffres.
• 'display into logarithlic values' : échelle logarithmique

arc vert

• 'green arc value begins at' : l'arc vert commence à la valeur ...
• 'green arc value ends at' : l'arc vert finit à la valeur ...
• 'green arc thickness' : épaisseur du trait

arc jaune

• idem

arc rouge

• idem

Voici par exemple ce que donne trois configurations différentes d'instruments génériques afin d'afficher les valeurs moteurs de :
La température de sortie d'échappement, La pression de l'huile et la température de l'huile :

Cette configuration est disponible dans le fichier 'ExtPlane-Panel-Default.ini' donné en exemple.

Il ne me reste plus qu'à vous souhaiter une bonne installation, configuration, et surtout un bon vol avec votre tablette écran supplémentaire.

( OOPS, oui je sais, j'ai laissé mes freins en positions serrés ... )

Instruments déportés, suite de l'étude ...

Dans ce court article, je vais vous présenter mon retour d'expérience  sur l'utilisation et l'essai d'adaptation du programme FlightSimPanel de  Davide Alberto Molin . Puis, j'exposerai d'autres possibilités de mise en place d'instruments déportés pour Xplane.

Retour d'expérience sur FlightSimPanel :

En premier lieu, il est a noter la bonne qualité du code du programme dans sa structure et son organisation. Par contre, ma faible maîtrise du langage NodeJs ne m'a pas permis d'adapter le programme afin de créer des pages web de tableaux d'instruments personnalisés. Le but étant de pouvoir se connecter par navigateur web à la page d'instruments voulus. Une pour les instruments de pilotages, une pour les paramètres moteurs et une autre pour les appareils de radio communications et navigations. En ce qui concerne le graphisme des instruments, je trouve qu'ils sont très bien réussis et cela donne vraiment envie de pouvoir les utiliser.
Au niveau de la configuration de xplane, il faut connaître quelle sortie activer dans le menu configuration réseau/datas. Pour cela, jeter un œil dans l'arborescence des fichiers sources du programme peut nous aider. En effet, il suffit de noter les numéros qui se trouvent à l'emplacement (src/services/datarefs/) afin de savoir quels numéros cocher dans xplane. Il est à noter que le fait d'utiliser ces sorties natives udp peut poser problème le jour où une nouvelle version d'xplane modifiera l'affectation de ces numéros (apparemment, c'est déjà arrivé ...).

Maintenant, venons en à l'utilisation en pratique. Après avoir lancé le serveur nodeJs, j'ai pu noter de temps en temps quelques ralentissement d'Xplane. J'ai utilisé une tablette sous android pour me connecter en wifi sur le serveur nodeJs. J'ai effectué un tour de piste de LFRB en condition VFR.
A la mise plein gazes pour le décollage, le compteur de vitesse se met à afficher les vitesses mais de manière un peu saccadée ce qui n'est pas très facile pour juger de la vitesse de rotation. En fait, le temps de latence pour chaque instrument est d'environ 1/5 de secondes ce qui n'est pas très confortable pour le pilotage en VFR et qui complique sérieusement les choses en IFR (tenu du glide de l'ILS par exemple).
Une autre critique est que l'on ne peut pas placer les instrument où l'on veut sur la page web ni même sélectionner ceux que l'on veut voir ou ne pas voir. Ceci est assez frustrant. Et comme mes connaissances en nodeJs sont limitées, j'ai échoué à vouloir implémenter ces comportements dans le codes sources de l'application serveur.

Autres solutions possibles :

pour pouvoir déporter les instruments sur un autre écran, j'ai encore dans ma besace deux autres solutions.

Utiliser une autre instance d'xplane :

C'est ce que j'utilise déjà pour afficher la vue de gauche dans un deuxième écran. Dans mon cas, la deuxième instance d'xplane s'exécute sur le même ordinateur que la première et utilise le deuxième écran qui correspond à mon deuxième espace bureau.
Cependant, pour pouvoir augmenter le nombre d'écran, il faut plutôt utiliser un autre ordi.
la deuxième instance d'xplane doit être configurée comme esclave de la première. Puis, ses paramètres d'affichage changés au niveau du décalage (haut,bas, droite, gauche) afin d'afficher la partie voulue. En l'occurrence, la partie de cockpit.

Avantage :
 . tout est natif, pas besoin de trouver des programmes complémentaires.
 . les instruments à afficher sont ceux déjà créés dans xplane.
 . un réagencement de la positions des instruments est possible via l'utilitaire planeMaker.
Inconvénients :
 . disposer du matériels (ordi , écran, réseau ethernet).
 . encombrement de l'espace de travail dû à ce surcroît de matériel.
 . au niveau de la licence xplane, il faut "légalement" une licence par Instance d'xplane.

Je prévois de rédiger un article plus détaillé pour expliquer la mise en place de cette solution.

Utiliser le programme ExtPlane-Panel.

J'ai découvert depuis quelques semaines le projet de Ville Ranki sur github : https://github.com/vranki/ExtPlane-Panel/blob/master/README.md
Le projet est composé de deux éléments: un plugin pour xplane et un programme client pour afficher les instruments. Le plugin xplane se charge de relayer les données de type 'datarefs' demandées par 'souscription' par les instruments du client. Une chose intéressante est que ont peut également, via le mécanisme des datarefs, effectuer des actions dans xplane. Ainsi, les instruments peuvent également avoir un rôle actif (changer le QNH de l'altimètre par exemple...)
Le programme client est écrit en C++ avec la librairie graphique Qt.

J'ai ainsi pu compiler le programme pour en faire une application Android et l'installer sur une tablette chinoise.
Pour ce faire, il a fallut installer les éléments suivants :
 . Qt et QtCreator :https://www.qt.io/download-open-source/
 . SDK (System Developpment Kit) de Android : http://developer.android.com/sdk/index.html
 . NDK de Qt http://developer.android.com/tools/sdk/ndk/index.html
(Voir le tutos : http://blog.developpez.com/gpu/?p=522 )

A noter : plutôt que d'utiliser Ant, j'ai coché l'option "utiliser gradle" au niveau des options de compilation/déploiement de QtCreator parce que sinon, j'avais une erreur lors de la demande de transfert et d'exécution du programme sur le terminal Android.

Voici en image le résultat du déploiement :

ExtPlane-panel on Android device

Mais encore ...

En entrant dans le code source du programme,  avec quelques connaissance de la POO, de C++ et de Qt, il devient assez facile de fabriquer d'autres instruments. Pour cela, il faut ajouter ses propres classes dans le répertoire 'panelitems' en dérivant la classe 'panelitem'. 

J'ai par exemple créer un indicateur de pression d'essence ressemblant à celui proposé sur le DR400. Le code se trouve ici : engine_fuel_p.h et là engine_fuel_p.cpp. J'ai modifié le projet initial en y ajoutant la définition de ressources images et les images dans le répertoire du même nom.
Pour essayer tout cela, le mieux est de 'git-cloner' mon dépôt ExtPlane-Panel issu du fork du projet de Ville Ranki (depuis, Ville ranki a ajouté ces nouveaux instruments dans son projet, donc git-cloner son dépôt ExtPlane-Panel). Ne pas oublier de 'git-cloner' également dans le même répertoire racine le dépôt ExtPlane du plugin. D'une part QtCreator en a besoin pour la compilation, le projet "ExtPlane-Panel" étant lié à celui du plugin "ExtPlane", et d'autre part il faudra bien utiliser ce plugin dans Xplane.

voici ce que donne le widget récemment créé :

Le prochain article explique de façon simple l'installation et le paramétrage de ExtPlane-Panel.

FlightSimPanels, des boutons de commandes c'est bien; mais avec des instruments de bord, c'est encore mieux !

FlightSimPanel :

Ca y est, j'ai chopé la cockpitose. Pas sûr que j'en guérisse.
Effectivement, en utilisant mon premier prototype (cf article cockpit-maison-pour-xplane ), il m'est vite devenu désagréable de devoir regarder deux tableaux de bord en même temps; le virtuel et le réel. En baissant dans xplane le tableau de bord, je me suis dit : OK, c'est ça qu'il me faut.

Ainsi, je me suis en mis en tête de trouver une solution 'cheap and fun' consistant à déporter les instruments (badin, vario, altimètre, etc ) sur un autre écran, ou une tablette, que je fixerai au milieu du cockpit réel.

Pour déporter sur un autre écran les instruments d'Xplane, il existe à ma connaissance deux solutions possible. Soit créer un tableau de bord Xplane et l'affiché avec le logiciel sur un autre écran. Soit utiliser FlightSimPanel.


Grâce à la discussion  "Déporter les instruments de vol sur un autre écran" et de l'expérience de Daniel_L du forum d'x-plane, j'ai pu constater qu'il existe un projet nommé FlightSimPanel.

Flight Simulator Panels, conçu par Davide Alberto Molin est basé sur la technologie node.js. Cette technologie permet de créer des applications 'temps réel' qui peuvent être directement jouées depuis un navigateur internet. Oui, vous avez bien lu; tout ce qui possède un écran et est connecté à un réseau peut donc faire office d'affichage d'instrument pour xplane.

Et bien allons-y !

Pré-requis : en ce qui me concerne, je suis sur un ordinateur ayant comme système d'exploitation Linux basé sur la distribution Ubuntu 14.04 LTS. Pour les autres OS grand public tels que Windows ou Mac, la solution devrait également fonctionner.
Avoir installer le client 'Git' pour télécharger les sources du programme avec l'instruction éponyme.

Installation de NodeJs

Il nous faut donc installer NodeJS. pour cela, il faut suivre les instructions de la documentation fournie sur le site : https://github.com/nodesource/distributions. (pour Windows ou Mac, aller plutôt là : http://nodejs.org/download/ )

Les instructions consistent en :
- ajouter un nouveau dépôt dans les dépôts de paquets Apt pour avoir la 'version' la plus récente de nodeJs.
- installer nodeJs via le gestionnaire de paquets 'aptitude'.
- installer le gestionnaire de paquets nodesJS : NPM. noter que 'npm' est déjà présent en installant nodeJs mais il faut absolument le mettre à jour en faisant la commande : sudo npm install npm -g.

En ce qui me concerne l'installation s'est bien passée.
voici un résumé des commandes shell :

curl -sL https://deb.nodesource.com/setup | sudo bash -
sudo aptitude update
sudo apt-get install nodejs
sudo npm install npm -g

Installation de FlightSimPanel :

Il faut 'télécharger' les sources du programme de Davide Alberto Molin. Pour comprendre ce que l'on fait, lire également la documentation : https://github.com/dmolin/flightSimPanels.
Ainsi, créons un répertoire 'FlightSimPanel' pour y mettre les sources.

mkdir flightSimPanels
cd flightSimPanels
git clone https://github.com/dmolin/flightSimPanels.git

Ensuite, allons dans le répertoire flightsimPanel créé par git et compilons à la sauce NodeJs le programme :

cd flightSimPanels
npm install

puis installons le module nodeJs requis par FlightSimPanel :

sudo npm install -g grunt-cli

Paramétrage réseau dans Xplane :

Lancer Xplane, puis aller dans le menu : 'Settings' -> 'Data Input/Output'
Dans l'onglet  'réseau' : adresse localhost : 127.0.0.1, port 49100

Dans l'onglet 'Data', cocher les première colonnes des items x,x,x,x,x,x :

Lancement du programme FlightSimPanel:

Et maintenant, y'a plus qu'à voir si cela fonctionne. Ouvrir un terminal et se placer dans le répertoire de flightSimPanel :

cd /...../...../...../FlightSimPanel

puis taper

grunt

ou bien, si l'on veut se passer de grunt ( car il ne fait que vérifier le code avec jshint, ..enfin d'après ce que j'ai cru comprendre en lisant le fichier Gruntfile.js ), taper

nodejs ./src/server

Une fois le nodejs lancé et le serveur en route, il ne reste plus qu'a se connecter au serveur depuis n'importe quel appareil en tapant l'adresse suivit par le numéro de port d'écoute (ici le port 3000).
Pour connaitre l'adresse de votre serveur, regarder ce que retourne la commande ifconfig (ou ipcondif sous windows). Ou encore l'indication fourni par xplane visible dans 'Settings' -> 'Data Input/Output'.


Exemple de connexion depuis le même poste hébergeant le serveur nodejs   :  http://localhost:3000/

Pour aller plus loin :

petit tour dans les arcanes du code source de FlightSimPanel ....

Dans les sources du programme fourni par Davide Alberto Molin. le repertoire "datarefs" nous fournis une information importante concernant les options à mettre en oeuvre dans Xplane au niveau 'Settings' -> 'Data Input/Output', onglet 'data'. En effet, dans ce répertoire 'datarefs' se trouvent des répertoires nommés par des numéros qui correspondent aux numéros de ligne des 'data' à cocher dans xplane.

Le "point d'entrée" du programme est le fichier 'server.js' situé à la racine du répertoire source 'src'. Dans ce fichier, l'on retrouve le numéro de port sur lequel se connecter pour recevoir les données d'xplane, à savoir dans notre cas le port numéro 49100. Et aussi le port sur lequel les clients web viennent se connecter, à savoir le port numéro 3000. Donc si ces numéros de ports ne conviennent pas, libre à chacun de nous de les changer.

Taille des instruments : pour gérer la taille des instruments, il faut modifier le fichier src/public/stylesheets.
dans la section '.gauge', modifier les valeurs des pourcentages affectées aux paramètres 'width', 'min-width', ...

exemple:
.gauge {
    float: left;
    /*
    width: 310px;
    height: 310px;
    margin-right: 20px;
    */
    width: 20%;
    min-width: 100px;
    margin-right: 1%;
    padding: 1px;
    position: relative;
    overflow: hidden;
}
(remarque: le texte placé entre les marques /* et */ n'a pas d'influence sur le programme puisque ces marques sont des marques de commentaire.)

Idée pour la suite :

Ce serait très intéressant de pouvoir créer 3 pages web.
Une page web pour les instruments de pilotage (vitesse, horizon, alti, bille, vario).
Une page web pour les instruments de navigation (VOR, ADF, affichage freq radio et nav)
Une page pour les paramètres moteur (compte tour, pression essence, pression huile, température...)

Ainsi, avec trois périphériques (tablette, smartphone, ...) on aurait tous les instruments à disposition, regrouper par famille et les écrans pourraient être placer où bon nous semble.
Bref va falloir se retrousser les manches....

Cockpit maison pour Xplane

Intro

Utilisateur de Xplane depuis plus de 3 ans maintenant, je me suis dit qu'il était temps de bricoler à l'aide de quelques interrupteurs, de la colle et des clous, un tableau de bord me permettant d'ajouter des commandes supplémentaires au joystick actuellement utilisé le tout pour moins de 100 euros.

Choix techniques :

Seulement les clous ne suffisent pas, il faut également un peu d'électronique et d'informatique. Mais rien de bien méchant à posteriori. Effectivement, un petit tour de piste du web m'a permis  de découvrir que le micro-contrôleur Teensy permet facilement d'être programmé comme périphérique USB. Pour mon application, j'ai choisi le Teensy++2.0 car il possède une quarantaine d'entrées/sorties. Le site constructeur est le suivant : https://www.pjrc.com/teensy/.
Pour se procurer ce bidule en France, j'ai trouvé pour l'instant qu'un seul revendeur : http://www.lextronic.fr/ . J'ai jusqu'à présent passé deux commandes chez eux et je n'ai pas eu à m'en plaindre. Dommage toutefois que seule la poste (colissimo) soit proposée pour les livraisons. Un service de relais colis m'aurait permis de gagner 4 à 5 jours de délais plutôt que d'attendre le samedi matin pour pouvoir enfin retirer mon colis à la poste...

Afin de mieux appréhender ce qu'il est possible de faire, un tour d'horizon sur des projets existants nous montre qu'à priori on doit même pouvoir faire le café... :

• switch panel (site en Allemand)
• Radio Module for X-Plane
• Garmin G1000 Emulator
• X-Plane Autopilot Panel
• ...

Cet excellent blog : https://simelectronics.wordpress.com/
 
et bien sûr les forums sont une source immense de renseignements :

• forum x-plane.org (Low-cost hardware using Teensy USB boards) 
• http://www.x-plane.fr/thread53808.html
• ...

Menuiserie :

Bref, après être rassuré sur la faisabilité du projet, nous pouvons commencer à scier quelques planches. Mais tout d'abord, un petit plan :

Pour la menuiserie, des tasseaux de 13x38 feront le cadre et de l'aglo 'medium' de 3mm d'épaisseur sera parfait pour les faces.

Après quelques réflexions, voici les commandes choisies qui occuperont ce tableau de bord :

Électronique et câblage :

Maintenant, un peu de câblage nous attend. Faites chauffer le fer à souder...

changement de fréquence radio :

Pour commencer, on va s'occuper de la partie des codeurs rotatifs (ceux qui serviront à changer les fréquences de la radio). Pour cela, j'ai opté pour ce type de codeurs : P23054-encodeur-lumineux-a-rotation-infini dont les plans se trouvent là.
Ces codeurs sont rétro-éclairés par deux leds internes verte et rouge. J'ai choisi de prendre la couleur verte pour la partie radio et la couleur rouge pour la partie navigation. Pour le codage, il y a deux manières possibles: soit on utilise des bascules D (composant CMOS 40xx) pour le décodage du sens de rotation, soit un laisse le soin au micro-contrôleur Teensy de gérer cela par programme. Pour l'instant, nous choisirons la deuxième approche.

Le schéma de câblage pour les 4 encodeurs se composent de 4 résistances pour l'alimentation des leds intégrés. A noter que les valeurs de résistances sont plus importantes pour les leds vertes afin de réduire leur luminosité par rapport aux rouges.

et voilà le résultat :

Pour tester nos leds, on peut alimenter le montage en 5 volts :

Platine support pour le micro-contrôleur Teensy :

Nous allons ajouter au teensy deux barrettes de connections :

Puis préparer sur un circuit imprimé "prototypage" la réception des fils et du connecteur teensy :

A noter que plutôt que d'opter pour un circuit imprimé, une autre solution aurait consisté à utiliser une nappe de 20 fils avec un connecteur femelle monté directement dessus.

Câblage :

En fouillant dans mes cartons, j'ai trouvé pour les fils un vieux câbles en nappe ainsi qu'un autre avec un connecteur 8 points très intéressant pour connecter les broches internes du Teensy. Ce dernier câble servait à raccorder 2 ports USB d'une carte mère vers la face avant d'un PC.

 A remarquer les 8 pins soudées en plus pour le raccordement de ce connecteur sur le Teensy ainsi que 2 autres pins pour déporter le bouton Reset du teensy.

Au départ, je n'avais pas prévu de déporter le bouton Reset. Cependant ce déport s’avérera pratique car ce bouton doit être utilisé pour déverser le programme vers le Teensy.
Je n'avais pas commandé assez de Pin lors de mon dernier achat, je suis allé à la déchetterie et j'ai pu y récupérer une vieille carte mère d'ordi sur laquelle j'ai récupéré ces connecteurs.

Côté platine d'accueil, voilà ce que cela donne :

Et enfin, les raccordements aux autres éléments :

Les câbles en nappes jouent parfaitement leurs rôles au niveau de l'aspect clean. ce qui est loin d'être le cas coté gros interrupteurs. Malgré tout, un schéma s'impose pour y voir plus clair... :

Plus qu'à mettre le teensy:

Programmation du Teensy :

pré-requis :

1. installer TeensyLoader : https://www.pjrc.com/teensy/loader.html
2. installer le logiciel "Arduino" puis "Teensyduino" : https://www.pjrc.com/teensy/td_download.html
3. installer le plugin pour xPlane : http://www.pjrc.com/teensy/td_flightsim.html (ancienne version), ou préférer la dernière version qui notamment permet de gérer des références xplane DataRefs de longueur supérieure à 58 caractères . Cette version se trouve sur github  https://github.com/PaulStoffregen/X-Plane_Plugin/ , cliquer sur le bouton 'Download ZIP' et décompresser le fichier zip. Ensuite, utiliser le plugin xplane qui est dans le répertoire Target

 

 un premier test :

Dans un premier temps, nous allons faire un programme juste pour repérer les branchements de chaque interrupteur. En effet, lors du câblage je n'ai peut être pas respecté exactement un ordre précis et maintenant mieux vaut vérifier qui est branché sur quoi. Vous remarquerez également que j'ai parfois sauté des Pins côté Teensy dans le but de garder les broches spécialisées (PWM -> Pulse Wave Modulation, AC/DC, etc ...). Ces broches pourront être utilisées plus tard comme par exemple un variateur d'éclairage du tableau de bord (sortie PWD), des manettes potentiomètres (convertisseur AN) pour le pas d'hélice, richesse carbu, etc...

Bref, avant de fantasmer, repérons d'abord nos branchements.
Le programme est disponible à l'adresse suivante : https://github.com/Nicolou/cockpit/blob/master/testButtons/testButtons.ino.
Pour la manip du déversement du programme dans le Teensy, les instructions sont sur le site constructeur : https://www.pjrc.com/teensy/loader.html
Comme mentionné dans les pré-requis, n'oublions pas d'installer le logiciel de programmation Arduino ainsi que le plugin pour pouvoir y utiliser le Teensy  : https://www.pjrc.com/teensy/tutorial.html 


Pour visualiser le résultat du test, ouvrir une console afin de voir ce qui est écrit sur le port 'série' grace à la commande cat suivi du nom du périphérique.
exemples :  
si le logiciel de programmation Arduino a été configuré en USB type: série
  cat /dev/ttyACM0
ou en type Flight Sim Controls
  cat /dev/hidraw4

Voici ce que cela donne chez moi :

A partir de là, voici le tableau récapitulatif des connexions

	Pin number
Button name	arduino style	C style
BATTERY	20	B0
ALTERNATOR	21	B1
MAGENTO_STOP	7	D7
MAGENTO_LEFT	8	E0
MAGENTO_RIGHT	9	E1
MAGNETO_BOTH	10	C0
MAGNETO_START	11	C1
AVIONIC	23	B3
PUMP	22	B2
CARB HEAT	19	E7
NC1	5	D5
NC2	4	D4
LAND_LIGHT	3	D3
TAXY_LIGHT	2	D2
NAV_LIGHT	1	D1
STROB_LIGHT	0	D0
BEACON_LIGHT	27	B7
RADIO_SWITCH	17	C7
NAV_SWTICH	14	C4
RADIO_MHZ	28,29	PA0,PA1
RADIO_KHZ	32,33	PA4,PA5
NAV_MHZ	30,31	PA2,PA3
NAV_KHZ	34,35	PA6,PA7
LANDING_GEAR	12	C2

un deuxième test : les codeurs rotatifs

pour cela, on va utiliser la librairie "Encoder.h" comme indiqué dans l'exemple du site : https://www.pjrc.com/teensy/td_libs_Encoder.html
En adaptant le programme cité en exemple avec les numéros de pins correspondant au notre nous obtenons le code suivant : https://github.com/Nicolou/cockpit/blob/master/testEncoders/TwoKnobs/TwoKnobs.ino

Un déversement du programme dans le teensy et hop ! , le test s'avère concluant.

Maintenant, les choses sérieuses vont pouvoir commencer.

Programme pour Xplane :

Nous allons utiliser les spécifications du fichier dataref prévues pour la communication entre le cockpit Teensy et le logiciel Xplane.


N'oublions pas d'installer le plugin xplane en le décompressant dans le répertoire de xplane à l'emplacement suivant  ./Resources/plugins.




Mais d'abord, quelques explications sur les éléments utilisés dans le programme vont permettre de mieux comprendre son fonctionnement.

• Pour pouvoir utiliser la bibliothèque spécifique FlightSim de xplane, il faut, dans la configuration de l'éditeur de programme Arduino, aller dans le menu 'outil' -> 'usb type' et choisir 'Flight sim controls'
• Pour identifier les numéros de pins du teensy, nous utiliserons des constantes afin de définir ces numéros une seule fois et à un seul endroit du programme.
• En plus de la librairie 'Encoder.h'; nous utiliserons la librairie 'bounce.h'. Cette librairie permet de bien gérer les états des interrupteurs (anti- rebond, détection changement d'état, etc ... cf https://www.pjrc.com/teensy/td_libs_Bounce.html
• Lire la doc https://www.pjrc.com/teensy/td_flightsim.html
• Un programme 'Arduino' (ou teensy) se compose toujours d'une fonction setup() et d'une fonction loop().

Ceci étant dit, (et quelques heures plus tard... ), voici le programme à ouvrir dans arduino (version teensy) : https://github.com/Nicolou/cockpit/blob/master/xplaneDR400v1/xplaneDR400v1.ino
Puis à compiler et déverser dans le teensy.

ça y est, la boi-boite est quasi terminée.Il me manque juste une prise USB femelle et un interrupteur poussoir (celui du reset) qui me permettront de fermer l'ensemble.

Juste une dernière photo (et ce n'est pas la plus jolie) mais qui montre comment j'ai fixé le cockpit au bureau.

Voilà, c'est Fini en ce qui concerne cette étape de prototypage. En espérant que cet article vous soit utile.
Nicolas Montarnal.