Le FMC (Flight Management Computer ou ordinateur de vol), est une technologie très avancée qui équipe pratiquement tous les avions commerciaux modernes. Globalement, un FMC possède plusieurs bases de données relatives aux performances, à la navigation, à diverses fonctions capables d'interagir avec l'autopilote, les gaz automatiques, le directeur de vol (FD : Flight director), l'IRS. Du moins c'est ce que nous avons constaté sur l'add on PMDG de Flight Simulator.

Le CDU (Control Display Unit), quant à lui, est une sorte d'interface homme machine entre le pilote et le FMC.

Jusqu'à présent, pour l'utiliser, nous avons souvent fait appel au "clic" de la souris. Ce qui, comme le MCP dont la réalisation a été présentée dans autre article, nous a amené aussi à voir comment s'affranchir de celle-ci.

Le but de cet article est de présenter ce que nous avons mis en œuvre pour réaliser le CDU du B737 de PMDG.

A ce jour des solutions de réalisations d'un tel module sont nombreuses, il suffit de chercher sur le net; on tombera sur des solutions commerciales déjà pré-montées, intéressantes pour des personnes qui veulent réaliser des cockpits à part entière; et on trouve aussi des solutions à faire soit même.

Le merveilleux site de Peter Jongen, traite de diverses réalisations de sous-ensembles pour construire un cockpit. Les solutions proposées par Peter sont séduisantes, car elles font appel aux interfaces réseaux pour connecter certains sous-ensembles au PC; contrairement à l'USB, le réseau est bien plus flexible en terme de câblage, d'où l'idée de relier le CDU au PC par le réseau. n' ayant pas une bonne maîtrise de l'interface Ethernet, aucune exigence ne sera portée sur le temps de latence que ce choix pourrait introduire, le module que nous voulons réaliser est prévu pour le jeu avant tout.

Ireneusz Niemirowski est un membre très actif sur le site de Peter. Il a pu développé une application de gestion de CDU pour l'addon PMDG, capable de tourner sur un appareil Windows 10 IoT core. Merci Irek pour ce grand boulot.

De plus, il est vraiment inutile de ré-inventer la roue; car de nombreux kits à micro-contrôleurs du commerce possèdent des interfaces réseaux intégrées. Ces solutions à bas coût incluent bien souvent toutes les fonctionnalités d'un ordinateur à part entière.

Ceci nous fait pencher naturellement vers un Raspberry-Pi ; en ce qui nous concerne, il convient parfaitement pour la gestion du CDU. En effet, le Raspberry-Pi est un véritable ordinateur aux dimensions légèrement plus grandes qu'une carte de crédit, avec lequel on peut réaliser des systèmes électroniques sophistiqués. Pour un coût de 35 euros environ (à la date où sont écrites ces lignes).

Besoins:

• Un Raspberry-Pi modèle 3b+;
• 69 boutons poussoirs tactiles;
• 1 bouton poussoir tactile monté en surface;
• Un écran LCD 5 pouces, 640x480, modèle ZJ050NA-08C HDMI, avec son panneau de commande;
• Un micro-contrôleur ATMEL 32U4;
• Un quartz de 16MHz;
• 2 condensateurs de 22pF;
• 1 condensateur de 1 µF;
• 1 condensateur de 100nF;
• 1 résistance de 1M;
• 2 résistances de 10K;
• 1 résistance de 1K;
• 2 résistances de 22Ohms;
• 9 résistances de 180Ohms;
• 4 résistances de 2,2K;
• 4 transistors BC807 (PNP);
• 1 diode 1N4148:
• 4 LED 3mm oranges;
• 4 LED 3mm rouges;
• 1 LED 5mm blanche;
• 1 LED orange montée en surface;
• 1 connecteur coudé 5 broches au pas de 2mm;
• 1 un connecteur HE 14 broches angle droit;
• 1 module Teensy 3.2;
• 1 carte à trous pastillées.

Réalisation du CDU :

Le projet est réalisé en deux phases :

Phase 1 :

Création de la maquette sur plaque à trous pastillés ;

Intégration du logiciel et tests fonctionnels.

Modifications possibles de la maquette de base.

Phase 2 :

Réalisation du circuit imprimé, en tenant compte de modifications de la phase 1 ;

Programmation des différents modules, et tests

Avant de continuer, quelques pré-requis sont nécessaires :

Windows IoT core devra être installé dans le Raspberry-Pi ;

