Cockpit maison avec Arduino (comment faire) ?

[Lami]

...

... mais une des références données par Djetdail offre déjà une solution assez complète.
La structure d'un programme d'interface Ethernet pour Arduino est disponible sur le site officiel http://arduino.cc/en/Reference/Ethernet et http://arduino.cc/en/Tutorial/UDPSendReceiveString.

Le plus difficile est d'obtenir des informations fiables sur les données fournies par X-Plane.
PhM m'a déjà aidé en me signalant que les répertoires de l'installation de X-Plane contenaient des fichiers de référence (je les avais trouvés sur internet sans me rendre qu'ils étaient déjà installés) mais il subsiste, à mon sens, un mauvais suivi de ces références.
J'utilise comme référence la version "officielle" datée du 29 mai 2014 (http://www.xsquawkbox.net/xpsdk/docs/DataRefs.html) mais je ne suis pas convaincu qu'elle soit complète et correcte.

Je vais regarder ça avec attention, merci de les ramener ! Et re-merci à Djetdail !

L'ami René
...

OK, j'ai regardé ça et je n'arrive pas à la même conclusion. On a le nom, l'emplacement et le type des données et le protocole UDP semble simple du côté Arduino. Les exemples de « Arduino.cc » sont basiques. Le problème c'est de passer par le panneau « Données Entrée/Sorties », avec ses boîtes à cocher et le fameux et problématique plug-in UDP de X-Plane ?

Je ne peux croire que personne n'a fait un petit plug-in générique qui reçoit et envoie les données du genre :

EnvoyerValeur ("sim/cockpit/radios/nav1_freq_hz", 10930);

et :

LireValeur ("sim/cockpit2/switches/navigation_lights_on");

Donc, simplement le littérale que l'on retrouve dans les DataRefs.txt et Commands.txt avec une carte Arduino et une carte Ethernet si l'USB est problématique.

L'ami René
Tous pour un et un pour tous !

[PhM]

    pinMode(i, INPUT_PULLUP);// PULLUP for setting "High" when pin open (LOW when on the GND)

Ok, là on entre dans un autre domaine, le fonctionnement de l'électronique interne d'un port d'interface d'un micro-controleur. Toutes les informations sont, par exemple, disponibles ici. Comme mentionné précédemment c'est en anglais (technique, pas littéraire), l'anglais est quasi incontournable dans ces domaines. Le document de référence pour l'Atmega32U4 fait 433 pages, et la partie sur les ports d'interface fait 20 pages. C'est très instructif mais je ne vais pas me lancer dans une traduction de 20 pages .

Je vais donc faire simple dans la réponse. Un pull-up est un dispositif, interne ou externe au micro-controleur, qui va assurer un niveau dit haut (la tension d'alimentation) lorsque le micro-controleur ne fixe pas lui même ce niveau pour quelque raison que ce soit. La figure 10-5 à la page 70 montre ce pull-up et toute la logique qui le commande, mais c'est très abscons si l'on a pas un bon niveau en électronique.

PhM

[Lami]

Bonjour PhM,

Merci ! Tu as écrit ce qui me manquait « qui va assurer un niveau dit haut (la tension d'alimentation) lorsque le microcontrôleur ne fixe pas lui-même ce niveau pour quelque raison que ce soit. »

Juste un détail, dans mon post précédent je n'ai pas écrie « littéraire », mais « littérale » (dico : Qui est représenté par des lettres.). Dans notre contexte, je faisais référence au libéré utilisé dans les DataRefs.txt et Commands.txt.

Et dans l'exemple que je faisais, cela voulait dire pouvoir faire du copier/coller dans notre code source du texte "littéral" trouvé dans les fichiers DataRefs.txt et Commands.txt.

Encore merci pour tout !

L'ami René
Tous pour un et un pour tous !

[FlyingBaldy]

Autre question, mais connexe; je ne maîtrise pas la récupération des données de X-Plane par l'Ethernet UDP. Alors est-ce que tu connais une personne francophone qui travaille avec la communication Ethernet UDP et X-Plane, et idéalement Arduino ?

C'est que je m’apprête à reproduire l'affichage avec l'Arduino sur écran LCD, GLCD ou TFT de par exemple les fréquences radios (NAV1, NAV2, COM1, COM2, ADF1, ADF2), les paramètres du FMS (vitesse air, altitude cible, la V/S, le cap, etc.).

L'objectif est de ne plus avoir à afficher le fouillis des « Données entrée/Sorties » de X-Plane (dans le coin supérieur gauche de l'écran) ou de constamment devoir modifier notre point de vue dans le cockpit pour faire le tour des paramètres de vol et du FMS, etc.

Comme promis, voici un programme Arduino qui lit toutes les informations demandées (plus d'autres).
Il n'y a aucun plugin ni bibliothèque spéciale à installer (installation standard d'Arduino).
Les broches correspondent à une carte Arduino MEGA.
Il faut modifier le sketch Arduino pour l'adresse IP de l'ordinateur hôte de X-Plane et pour l'adresse MAC de la carte Arduino (voir étiquette au dos du shield Ethernet).
Il s'agit d'un sketch d'essai, fonctionnel mais encombré par de nombreuses lignes Serial.print visant à afficher sur le moniteur série les différentes informations.
La première ligne affichée correspond à l'adresse IP de la carte car elle est déterminée automatiquement par un serveur DHCP. Cette valeur doit ensuite être recopiée dans X-Plane.
il est possible d'améliorer en réduisant la fréquence de lecture des données par un délai dans chaque passage de boucle ou en testant si la valeur est identique à la valeur relevée lors du passage précédent.
A part les instructions de LED ( en commentaire), je n'ai pas inclus d'instruction d'affichage sur LCD,...

Bon amusement.

/*
I/O interface for X-Plane Cockpit Simulator

Receiving DATA from X-Plane

Vlad Sychev, 2012-2014 - Modifed Flyingbaldy 20/7/2014
http://b58.svglobe.com
 */
 
#include <SPI.h>           // si SPI utilisé
#include <Ethernet.h>
#include <EthernetUdp.h> 
#include <Servo.h>          //si servo utilisé 
//-----------------------------
byte mac[] = {0x11, 0x11, 0x11, 0x11, 0x11, 0x11};     // mettre à jour selon l'adresse MAC de votre shield Arduino (étiquette au dos de la carte)
IPAddress ip ;                                         // Adresse IP Arduino 
IPAddress ipx(192, 168, 1, 1);                         // mettre à jour selon l'adresse IP de votre PC 
unsigned int localPort = 49001;                        // port pour recevoir les paquets UDP 
unsigned int  XP = 49000;                              // port ppour envoyer les paquets UDP
EthernetUDP Udp;                                       // instance EthernetUDP pour envoyer/recevoir les paquets UDP
byte DATA_buf[500];                                    // vecteur de stockage des données transitant par UDP 
int packetSize;                                        // taille du paquet reçu

//-------------------------------------------------------------------------------------- 

int FuelL;              //---  quantité réservoir gauche 
int FuelR;              //---  quantité réservoir droit 
float Bus;              //--- Tension de Bus
int Flaps;              //--- Position des flaps  
int Flaps_pre;          // --- Position précédente (on n'envoie par liaison série que s'il y a un changement de valeur)
int Var_temp;

// --- Pins for LEDs   (mettre à jour les broches reliées à des LED
   int GearLed0 = 31;      //- Broche pour Led "En Transit"     
   int GearLed1 = 33;
   int GearLed2 = 35;
   int GearLed3 = 37;           

   int MarkerLed1 = 39;    // Broche pour témoin LED "O"
   int MarkerLed2 = 41;    // Broche pour témoin LED "M"
   int MarkerLed3 = 43;    // Broche pour témoin LED "I"

//----------------------------------------------------------------------------
float Gear1 = 1;                                 //--- Position initiale train #1 ( 1.00 - sorti et verrouillé, 0 - rentré)
float Gear2 = 1;                                 
float Gear3 = 1;                                   

int COM1_freq;
int COM1_standby;
int COM2_freq;
int COM2_standby;
int NAV1_freq;
int NAV1_standby;
int NAV2_freq;
int NAV2_standby;
//int ADF1_freq;
//int ADF2_freq;
float IAS;
float VVI;
float COM1_freq_float;
float COM1_standby_float;
float COM2_freq_float;
float COM2_standby_float;
float NAV1_freq_float;
float NAV1_standby_float;
float NAV2_freq_float;
float NAV2_standby_float;
float Heading_true;
float Heading_mag;
float Autopilot_speed;
float Autopilot_heading;
float Autopilot_VVI;
float Autopilot_altitude_dial;
float Autopilot_altitude_VNAV;
float Autopilot_altitude_use;
float Autopilot_sync_roll;
float Autopilot_sync_pitch;
float Marker1;
float Marker2;
float Marker3;

//----------------------------- définition de l'union utilisée pour partager la même zone mémoire entre différents formats de variable (ici 4 octets de caractères ou 1 flottant). ---------------
   union {
        char bytevalue[4];                         
        float floatvalue;
        }  bf;

//=================  setup  ===========================================
void setup()  { 
  
 //-----------------------------------------------------------------  

  Ethernet.begin(mac);                                      // démarrage connexion Ethernet:DHCP 
  ip = Ethernet.localIP();                                  // recherche adresse IP locale de la carte Arduino
  Ethernet.begin(mac,ip);                                   // démarrage liaison Ethernet 
  Udp.begin(localPort);                                     //..et UDP:

// for (int i = 22; i < 30; i++)  pinMode(i, INPUT_PULLUP);     // broches 22-29 en Entrée (lecture d'interrupteurs/encodeurs) et niveau haut par défaut
// for (int i = 30; i < 44; i++)  pinMode(i, OUTPUT);           // broches 30 à 44 en Sortie (affichage sur LED, LCD...
 
 Serial.begin(9600);                   // retour valeurs de test vers l'écran du PC via liaison série
                    Serial.println("");  
                    Serial.print("Adresse IP Arduino ="); Serial.println(ip);  // affiche l'adrese IP de la carte ARDUINO attribuée automatiquement par DHCP (cette adresse est à recopier dans le panneau Data In Out de X-Plane)
   }
           
//========= Setup End ===========



//------------------------  Début du programme ------------------------------------------------
void loop() 
{
cmd("sim/none/none");

//========================= RECEPTION DONNEES DEPUIS X-PLANE ====================================


//----------------------------------------------  )------------------
                                     
  packetSize = Udp.parsePacket();   // essai de lecture d'un paquet
       if (Udp.available())         // si paquet reçu
  {
   Udp.read ( DATA_buf, packetSize );   // lit les données UDP à partir du tampon. Toutes les données sont stockées dans la variable DATA_buf 

       
//---------------------------------------------- LECTURE DES DONNEES ---------------------------------------


       for (int i = 5; i < packetSize; i += 36)    // on lit chaque groupe de données par série de 36 octets
         { 
          switch (DATA_buf[i])                     //--- selon type de données (numéro de groupe)
             {
   
              case 3:      //------------------------------ Vitesses réelles  -------------------   
              
                        for (int n=0; n<4; n++) bf.bytevalue[n] = DATA_buf[i+4+n];    // lit le 1er jeu de 4 octets dans le groupe (correspond à la première valeur affichée dans DATA IN/OUT, donc IAS)         
                                   IAS = bf.floatvalue;
                                         
//                    Serial.print("kias Speed = "); Serial.println(IAS);  

                         break;

              case 4:      //------------------------------ VVI (V/S)  -------------------   
              
                      for (int n=0; n<4; n++) bf.bytevalue[n] = DATA_buf[i+12+n];         // 3e jeu de données dans le groupe #4 ( #25-28 bytes)
                          VVI = bf.floatvalue;
                         

                         break;

              case 13:      //------------------------------ Position des Flaps  -------------------   
              
                      for (int n=0; n<4; n++) bf.bytevalue[n] = DATA_buf[i+20+n];         // read 5-th 4-byte data in group #13 ( #25-28 bytes)
                          Flaps = int(bf.floatvalue * 100);         
                         
//                    if (Flaps_pre !=  Flaps)  {  
                      
//                    Serial.print("Flaps Position = "); Serial.println(Flaps);  
                     
//                           Flaps_pre =  Flaps;
//                                               }
                         break;

              case 18:      //------------------------------ Caps réels  -------------------   
              
                      for (int n=0; n<4; n++) bf.bytevalue[n] = DATA_buf[i+12+n];         // 3e jeu de données dans le groupe (cap vrai)
                          Heading_true = bf.floatvalue;
                         
                      for (int n=0; n<4; n++) bf.bytevalue[n] = DATA_buf[i+16+n];         // 4e jeu de données dans le groupe (cap magnétique)
                          Heading_mag = bf.floatvalue;

//                    Serial.print("CAP = "); Serial.println(Heading_true);  

                          break;

              case 62:      //----------------------------- Jauges carburant  -------------------
              
                       for (int n=0; n<4; n++) {bf.bytevalue[n] = DATA_buf[i+4+n];}   // read 1-st 4-byte data in group #62  (réservoir 1)
                                    FuelL = int(bf.floatvalue);             
                       for (int n=0; n<4; n++) bf.bytevalue[n] = DATA_buf[i+8+n];     // read 2-nd 4-byte data in group #62 (réservoir 2)
                                    FuelR = int(bf.floatvalue);
                                 
 
           //       Serial.print("Fuel Left Tank = ");  Serial.println(FuelL);
                             
                               break;
  
            
              case 67:      //---------------------------- Indicateurs de train  -------------------
              
                               for (int n=0; n<4; n++) bf.bytevalue[n] = DATA_buf[i+4+n];             // train 1
                                   Gear1 = bf.floatvalue;     
                
                               for (int n=0; n<4; n++) bf.bytevalue[n] = DATA_buf[i+8+n];
                                   Gear2 = bf.floatvalue;

                               for (int n=0; n<4; n++) bf.bytevalue[n] = DATA_buf[i+12+n];
                                   Gear3 = bf.floatvalue;

//                                         if (Gear1 == 1)   digitalWrite(GearLed1, HIGH) ;             // allumage Led 1 selon information reçue (verrouillage train)
//                                         else   digitalWrite(GearLed1, LOW) ;  
//                                         if (Gear2 == 1)   digitalWrite(GearLed2, HIGH) ;
//                                         else  digitalWrite(GearLed2, LOW) ; 
//                                         if (Gear3 == 1)   digitalWrite(GearLed3, HIGH) ;
//                                         else   digitalWrite(GearLed3, LOW) ; 
//                                         if (Gear1 == Gear2 && Gear2 == Gear3)  digitalWrite(GearLed0, LOW) ;   //LED rouge pour transit
//                                         else   digitalWrite(GearLed0, HIGH) ;              
           
                            break;  

              case 96:      //----------------------------- fréquences COM 1/2 ----------------------
              
                        for (int n=0; n<4; n++) bf.bytevalue[n] = DATA_buf[i+4+n];     // 1er jeu de données dans le groupe         
                                   COM1_freq_float = bf.floatvalue/100.0;
                                   COM1_freq = int(bf.floatvalue);
                
                        for (int n=0; n<4; n++) bf.bytevalue[n] = DATA_buf[i+8+n];     // 2e jeu de données dans le groupe
                                   COM1_standby_float = bf.floatvalue/100.0;
                                   COM1_standby = int(bf.floatvalue);

                        for (int n=0; n<4; n++) bf.bytevalue[n] = DATA_buf[i+16+n];    // 4e jeu de données dans le groupe
                                   COM2_freq_float = bf.floatvalue/100.0;
                                   COM2_freq = int(bf.floatvalue);
           
                        for (int n=0; n<4; n++) bf.bytevalue[n] = DATA_buf[i+20+n];    // 5e jeu de données dans le groupe      
                                   COM2_standby_float = bf.floatvalue/100.0;
                                   COM2_standby = int(bf.floatvalue);

//                        Serial.print("COM1 = "); Serial.println(COM1_freq_float);  
                        Serial.print("COM1 = "); Serial.print(COM1_freq); Serial.print(" en entier ou "); Serial.print(COM1_freq_float); Serial.println(" en flottant");   
//                        Serial.print("COM1 stby = "); Serial.println(COM1_standby_float);  
                        Serial.print("COM1 stby = "); Serial.println(COM1_standby);  
//                        Serial.print("COM2 = "); Serial.println(COM2_freq_float);  
                        Serial.print("COM2 = "); Serial.println(COM2_freq);  
//                        Serial.print("COM2 stby = "); Serial.println(COM2_standby_float);  
                        Serial.print("COM2 stby = "); Serial.println(COM2_standby);  
               
                              break;
                         
              case 97:      //-----------------------------  fréquences NAV 1/2 ----------------------
              
                        for (int n=0; n<4; n++) bf.bytevalue[n] = DATA_buf[i+4+n];    // 1er jeu de données dans le groupe
//                                   NAV1_freq_float = bf.floatvalue/100.0;
                                   NAV1_freq = int(bf.floatvalue);

                        for (int n=0; n<4; n++) bf.bytevalue[n] = DATA_buf[i+8+n];    // 2e jeu de données dans le groupe
//                                   NAV1_freq_float = bf.floatvalue/100.0;
                                   NAV1_standby = int(bf.floatvalue);
           
                        for (int n=0; n<4; n++) bf.bytevalue[n] = DATA_buf[i+20+n];    // 5e jeu de données dans le groupe       
//                                   NAV2_freq_float = bf.floatvalue/100.0;
                                   NAV2_freq = int(bf.floatvalue);
                
                        for (int n=0; n<4; n++) bf.bytevalue[n] = DATA_buf[i+24+n];    // 6e jeu de données dans le groupe
//                                   NAV2_freq_float = bf.floatvalue/100.0;
                                   NAV2_standby = int(bf.floatvalue);

                        Serial.print("NAV1 = "); Serial.println(NAV1_freq);  
                        Serial.print("NAV1 stby = "); Serial.println(NAV1_standby);  
                        Serial.print("NAV2 = "); Serial.println(NAV2_freq);  
                        Serial.print("NAV2 stby= "); Serial.println(NAV2_standby);  

                              break;
                         
              case 105:      //-----------------------------    Indicateurs balises O M I ----------------------
              
//                         if (DATA_buf[i+7] == 0) digitalWrite(MarkerLed1, LOW) ;       // Allumage/extinction de la LED du Marker O
//                                         else   digitalWrite(MarkerLed1, HIGH) ;  
//                         if (DATA_buf[i+11] == 0) digitalWrite(MarkerLed2, LOW) ;      // Allumage/extinction de la LED du Marker M
//                                         else   digitalWrite(MarkerLed2, HIGH) ;  
//                         if (DATA_buf[i+15] == 0) digitalWrite(MarkerLed3, LOW) ;      // Allumage/extinction de la LED du Marker I
//                                         else   digitalWrite(MarkerLed3, HIGH) ;  
                              break;
                       
              case 118:      //------------------------------ Consignes autopilote  -------------------   
              
                        for (int n=0; n<4; n++) bf.bytevalue[n] = DATA_buf[i+4+n];     // 1er jeu de données dans le groupe
                                   Autopilot_speed = bf.floatvalue;
                
                        for (int n=0; n<4; n++) bf.bytevalue[n] = DATA_buf[i+8+n];     // 2e jeu de données dans le groupe
                                   Autopilot_heading = bf.floatvalue;

                        for (int n=0; n<4; n++) bf.bytevalue[n] = DATA_buf[i+12+n];    // 3e jeu de données dans le groupe
                                   Autopilot_VVI = bf.floatvalue;
           
                        for (int n=0; n<4; n++) bf.bytevalue[n] = DATA_buf[i+16+n];    // 4e jeu de données dans le groupe       
                                   Autopilot_altitude_dial = bf.floatvalue;
                
                        for (int n=0; n<4; n++) bf.bytevalue[n] = DATA_buf[i+20+n];    // 5e jeu de données dans le groupe
                                   Autopilot_altitude_VNAV = bf.floatvalue;

                        for (int n=0; n<4; n++) bf.bytevalue[n] = DATA_buf[i+24+n];    // 6e jeu de données dans le groupe
                                   Autopilot_altitude_use = bf.floatvalue;
           
                        for (int n=0; n<4; n++) bf.bytevalue[n] = DATA_buf[i+28+n];    // 7e jeu de données dans le groupe       
                                   Autopilot_sync_roll = bf.floatvalue;
                
                        for (int n=0; n<4; n++) bf.bytevalue[n] = DATA_buf[i+32+n];    // 8e jeu de données dans le groupe
                                   Autopilot_sync_pitch = bf.floatvalue;
          
//                        Serial.print("VS Autopilote = "); Serial.println(Autopilot_VVI);  
                            break;  
                         

               case 124:       //------------------------- Tension Bus ----------------------------------  
               
                        for (int n=0; n<4; n++) bf.bytevalue[n] = DATA_buf[i+12+n];  // read 3-d 4-byte data in group #124
                        Bus= bf.floatvalue;
                                    
           //       Serial.print("Bus Voltage = ");  Serial.println(Bus);

                              break;

            } 
        }
 
   }            // ========== FIN de la lecture des paquets UDP      


 }   //------------------------------------------------ Fin de boucle principale------------------

  void cmd (char Data_com[])
                {
                Udp.beginPacket(ipx, XP);    // initialisation du paquet UDP 
                Udp.write("CMND0") ;         // écriture texte pour une commande
                Udp.write(Data_com) ;        // écriture du texte de la commande
                Udp.endPacket();             // fin du paquet UDP

                }

[Lami]

Bonjour FlyingBaldy,

Merci pour votre aide !

J'ai copié à l'identique à l'exception des deux adresses IP et de l'adresse MAC.

Pas d'erreur de compilation.

Dans X-Plane « Données Entré/Sorties », j'ai coché la première case des numéros suivants :

3, 4, 13, 18, 62, 67, 96, 97, 105, 118 et 124

Mais il n'y a que l'affichage de l'adresse IP comme données et toutes les variables restent à 0.

J'ai dé-commenté ce qui pouvait l'être, mais rien ne s'affiche.

Après un petit test, il s'avère que le programme ne passe jamais la première condition :

  if (Udp.available())         // si paquet reçu

J'ai copié/coller le tout dans mon code pour ma télécommande de X-Plane avec afficheur LCD et il y a bien connexion Ethernet UDP entre Arduino et X-Plane et mes autres commandes fonctionnent.

Une idée du problème ?

Encore merci pour tout !

L'ami René
Tous pour un et un pour tous !

[Daniel_L]

Question basique.
Tu es allé dans l'option de menu suivante Connexions Réseau ?
Dans le dernier onglet Données, tu as coché la case IP Receveur de données et saisi l'adresse IP du destinataire de tes paquets UDP ?

Daniel

[Lami]

Bonjour Daniel,

Merci pour ton aide !

Comme cela :

C'est correct ?

Une idée du problème ?

L'ami René
Tous pour un et un pour tous !

[FlyingBaldy]

Bonjour Lami,

L'erreur est dans ta première copie d'écran.
Par défaut, X-Plane propose le port 49000. Il faut mettre 49001 car il s'agit du port du récepteur des informations UDP, ici la carte Arduino.
La case précédente doit contenir le numéro d'adresse IP qui est affiché par la routine Arduino (je suppose que c'est ce que tu as fait).

En résumé et pour être complet:
Laisser les ports UDP comme indiqué dans la deuxième figure ci-dessus (configuration par défaut de X-Plane):
49000 pour "port reçu sur" (il s'agit du port de l'ordinateur sur lequel X-Plane est installé)
49001 pour "port envoyé sur" (il s'agit du port d'envoi vers la carte Arduino)
Cette dernière valeur (49001) doit être recopiée dans la case de la figure 1 ci-dessus (par défaut, X-Plane propose, à tort selon moi, 49000).

Ensuite, selon le cas:
1. Si les adresses IP de votre réseau sont attribuées automatiquement par un serveur DHCP - ce qui est le cas dans la très grande majorité des installations (si vous ne savez pas quelle est votre installation, alors considérez que c'est un DHCP):
Raccorder la carte au PC via USB et au réseau via câble ethernet.
Lancer X-Plane puis le sketch Arduino.
Noter l'adresse IP qui est la première information affichée par le sketch Arduino.
Recopier cette valeur dans la case de la première figure ci-dessus.

Note : si vous ajoutez ou retirez un périphérique dans votre réseau (imprimante, scanner, PC...), il est possible que le serveur DHCP attribue automatiquement une autre adresse IP à votre carte Arduino.
Soyez vigilant. Si c'est le cas, il faudra modifier l'adresse IP dans X-Plane.

Enjoy your flight!

2. S'il n'y a pas de serveur DHCP et que vous attribuez les adresses IP manuellement):
Demandez-moi (il faut modifier légèrement le sketch Arduino en remplaçant l'instruction "IPAdress ip;" par "IPAdress ip (192, 168,1, 99);". Note "1, 99" est un exemple et doit être remplacé par l'adresse que vous avez choisie .
Recopiez cette adresse IP dans la cellule de la première figure ci-dessus.
Recompilez et téléchargez le sketch Arduino vers la carte.

C'est prêt, servez chaud!

[Lami]

Bonjour,

Merci Daniel et FlyingBaldy, c'était la bonne solution, j'ai maintenant autre chose que des zéros « 0 » sur mon écran Arduino LCD. Sans votre aide, j'aurais cherché très très très longtemps ! Alors, un gros MERCI !

Donc, la configuration de « Connections Internet », onglet « Données », c'est :

Après les images, en littéral, j'écrirais :

Configurer X-Plane avec la carte Arduino et son extension Ethernet

Dans X-Plane, menu « Paramètres », option « Connexions réseau », onglet « Données » :

Dans votre code source, copier l'adresse IP de la ligne « VOS adresses IP sont: ». Chez moi c'est : « 192.168.2.2 ».

Dans le code source, la ligne :

IPAddress ipx (192, 168, 1, 1); // mettre à jour selon l'adresse IP de votre PC

Qui devient :

IPAddress ipx (192.168.2.2); // mettre à jour selon l'adresse IP de votre PC

Dans X-Plane, dans la section centrale « IP pour la sortie Données » assurez-vous que la première boîte est cochée « [ x ] IP receveur de données (...) ».

Sur la même ligne, dans la boîte à 5 chiffres, entrez la valeur « 49001 ».

Pour éviter des changements de l'adresse IP de l'Arduino, je recommande de donner une adresse IP fixe.

Pour ce faire, je prends les trois premiers nombres de l'adresse de X-Plane, ici c'est « 192.168.2 ».

Pour le dernier nombre, je calcul le nombre d'ordinateur et de périphérique branchez sur le réseau local et je multiplie par deux pour me garder une grande marge de manœuvrer. Chez moi cela donne « 14 ».

Alors, sur la même ligne que le « 49001 », dans la boîte à 15 chiffres, j'entre l'adresse IP de la carte d’extension Arduino Ethernet « 192.168.2.14 ».

Je prends soin de copier cette adresse IP pour la carte Ethernet Arduino dans le code source comme ceci :

La ligne :

IPAddress ip ; // Adresse IP Arduino

Qui devient :

IPAddress ip (192.168.2.14); // Adresse IP Arduino

Et je commente la ligne :

ip = Ethernet.localIP(); // recherche adresse IP locale de la carte Arduino

Qui devient :

// ip = Ethernet.localIP(); // recherche adresse IP locale de la carte Arduino

Ou vous pourrez tout simplement l'effacer complètement.

Enregistrez les nouveaux paramètres de X-Plane en quittant et redémarrant le simulateur et compilé et charger le nouveau code dans votre carte Arduino.

Fin de la configuration de X-Plane et de la carte Arduino

J'ai écrit les précédentes lignes comme aide mémoire personnel, mais je présume que cela pourra en aider d'autres.

Encore un très grand merci pour votre aide !

Je retourne peaufiner mes affichages sur l'écran Arduino LCD.

L'ami René
Tous pour un et un pour tous !

[FlyingBaldy]

Excellente nouvelle.
Tes explications seront utiles pour le Wiki (lorsque nous aurons exploré et dévoilé tous les mystères de l'interface avec X-Plane et une Arduino).

Pour l'adresse fixe de la carte (192.168.1.14), ta méthode est bonne (nombre d'appareils fois deux), mais tu peux également commencer par le haut (192.168.1.254, 192.168.1.253 ...).
Avec tous les appareils interconnectés qui existent et qui vont nous envahir (NAS, frigo, TV, balance....), on n'est jamais assez prudent!

[Lami]

Excellente nouvelle.

Bonjour FlyingBaldy,

Je trouve aussi que c'est une excellente nouvelle !

Tes explications seront utiles pour le Wiki (lorsque nous aurons exploré et dévoilé tous les mystères de l'interface avec X-Plane et une Arduino).

Ça me trotte dans un coin de la tête, mais je redoute un peu ce moment, car je trouve son interface plutôt rustique et non naturelle d'approche. Mai j'y pense.

Pour l'adresse fixe de la carte (192.168.1.14), ta méthode est bonne (nombre d'appareils fois deux), mais tu peux également commencer par le haut (192.168.1.254, 192.168.1.253 ...)...

Ça, c'est bien visé, et plus simple encore que mon petit calcul, bien vu !

Merci pour tout !

L'ami René
Tous pour un et un pour tous !

[FlyingBaldy]

Que se passe-t-il si une broche n'est pas raccordée ("laissée en l'air")? Le récepteur ne sait pas comment considérer l'information.
Il est donc de bonne pratique d'imposer une valeur lorsqu'une broche n'est pas raccordée, par exemple :
« PULLUP for setting "High" when pin open (LOW when on the GND). » que l'on pourrait traduire par :
"Tirer le signal vers le haut pour qu'il soit au niveau "HAUT" lorsque la broche n'est pas raccordée (niveau BAS lorsqu'elle est raccordée à la masse)"
Cela veut dire que chaque broche non raccordée est en fait raccordée à la tension de référence (5V par exemple).

Pour être complet, cela signifie que lorsque l'interrupteur connecté à cette broche d'entrée bascule (=est activé), il doit envoyer un signal BAS (donc mise à la masse).
Par exemple pour un interrupteur, il suffit de connecter un côté de l'interrupteur à la broche d'entrée de l'Arduino et l'autre à la masse.
Sans action sur l'interrupteur, l'interrupteur est ouvert (pas de circuit fermé, c'est donc la résistance pull-up interne de l'Arduino qui va provoquer un signal HAUT).
Lorsqu'on actionne l'interrupteur, celui-ci ferme le circuit et connecte la broche de l'Arduino à la masse (niveau BAS.

Lorsqu'on choisit une entrée PULLUP (instruction "pinMode (x, INPUT_PULLUP)"), l'action de l'interrupteur doit donc être une mise à la masse (ce qui est facile à réalise puisqu'il ne faut pas mettre le montage électronique de l'interrupteur sous tension).
La programmation est donc : SI niveau BAS sur la broche (=interrupteur actionné) ALORS ACTION.

Si on choisit une entrée normale INPUT (instruction "pinMode (x, INPUT)"), le fonctionnement est : SI niveau HAUT sur la broche (=interrupteur actionné) ALORS ACTION.
Le dispositif électronique doit donc fournir une tension haute (3-5V lorsqu'il est actionné).

Méfiance donc.

[Lami]

Oui, méfiance pour moi !

Une phrase de PhM m'a bien aidé à comprendre « qui va assurer un niveau dit haut (la tension d'alimentation) lorsque le microcontrôleur ne fixe pas lui-même ce niveau pour quelque raison que ce soit. ».

Donc, s'il n'y a rien à faire sur la broche ou que rien ne se passe sur la broche en « INPUT_PULLUP », Arduino lui met du 5V en attente d'un changement d'état sur la broche. C'est bien ça ?

Pourquoi un tel mécanisme, ça me semble compliqué pour rien ?

Je comprends ce que vous décrivez, mais pourquoi un tel comportement, c'est ça qui me reste nébuleux ?

Est-ce pour pallier aux états fluctuants de la statique sur une broche d'entrée ou pour l'électromagnétisme ?

Pour moi, c'est comme bloquer la porte d'entrée en attendant une livraison, c'est à première vue, un non-sens.

Mais ne vous en faites pas avec mon incompréhension, en électricité, il y a bien des choses que je ne comprends pas.

L'ami René
Tous pour un et un pour tous !

[Lami]

Bonjour,

J'ai un problème pour sélectionner la radio en vue de modifier sa fréquence. J'ai essayé avec deux méthodes différentes sans succès.

Méthode 1 :

...
const int BOUTON_RADIO_NAV_1 = 0;
const int BOUTON_RADIO_NAV_2 = 1;
const int BOUTON_RADIO_COM_1 = 2;
const int BOUTON_RADIO_COM_2 = 3;
const int BOUTON_RADIO_ADF_1 = 4;
const int BOUTON_RADIO_ADF_2 = 5;
...
int RadiosActive = 0;
...
//************************************************** ***************************
// FONCTION EnvoyerDonneesX_Plane
//************************************************** ***************************
void EnvoyerDonneesX_Plane (char DonneesDeReference[], float Donnees_A_Communiquer)
// Send PaquetUDP_Donnees ( PaquetUDP_Donnees and ValeurFormat1Float)
{
int n = 0;
while (DonneesDeReference [n])
{
PaquetUDP_Donnees [n] = DonneesDeReference [n];
n = n + 1;
}
for (int i = n; i < 500; i = i + 1)
{
PaquetUDP_Donnees [i] = char (32);
}
CarteEthernetUDP.beginPacket (X_PLANE_ADRESSE_IP, X_PLANE_ADRESSE_UDP);
CarteEthernetUDP.write ("DREF0");
TemponComUDP.ValeurFormat1Float = Donnees_A_Communiquer;
for (int i = 0; i < 4; i = i + 1)
{
CarteEthernetUDP.write (TemponComUDP.ValeurFormat4Byte [i]);
}
CarteEthernetUDP.write (PaquetUDP_Donnees);
CarteEthernetUDP.endPacket ();
}
//************************************************** ***************************
...
RadiosActive = BOUTON_RADIO_COM_2;
EnvoyerDonneesX_Plane ("sim/cockpit/radios/nav_com_adf_mode", RadiosActive);
/* DataRefs.txt
sim/cockpit2/radios/actuators/nav_com_adf_mode int y enum Frequency-to-change selection for the all-in-one radio, 0->5 are Nav1, Nav2, Com1, Com2, ADF1, ADF2.
*/
...

Méthode 2 :

...
//************************************************** ***************************
// FONCTION EnvoyerCommandeX_Plane
//************************************************** ***************************
void EnvoyerCommandeX_Plane (char Donnees_A_Communiquer [])
{
CodeSituation = 50;
CarteEthernetUDP.beginPacket (X_PLANE_ADRESSE_IP, X_PLANE_ADRESSE_UDP);
CarteEthernetUDP.write ("CMND0");
CarteEthernetUDP.write (Donnees_A_Communiquer);
CarteEthernetUDP.endPacket ();
}
//************************************************** ***************************
...
EnvoyerCommandeX_Plane ("sim/audio_panel/select_audio_nav1");
EnvoyerCommandeX_Plane ("sim/audio_panel/select_audio_com1");
EnvoyerCommandeX_Plane ("sim/audio_panel/select_audio_adf1");
EnvoyerCommandeX_Plane ("sim/audio_panel/select_audio_nav2");
EnvoyerCommandeX_Plane ("sim/audio_panel/select_audio_com2");
EnvoyerCommandeX_Plane ("sim/audio_panel/select_audio_adf2");

/* Commands.txt
sim/audio_panel/select_audio_nav1 Select audio: NAV1.
sim/audio_panel/select_audio_nav2 Select audio: NAV2.
sim/audio_panel/select_audio_com1 Select audio: COM1.
sim/audio_panel/select_audio_com2 Select audio: COM2.
sim/audio_panel/select_audio_adf1 Select audio: ADF2.
sim/audio_panel/select_audio_adf2 Select audio: ADF2.
*/
...

Il me semble que chacune de ces méthodes devraient fonctionner, mais aucune ne marche ?

Vous pourriez me donner une piste de solution, ou la solution ?

Merci par avance !

L'ami René
Tous pour un et un pour tous !

[Lami]

En passant, pour informer les curieux, un montage pour télécommander X-Plane, avec une carte Arduino Mega R3, une carte d'extension Ethernet, un capteur infrarouge, la télécommande, un buzzer et un petit écran LCD 20 x 4, ça ressemble à cela :

L'ami René
Tous pour un et un pour tous !