Il y a quelques temps, un pilote me demandait combien l'Arduino avait de ports entrée/sortie, pour comparer avec une autre carte. A mon avis, cela ne doit pas être un critère de sélection, car acheter autant de cartes qu'il faut pour afficher touts les voyants et brancher tous les interrupteurs vous reviendrait probablement assez cher et nécessiterai plusieurs ports USB. Surtout qu'au lieu de ça, avec le BUS I2C dont nous avons déjà parlé, notre carte Arduino étend considérablement ses capacités.
Nous avions déjà parlé du bus I2C, l'affichage du compteur de la 406 transformé en indicateur CHAFF/FLARES. Dans cet article, on va utiliser ce même bus avec un CI (circuit intégré) qui va étendre le nombre d'entrées/sorties de l'arduino.
Ce CI sera le très utilisé MCP23017. D'un prix d'environ 2 à 3 euros, il possède 16 broches qui peuvent servir d'entrée (pour voir par exemple l'état d'un interrupteur), ou de sortie (pour éclairer, par exemple, un voyant, une diode). Le MCP 23017 a une adresse fixe (0x20) à laquelle s'ajoute une adresse "flottante" codée sur 3 pattes, ce qui permet d'en mettre 8 au maximum sur un même bus. Donc, 8 CI avec chacun 16 E/S, ça nous donne la possibilité d'ajouter 128 Entrées/Sorties. Et si on est limité par 8 CI max sur le même bus, on peut mettre d'autres CI de même fonction avec des adresses différentes, ce qui nous ajoute encore des possibilités d'E/S.
La doc du MCP 23017 se trouve par exemple ici elle pourra vous être utile pour le brochage et la programmation... ou alors, choisissez le confort d'utiliser une librairie déjà écrite (je vous propose celle d'Adafruit à l'adresse https://github.com/adafruit/Adafruit-MC ... no-Library) et lisez le tuto en français à partir de cette adresse : http://mchobby.be/wiki/index.php?title=MCP23017
Pour ce qui nous intéresse, le brochage du MCP est le suivant :
[ul]
[li]Les broches 1 à 8 et 21 à 28 sont des entrées/sorties.[/li]
[li]VDD est l'alimentation positive[/li]
[li]VSS la masse[/li]
[li]SCL et SDA sont pour la communication I2C[/li]
[li]RESET permet de réinitialiser le MCP. (Remarquez la barre horizontale au desus de RESET, cela signifie que par défaut le broche doit être en signal haut, c'est à dire alimentée; Donc pour réinitialiser le MCP, il faut mettre cette broche à la masse).[/li]
[li]A0 à A2 permettent de définir l'adresse flottante du CI.[/li]
[/ul]
Premier exemple : 3 boutons du panneau MISC
Pour ce premier exemple, on va utiliser l'Arduino Leonardo (car il crée un clavier USB), et la librairie Adafruit_MCP23017 pour commander trois interrupteurs du panneau MISC : l'interrupteur On/Off du laser, et les deux interrupteurs à trois position du pilote automatique.
Dans un précédent article, un programme en C++ exécuté sur le PC envoyait des séquences de touche à BMS. Dans les exemples d'aujourd'hui, il n'y a aucun programme sur le PC : les séquences de touche sont envoyées directement de l'arduino vers le PC. Mais cela nécessite d'utiliser la carte Arduino Leonardo.
Côté hardware, Il y a trois interrupteurs, dont deux à trois positions (un ON/OFF et deux ON/OFF/ON). Un seul MCP23017 suffit. Les petites particularités : les trois broches 15,16 et 17 qui définissent l’adresse flottante du CI sont reliées à la masse, l'adresse flottante du CI sera donc 0.
Le brochage du circuit est le suivant :
Pour la connexion des interrupteurs :
Les interrupteurs à deux positions (ON/OFF), il suffit simplement de relier une broche de l’interrupteur à la broche du MCP23017 (1 à 8 ou 21 à 28) et l'autre broche de l'interrupteur à la masse.
Les interrupteurs à trois positions (ON/OFF/ON), une broche de l'interrupteur est à la masse, les deux autres broches sont sur deux broches différentes du MCP23017. P.info, sur les interrupteurs que j'ai acheté la masse est au milieu, la broche du haut correspond au levier en position basse et la broche du bas correspond au levier en position haute.
Et en photo :
Le programme : Les broches du CI sont en pull up, cela signifie que par défaut la tension est à 5V (la sortie est à 1). Pour que l'état change, il faut relier cette broche sur la masse. On relie donc chaque broche à une borne de l'interrupteur, et l'autre broche de l'interrupteur est reliée à la masse du CI.
Deux cas de figure se rencontrent : Pour les interrupteurs à deux position, le programme regarde l'état de la broche du CI : si c'est haut (c'est à dire que la broche est à 5v), rien ne se passe, l'interrupteur est ouvert. Si c'est bas, c'est que la broche est reliée à la masse, l'interrupteur est fermé.
Pour les interrupteurs à trois position, la position du milieu n'est pas raccordée. Le programme regarde donc l'état des broches supérieures et inférieures de l'interrupteur. Si aucune des deux n'est fermée, c'est donc que l'interrupteur est dans la position du milieu.
La vérification de chaque broche s'effectue dans une boucle : toutes les x millisecondes, le programme vérifie l'état de chaque broche (donc de chaque interrupteur) et envoie le code clavier ou la combinaison clavier correspondante. L'inconvénient, c'est que nous avons des interrupteurs, et il est impossible d'envoyer à chaque boucle la séquence clavier de l'état de l'interrupteur. Pour éviter cela, peut être qu'il faudrait supprimer la répétition du clavier. Une autre piste également, c'est d'utiliser la fonction du CI qui se manifeste dès qu'une broche change d'état. Néanmoins, je n'ai utilisé aucune de ces solutions : j'ai mis en place un témoin de l'état de chaque interrupteur. Dès qu'un interrupteur change de position, le programme envoie le code clavier et modifie l'état du témoin pour cet interrupteur.
Bien que je n'ai pas essayé d'autres méthodes, l'avantage que je vois avec cette solution est qu'il suffit de réinitialiser le témoin pour que chaque interrupteur soit vérifié à nouveau. Plus concrètement : en remettant ce témoin (que je nomme trigger) à zéro, tous les interrupteurs du cockpit vont prendre la position de vos interrupteurs physiques. Il ne sera donc pas nécessaire de comparer chaque interrupteur avec son équivalent réel et dans le simulateur, inutile aussi de charger des profils différents selon que vous démarriez en RAMP ou en TAXI. Par contre, si vous démarrez en taxi ou en vol et que vos interrupteurs sont en position arrêt, ça risquera de vous faire drôle... (La réinitialisation du trigger est dans le second exemple).
Voilà le code :
Code : Tout sélectionner
/* Exemple button.pde
Utilise la librairie Adafruit-MCP23017 pour la lecture d'entrée et activation de la Pull-Up sur un MCP23017 I/O expander
Code écrit par LadyAda pour AdaFruit Industries [www.adafruit.com], Domaine Publique
TRADUCTION FRANCAISE par Meurisse D. pour MCHobby.be [www.mchobby.be], CC-BY-SA pour tâche de traduction.
TUTORIEL complémentaire EN FRANCAIS par MCHobby.be sur (voir wiki pour licence tutoriel)
http://mchobby.be/wiki/index.php?title=MCP23017
*/
#include <Wire.h>
#include "Adafruit_MCP23017.h"
#define laser 0
#define ap_pitch_hold 1
#define ap_off 2
#define ap_att_hold 3
#define ro_hdg_sel 4
#define ro_att_hold 5
#define ro_strg_sel 6
#define control 1
#define shift 2
#define alt 4
Adafruit_MCP23017 mcp;
unsigned int toggle = 0; //deux octets : 16 bits
void setup() {
Keyboard.begin();
//Serial.begin(9600);
mcp.begin(); // Utiliser l'adresse par défaut 0x00
mcp.pinMode(0, INPUT); // Activer GPA0 : Laser
mcp.pullUp(0, HIGH);
mcp.pinMode(1, INPUT); // Activer GPA1 : AP Pitch Hold
mcp.pullUp(1, HIGH);
mcp.pinMode(2, INPUT); // Activer GPA2 : AP Att Hold
mcp.pullUp(2, HIGH);
mcp.pinMode(3, INPUT); // Activer GPA3 : AP HDG Sel
mcp.pullUp(3, HIGH);
mcp.pinMode(4, INPUT); // Activer GPA4 : AP STRG Sel
mcp.pullUp(4, HIGH);
mcp.pinMode(15, INPUT); // Activer GPA15 : Réinitialisation de toggle
mcp.pullUp(15, HIGH);
}
void loop() {
if (!mcp.digitalRead(15)){
toggle = 0;
}
//Interrupteur LASER
if (mcp.digitalRead(0)){
//laser OFF
if (bitRead(toggle,laser)){
clavier ('h',control|alt);
bitClear (toggle,laser);
}
}else{
if (!bitRead(toggle,laser)){
//laser ON
clavier ('g',control|alt);
bitSet (toggle,laser);
}
}
//Interrupteur Auto-Pilot
if (!mcp.digitalRead(1)){
//pitch hold
if (!bitRead(toggle,ap_pitch_hold)){
clavier ('b',control|alt);
bitSet (toggle,ap_pitch_hold);
bitClear (toggle,ap_att_hold);
bitClear (toggle,ap_off);
}
} else if (!mcp.digitalRead(2)){
//att hold
if (!bitRead(toggle,ap_att_hold)){
clavier ('c',control|alt);
bitSet (toggle,ap_att_hold);
bitClear (toggle,ap_pitch_hold);
bitClear (toggle,ap_off);
}
}else{
//off
if (!bitRead(toggle,ap_off)){
clavier ('q',control|alt);
bitSet (toggle,ap_off);
bitClear (toggle,ap_att_hold);
bitClear (toggle,ap_pitch_hold);
}
}
//Interrupteur ROLL
if (!mcp.digitalRead(3)){
//ro_hdg_sel
if (!bitRead(toggle,ro_hdg_sel)){
clavier ('d',control|alt);
bitSet (toggle,ro_hdg_sel);
bitClear (toggle,ro_att_hold);
bitClear (toggle,ro_strg_sel);
}
} else if (!mcp.digitalRead(4)){
//att hold
if (!bitRead(toggle,ro_strg_sel)){
clavier ('f',control|alt);
bitSet (toggle,ro_strg_sel);
bitClear (toggle,ro_hdg_sel);
bitClear (toggle,ro_att_hold);
}
}else{
//off
if (!bitRead(toggle,ro_att_hold)){
clavier ('e',control|alt);
bitSet (toggle,ro_att_hold);
bitClear (toggle,ro_hdg_sel);
bitClear (toggle,ro_strg_sel);
}
}
delay(1);
}
void clavier(char touche, int fonction){
if (fonction & control) Keyboard.press(KEY_LEFT_CTRL);
if (fonction & shift) Keyboard.press(KEY_LEFT_SHIFT);
if (fonction & alt) Keyboard.press(KEY_LEFT_ALT);
Keyboard.press(touche);
delay(100);
Keyboard.releaseAll();
}
Et voilà en vidéo ce que ça donne, avec un petit support vite fait (et plutot mal fait) en plexi :
Voilà le second exemple : Panneaux SNSR PWR et HUD.
On dénombre :
3 interrupteurs à deux position : (3 broches)
8 interrupteurs à 3 position (16 broches)
J'ai aussi ajouté 1 interrupteur à deux positions pour réinitialiser le témoin (trigger). Je l'ai mis sur l'emplacement non matérialisé du panneau HUD. (1 broche).
Au total, ça prend 3 + 16 + 1 broches, il nous faut donc utiliser 20 broches pour tester l'état de ces interrupteurs. Pour ça, il sera nécessaire d'employer plumiers MCP23017. Comme chaque MCP23017 ajoute 16 broches, il en faudra donc deux. Leur connexion s'effectue presque de la même façon qu'avec un seul, la nuance se situe uniquement dans leur adresse flottante : les broches 15, 16 et 17 du premier sont reliées à la masse, ce sera donc zéro. Le second sera broché sur masse, masse et +5v, son adresse sera donc 1. Le brochage s'effectue sur 3 broches et se calcule comme en binaire.
Comme support, j'ai utilisé une chute de plexi de 4 mm que j'ai courbé sur les côtés pour faire un socle. J'ai repéré les trous et j'ai percé pour mettre les interrupteurs. J'aurai pu mieux faire en mettant des interrupteurs de formes différentes comme dans le F16, également, j'aurai du mettre un interrupteur temporaire pour réinitialiser le témoin et j'aurai pu mieux faire le panneau, plutôt que d'imprimer une feuille et la mettre en dessous. Mais c'est juste une expérience.
Le brochage des interrupteurs s'effectue comme précédemment.
Dans notre schéma de BUS I2C, on en est là :
Et "en vrai", ça ressemble à ça :
Etape par étape :
[ul]
[li]En tout premier lieu, repérez dans le cockpit du F16 tous les boutons que vous voulez connecter.[/li]
[li]Pour chacun de ces boutons, trouvez dans le document dash1 (C:\Falcon BMS 4.32\Docs\BMS Manuals\Falcon BMS Manuals\BMS-Dash1.pdf) leur commande (le BMS Key Callbacks). Par exemple, le bouton RDR du panneau SNSR PANEL a 3 positions : ALT, STBY et OFF. Sur la page 49 du document BMS-Dash1, on devine les commandes suivantes : SimRALTSTDBY, SimRALTON et SimRALTOFF qui correspondent manifestement à chaque état de l'interrupteur :
[/li]
[li]Il faut créer des raccourcis clavier pour chaque état de cet interrupteur. Si les entrées SimRALTSTDBY, SimRALTON et SimRALTOFF n'existent pas dans votre fichier de commandes clavier (le fichier *.key), quittez falcon et ajoutez les avec un éditeur de texte (p.exemple le bloc-notes notepad.exe). Pour ce faire, ajoutez une nouvelle ligne dans le fichier *.key, selon le format SimRALTON -1 0 0XFFFFFFFF 0 0 0 1 "RADAR ALT ON", ensuite, ouvrez Falcon BMS, retrouvez ces entrés et affectez leur des raccourcis clavier. Automatiquement, Falcon va mettre les codes corrects liés aux raccourcis que vous avez assigné.
[/li]
. [/li][li]A présent, reliez physiquement l’interrupteur sur les deux broches du CI MCP23017. Sur l'interrupteur, la broche du milieu à la masse, les deux autres sur les broches désirées du MCP. Dans mon exemple, j'ai relié la broche du bas de l'interrupteur (donc qui correspond à l'interrupteur en position haut à la broche 3 du MCP n°0, et j'ai relié la broche du haut de l'interrupteur (qui correspond à l'interrupteur en position basse à la broche 4 du MCP n°0[/li]
[li]A présent, dans le programme, ajoutez la ligne qui appelle le fonction de gestion des interrupteurs à trois fonction.
vInterr3( 0, 3, 3, 'o', control|alt, 'p', control|alt,'a', control|alt); //RDR ALT
La documentation est donnée dans le programme juste au dessus de la fonction vInterr3.[/li]
[/ul]
Voilà le programme :
Code : Tout sélectionner
/* Exemple button.pde
Utilise la librairie Adafruit-MCP23017 pour la lecture d'entrée et activation de la Pull-Up sur un MCP23017 I/O expander
Code écrit par LadyAda pour AdaFruit Industries [www.adafruit.com], Domaine Publique
TRADUCTION FRANCAISE par Meurisse D. pour MCHobby.be [www.mchobby.be], CC-BY-SA pour tâche de traduction.
TUTORIEL complémentaire EN FRANCAIS par MCHobby.be sur (voir wiki pour licence tutoriel)
*/
#include <Wire.h>
#include "Adafruit_MCP23017.h"
#define control 1
#define shift 2
#define alt 4
Adafruit_MCP23017 mcp[2];
unsigned long toggle[2];
void setup() {
Keyboard.begin();
mcp[0].begin();
mcp[1].begin(1);
for (int i=0;i<16;i++){
mcp[0].pinMode(i, INPUT);
mcp[0].pullUp(i, HIGH);
mcp[1].pinMode(i, INPUT);
mcp[1].pullUp(i, HIGH);
}
}
void loop() {
if (!mcp[0].digitalRead(5)){
//fonction de synchronisation des boutons (falcultatif)
toggle[0] = 0;
toggle[1] = 0;
}
//SNSR PWR
vInterr2( 0, 0, 0, 'i', control|alt, 'j', control|alt); //Left HDPT
vInterr2( 0, 1, 1, 'k', control|alt, 'l', control|alt); //Right HDPT
vInterr2( 0, 2, 2, ';', control|alt, 'n', control|alt); //FCR
vInterr3( 0, 3, 3, 'o', control|alt, 'p', control|alt,'a', control|alt); //RDR ALT
//HUD
vInterr3( 1, 0, 0, 'r', control|alt, 's', control|alt,'t', control|alt); //SCALES
vInterr3( 1, 2, 3, 'u', control|alt, 'v', control|alt,'z', control|alt); //LADDER
vInterr3( 1, 4, 6, 'x', control|alt, 'y', control|alt,'w', control|alt); //DED DATA
vInterr3( 1, 6, 9, 0xE1, control|alt, 0xE2, control|alt,0xE3, control|alt); //RETICLE
vInterr3( 1, 8, 12,0xE4, control|alt, 0xE5, control|alt,0xE6, control|alt); //VELOCITY
vInterr3( 1,10, 15,0xE7, control|alt, 0xE8, control|alt,0xE9, control|alt); //ALT
vInterr3( 1,12, 18,0xEA, control|alt, 0xDF, control|alt,0xDE, control|alt); //BRT
delay(1);
}
/******************************************************************************/
/*
Gestion d'un interrupteur à deux positions.
iMCP : Numéro du MCP
iBroche : Numéro de la broche du MCP qui sera connecté à l'interrupteur en position haute.
La position basse de l'interrupteur doit impérativement être connectée à la broche suivante.
iFlag : Numéro du premier bit du trigger. La trigger va utiliser le numéro de bit que vous avez envoyé, et le bit suivant.
cKeyUP : Touche de raccourci clavier pour l'interrupteur en position haute.
icKeySUP : Touche de fonction de raccourci clavier pour l'interrupteur en position haute. Les options sont control, shift et alt.
cKeyDO : Touche de raccourci clavier pour l'interrupteur en position basse.
icKeySDO : Touche de fonction de raccourci clavier pour l'interrupteur en position basse.
Note :
-Si vous voulez cumuler les touches de fonction Control, Shift et Alt, vous devez les incrire en les séparant par une barre verticale | ).
-Les touches sont envoyées selon un clavier en QWERTY. P.ex, si vous avez défini en raccourci la touche a dans falcon, l'arduino devra envoyer un q.
*/
void vInterr2(int iMCP,int iBroche, int iFlag, char cKeyUP, int icKeySUP,char cKeyDO, int icKeySDO){
if (mcp[iMCP].digitalRead(iBroche)){
if (bitRead(toggle[iMCP],iFlag)){
clavier (cKeyDO,icKeySDO); //DOWN
bitClear (toggle[iMCP],iFlag);
}
}else{
if (!bitRead(toggle[iMCP],iFlag)){
clavier (cKeyUP,icKeySUP); //UP
bitSet (toggle[iMCP],iFlag);
}
}
}
/*
Gestion d'un interrupteur à trois positions.
iMCP : Numéro du MCP
iBroche : Numéro de la broche du MCP qui sera connecté à l'interrupteur en position haute.
La position basse de l'interrupteur doit impérativement être connectée à la broche suivante.
iFlag : Numéro du premier bit du trigger. La trigger va utiliser le numéro de bit que vous avez envoyé, et les deux bits suivants.
cKeyUP : Touche de raccourci clavier pour l'interrupteur en position haute.
icKeySUP : Touche de fonction de raccourci clavier pour l'interrupteur en position haute. Les options sont control, shift et alt.
cKeyMI : Touche de raccourci clavier pour l'interrupteur en position milieu.
icKeySMI : Touche de fonction de raccourci clavier pour l'interrupteur en position milieu.
cKeyDO : Touche de raccourci clavier pour l'interrupteur en position basse.
icKeySDO : Touche de fonction de raccourci clavier pour l'interrupteur en position basse.
Note :
-Si vous voulez cumuler les touches de fonction Control, Shift et Alt, vous devez les incrire en les séparant par une barre verticale | ).
-Les touches sont envoyées selon un clavier en QWERTY. P.ex, si vous avez défini en raccourci la touche a dans falcon, l'arduino devra envoyer un q.
*/
void vInterr3(int iMCP,int iBroche, int iFlag, char cKeyUP, int icKeySUP,char cKeyMI, int icKeySMI,char cKeyDO, int icKeySDO){
int iFlagUP = iFlag;
int iFlagMI = iFlag+1;
int iFlagDO = iFlag+2;
if (!mcp[iMCP].digitalRead(iBroche)){
//UP
if (!bitRead(toggle[iMCP],iFlagUP)){
clavier (cKeyUP,icKeySUP);
bitSet (toggle[iMCP],iFlagUP);
bitClear (toggle[iMCP],iFlagDO);
bitClear (toggle[iMCP],iFlagMI);
}
} else if (!mcp[iMCP].digitalRead(iBroche+1)){
//DOWN
if (!bitRead(toggle[iMCP],iFlagDO)){
clavier (cKeyDO,icKeySDO);
bitSet (toggle[iMCP],iFlagDO);
bitClear (toggle[iMCP],iFlagUP);
bitClear (toggle[iMCP],iFlagMI);
}
}else{
//MIDDLE
if (!bitRead(toggle[iMCP],iFlagMI)){
clavier (cKeyMI,icKeySMI);
bitSet (toggle[iMCP],iFlagMI);
bitClear (toggle[iMCP],iFlagUP);
bitClear (toggle[iMCP],iFlagDO);
}
}
}
void clavier(char touche, int fonction){
if (fonction & control) Keyboard.press(KEY_LEFT_CTRL);
if (fonction & shift) Keyboard.press(KEY_LEFT_SHIFT);
if (fonction & alt) Keyboard.press(KEY_LEFT_ALT);
Keyboard.press(touche);
delay(100);
Keyboard.releaseAll();
}
Notez en début l'action de l'interrupteur "TEST", qui permet de positionner les interrupteurs de BMS comme ils sont positionnés sur le panneau physique.
P.info, j'ai ajouté une vidéo à la fin de l'article initial, c'est pour faire voir la réinitialisation du trigger : tous les interrupteurs de BMS prennent la position qu'ils ont sur le panneau physique.
Regardez bien les panneaux dans BMS, au début de la vidéo :
.