Les interfaces réseaux devront être configurées.

Phase 1 : réalisation de la maquette en fils volants

Pour cette première phase de réalisation on va créer un circuit sur une plaque à trous pastillés en effectuant liaisons directe entre les composants. Aucun schéma n'a été fait dans cette étape ; nous nous sommes contentés de faire des liaisons avec du fil de rigide soudé sur la plaque et le reste par des fils souples, à partir de schéma dessiné sur du papier brouillon.

Le matériel nécessaire dans cette phase est composé de :

1 carte pastillée à trous ;

1 Raspberry-Pi modèle 3B+ ;

1 Un écran LCD 5 pouces 800x480, l'ayant sous la main;

1 Un module de liaison HDMI ;

1 Un module Teensy 3.2 ;

1 Câble USB A / micro-USB ;

Du fil de câblage.

La figure ci-dessous montre la carte à trous pastillés avec des boutons poussoirs déjà montés, ainsi que le Raspberry, Teensy et l'écran; prêts pour l'assemblage:

Le Raspberry-Pi, a pour rôle de gérer les communications entre l'ordinateur, l'écran et le clavier.

Il est relié à l'ordinateur par un câble Ethernet, à l'écran LCD par une connexion HDMI, puis à Teensy par la liaison USB.

Le Teensy 3.2, permet de gérer les données entre les 69 bouton poussoirs tactiles disposés en matrice 10 lignes x 7 colonnes et Raspberry-Pi.

Les 10 lignes sont reliées sur les broches numéro 2 à 11, tandis que les 7 colonnes sont reliées sur les broches de 14 à 20 du Teensy.

Après de longues minutes de soudure,la plaque précédente a donc été assemblée avec le Raspberry-Pi et le Teensy.

Programmation :

L'application de gestion du CDU a d'abord été installée dans le Raspberry-Pi, ensuite nous avons développé, puis téléversé le programme ci-après dans le Teensy, grâce à l'interface de programmation Arduino.

/********************************************************************
 * Here our test program using Teensy 3.2 for matrix keyboard management
 * By: Jt BB
 * rev: 06/2020
 */
#include <Keypad.h>

const byte ROWS = 10;
const byte COLS = 7;
#ifdef M
#undef M
#endif
#define M(n) ((n) & KEYCODE_MASK)

char keys [ROWS] [COLS] = {

  {M(KEY_Z),M(KEY_Q),M(KEY_A),M(KEY_1),M(KEY_ESC),M(KEY_TAB),M(KEY_TILDE)},
  {M(KEY_F1),M(KEY_F2),M(KEY_F9),M(KEY_5),M(KEY_MINUS),M(KEY_LEFT_BRACE),0},
  {M(KEY_LEFT_ARROW),M(KEY_F3),M(KEY_8),M(KEY_T),M(KEY_6),M(KEY_EQUAL),M(KEY_F8)},
  {M(KEY_F12),M(KEY_F4),M(KEY_F5),M(KEY_G),M(KEY_Y),M(KEY_RIGHT_BRACE),M(KEY_F7)},
  {M(KEY_2),M(KEY_3),M(KEY_F11),M(KEY_4),M(KEY_H),M(KEY_F6),M(KEY_QUOTE)},
  {M(KEY_S),M(KEY_D),M(KEY_END),M(KEY_F),M(KEY_7),M(KEY_BACKSPACE),M(KEY_INSERT)},
  {M(KEY_W),M(KEY_E),M(KEY_HOME),M(KEY_R),M(KEY_J),M(KEY_K),M(KEY_9)},
  {M(KEY_X),M(KEY_C),M(KEY_SPACE),M(KEY_V),M(KEY_U),M(KEY_I),M(KEY_L)},
  {M(KEY_RIGHT),M(KEY_DOWN),M(KEY_ENTER),M(KEY_B),M(KEY_M),M(KEY_COMMA),M(KEY_O)},
  {M(KEY_N),M(KEY_PERIOD),M(KEY_SLASH),M(KEY_BACKSLASH),M(KEY_P),M(KEY_0),M(KEY_SEMICOLON)}

};

byte rowPins[ROWS] = {2,3,4,5,6,7,8,9,10,11}; //connect to the row pinouts of the keypad
byte colPins[COLS] = {14,15,16,17,18,19,20}; //connect to the column pinouts of the keypad


Keypad kpd = Keypad( makeKeymap(keys), rowPins, colPins, ROWS, COLS );

unsigned long loopCount;
unsigned long startTime;
int x = 0;

void setup() {
    Serial.begin(9600);
    loopCount = 0;
    startTime = millis();  
}


void loop() {
    loopCount++;
    //char key = kpd.getKey() and loopCount millis start time defauft = 5000 other value 10000;
    if ( (millis()-startTime)>5000 ) {
        startTime = millis();
        loopCount = 0;
    }
    
    
    if (kpd.getKeys())
    {
        for (int i=0; i<LIST_MAX; i++)   // Scan the whole key list.
        {
            if ( kpd.key[i].stateChanged )   // Only find keys that have changed state.
            {
                switch (kpd.key[i].kstate) {  // Report active key state : PRESSED, HOLD, IDLE or RELEASED
                    case PRESSED:
                    
                    Serial.print("Key ");
                    Serial.print(kpd.key[i].kchar);
            
                    Keyboard.set_key1(kpd.key[i].kchar);
                    Keyboard.send_now();
                          
        
                break;
                 
                    case HOLD:
                    
                    Keyboard.set_key1(kpd.key[i].kchar);
                    Keyboard.send_now();
                    
                break;
                    case RELEASED:
                   
                    Keyboard.set_key1(0);
                    Keyboard.send_now();
               
                break;
                    case IDLE:
                   { ;} 
                    
                }
                
            }
        }
    }
}  // End of file--

On peut faire quelques tests avec le nouveau clavier, même si les touches ne sont pas sérigraphiées, il faut malheureusement deviner où elles se situent en tenant compte d'une photo d'un CDU, comme par exemple celle-ci:

On va d'abord exécuter l'application PMDG Data and Events Server, qui peut être récupérée gratuitement sur le site de Peter. Lancer ensuite Flight Simulator X, puis le B737 de PMDG. Ensuite connecter (en cliquant sur Connect) DataEvenServer afin qu'il puisse communiquer avec l'addon PMDG, on est à présent prêt pour commencer la configuration.

Mettre sous tension le CDU, attendre que Windows soit bien démarré, dans le champ IP saisir l'adresse IP du PC, dans le champ PORT saisir 8094. A présent si on appuie sur le bouton CONNECT du CDU, on peut commencer la configuration.

Les images ci-après illustrent les résultats obtenus comparés avec celles du CDU du B737 de PMDG telles qu'affichées à l'écran du PC:

C'est vraiment très encourageant.

Avant de clore cette première phase de réalisation, nous avons rencontrés quelques problèmes relatifs au rebonds des touches du clavier, ce type de dysfonctionnement entraîne de fois des affichages successifs d'un caractère, voire le blocage du CDU selon la fonction en cours d'exécution, comme illustré par cette photo:

Nous n'avons pas souhaité amener des correctifs à cela en utilisant toujours le même contrôleur (Le Teensy). Ce qui nous amène directement à la phase suivante de la réalisation.

Phase 2 : réalisation du circuit imprimé et améliorations

A l'issue de la phase de réalisation précédente, nous avons obtenu de bons résultats malgré le phénomène des rebonds des touches, le CDU communique bien avec l'ordinateur, et affiche des données en provenance de celui-ci.

A présent on va créer le circuit imprimé, et essayer d'apporter des améliorations sur la gestion du clavier. Ce sera exclusivement l'essentiel du travail qui sera à faire dans cette phase; le programme contenu dans le Raspberry-Pi reste inchangé.

Entre temps une face avant équipée de boutons gravés a été commandée chez Hispapanels pour un prix qui se situe autour de 80 euros, mais aussi un nouvel afficheur 5 pouces en 640x480 avec une interface HDMI chez Amazon. C'est un modèle ZJ050NA-08C avec sa carte de commande.

En attendant on va d'abord s'occuper du clavier. Désormais exit Teensy, pour cause de prix; nous allons plutôt implanter le contrôleur sur le même circuit imprimé que les boutons poussoirs tactiles, cela évite des connecteurs supplémentaires sur le circuit imprimé.

C'est le microcontrôleur ATMEL32U4 qui a été retenu pour accomplir cette tâche. Le choix de ce microcontrôleur porte essentiellement sur sa capacité à disposer d'une interface USB intégrée, puis à gérer des communications sur ce type d'interface; de plus il possède suffisamment de broches pour connecter les 69 boutons tactiles sous forme de clavier matricé. Pour avoir plus d'informations techniques sur ce composants, il faudra se reporter sur le site de Microchip.

Le circuit imprimé commandé chez le sous-traitant est disponible et prêt à recevoir l'ensemble des éléments.

Après soudure des touches, puis de l'ATMEL32U4 et des autres composants, le clavier se présente sous cette forme:

Une fois l'écran LCD et le Raspberry-Pi connectés, il ne reste plus qu'à assembler le tout avec une face avant.

Programmation:

Comme nous l'avions signalé plus haut dans ces lignes, le programme tourne ici autour de la gestion du clavier à base de l'ATMEGA32U4.

Programmer une interface USB nécessite de se plonger dans la vaste bibliographie consacrée à cette technologie, on y trouvera des notions tels que les descripteurs, et bien d'autres encore. Pour plus d'information, une recherche dans le net en vaut le détour, on pourra y trouver des sources détaillées à ce sujet.

Pour notre part nous avons trouvé toujours dans le net, un microprogramme de gestion de clavier USB appelé TMK, celui-ci offre beaucoup de facilité de programmation, et d'ailleurs beaucoup de projets de création et de transformation d'anciens claviers ont vu le jour grâce ce microprogramme.

Pour réaliser le programme de gestion du clavier, à partir de TMK, nous nous sommes inspirés d'un exemple de projet fournit dans le paquetage appelé "onekey".  A partir de ce projet, on a apporté des modifications dans les fichier config.h, keymap.c et matrix.c.

Dans le fichier config.h, on va définir le nombre de lignes et de colonnes de la matrice du clavier.

Puis dans le fichier matrix.c, on va redéfinir les fonctions : init_cols; read_cols; unselect_rows; select_rows. Beaucoup d'exemples de projets de gestion de clavier sont proposés dans le repos, on peut s'en inspirer.

Ce qu'on peut juste dire c'est que :

init_cols configure toutes les colonnes en entrée, et active les résistances de pull-up sur chacune d'entre elles.

read_cols lit l'état de toutes les colonnes, puis enregistre le résultat sous forme d'un octet, du moins pour un clavier ayant au plus 8 colonnes.

unselect_rows met toutes les lignes en état haute impédance.

select_rows met chacune des lignes spécifiques à l'état bas.

Pour finir la définition de chaque touche se fera dans le fichier keymap.c; il faudra aussi veiller à bien respecter la disposition des touches telle que définies dans le schéma.

Une fois ce travail effectué, on compile le projet; si tout se passe bien on obtient un fichier .hex.

Il ne faut pas hésiter à se rendre à l'adresse du Repo de TMK, pour plus d'information sur ce microprogramme.                 

C'est ce fichier .hex qui sera programmé dans l'ATMEGA32U4.

Entre temps, la face avant de Hispapanels a été reçue, ainsi que le nouvel afficheur LCD 640x480. Nous nous sommes contenté d'intégrer ces deux composants sur le circuit imprimé prémonté du clavier.

Malgré une bonne finition, les dimensions de la face avant de Hispapanels ne correspondaient exactement à la disposition de l'écran. Quelques ajustements à la lime ont donc été nécessaires pour essayer d'aligner au mieux la face avant, l'écran et le clavier.

On a obtenu ceci au final:

Le nombre de câbles a diminué, comme peut le voir la photo ci-dessus; on a désormais besoin que d'un câble réseau (jaune), pour relier le CDU à l'ordinateur et d'un câble d'alimentation (à deux fils noir).

Les tests:

Des essais fonctionnels avec face avant montée ont laissés encore apparaître de très rares rebonds des touches.

La face avant a donc été de nouveau démontée pour faire des essais directement avec des boutons tactiles. Au cours de ces essais, nous avons constaté la disparition des rebonds. Tout laisse à croire que l'environnement mécanique des touches (leur course à travers les trous de perçage, les frottements, l'absence de ressort de rappel, ...) pourrait aussi entraîner ce genre de dysfonctionnement. La conception du clavier parfait n'est donc pas si évidente. Côté informatique, des algorithmes sont capables de diminuer au maximum les rebonds. Mais en tout cas malgrès de très rares rebonds encore présents, on peut déjà utiliser le CDU pour jouer.

Certaines améliorations mécaniques sont donc à prévoir dans ce sens.

On va terminer cet article la présentation du CDU en action sur un exemple de saisie d'une route Orly / Marseille-Provence, avec un démarrage cockpit à froid:

 Jt BB