See site in english Voir le site en francais
Website skin:
home  download  forum  link  contact

Welcome, Guest. Please login or register.
Did you miss your activation email?

Login with username, password and session length

Author Topic: Arduino Uno + Orbiter  (Read 61031 times)

0 Members and 1 Guest are viewing this topic.

Offline hysot

  • Full Member
  • ***
  • Posts: 110
  • Country: Canada ca
  • Karma: 8
26 October 2013, 01:35:16
Bonjour tout le monde!

Depuis une petite semaine je me suis lancé dans l’étude de la réalisation d'un panel pour Orbiter.
Oui juste un panel et non un cockpit. Je déménage régulièrement et souhaite avoir quelques chose de facilement transportable. Donc je prévois une série d'interrupteurs, de bouton poussoir, un écran de PC pour les deux MFDs et le tout agrémenté de LEDs.

Pour réaliser tout ça j'utilise une Arduino Uno R3 que j'ai modifié pour qu'elle émule un clavier. L'avantage de l'Arduino c'est qu'on peut faire bien plus qu'émuler un clavier. On peut notamment commander des LEDs (bien qu’indépendantes d'Orbiter).
J'ai voulu faire simple et surtout faire a ma portée, donc j'ai laisse tombe Orb:connect bien trop complexe pour moi et très peu documenté. D’où la solution d’émuler un clavier.

Je suis pour le moment dans la phase de test des codes donc pas de superbes photos de construction.
Comme j'arrive a des resultats assez convainquant jusqu’à présent je souhaite partager mes travaux avec la communauté. Je trouve qu'il n'y a pas assez d'info ou même de tutoriel sur la réalisation de ce genre de montage basé sur l'utilisation d'une Arduino.


La première étape de mon projet a été de faire en sorte que l'Arduino émule un clavier. En effet, de base, l'Arduino Uno est reconnue comme un périphérique série et non comme un périphérique usb, encore moins comme un clavier.
Comment changer tout ça? L'arduino Uno R3 est munie de la puce ATMega16U2 qui est codée (firmware) de façon a être identifié comme un périphérique série.  Il va falloir changer ce firmware pour que le PC la reconnaisse comme un clavier.

(La méthode suivante est destinée pour Windows et par du principe que le logiciel IDE Arduino 1.0.5 est installé ainsi que le driver pour l'Arduino Uno R3 – L'érduino doit être reconnue comme un périphérique série dans le gestionnaire de périphérique de Windows. Je n'invente rien, je n'ai fait que suivre les infos trouvées ici et la sur le net dont cette vidéo. Je prends juste le temps de mettre tout ça en français)

1- Pour se faire vous aller avoir besoin du programme FLIP de ATMEL que vous trouverez ici
Sélectionner la version "Java Runtime Environement included".
Téléchargez la et installez la.

2- Ensuite vous allez avoir besoin de télécharger le nouveau Firmware Arduino-keyboard-0.3.hex sur cette page
Une fois télécharger déplacer le fichier .hex dans le dossier du logiciel IDE Arduino 1.0.5

C:/Program Files/Arduino/hardware/arduino/firmwares/atmegaxxu2/arduino-usbserial

Dans ce dossier vous y trouverez d'autres fichier en .hex . Ce sont d'autres firmwares. Il y en a pour la Arduino Mega mais il y a aussi le Firmware d'origine de votre Uno R3. Pas besoin de le télécharger pour le remettre, il est ici et il vous servira pour plus tard. J'y viendrai.

3- Enfin avant de se lancer dans l'aventure, il vous faudra télécharger la librairie HIDKeyboard qui vous permettra de rédiger les programmes. Télécharger la >>ici<<< en cliquant sur "Download ZIP" dans la colonne de droite.

Voila, êtes vous prêts a flasher votre Arduino? Elle ne sentira rien ne vous inquiétez pas mais sachez que je ne serais en aucun cas responsable si ça tourne mal ;). Donc faites le si vous vous en sentez capable :)

4- On va d'abord passer l'Arduino en mode DFU (Device Firmware Upgrade ). Pour cela, munissez vous d'un bout de câble et reliez ensemble les deux pins comme indiquez sur la photo jusqu'a ce que la LED intégrée et reliée a la pin 13 se mette a clignoter très rapidement confirmant le passage au mode DFU. . Attention repérez bien l'emplacement de ces pins. J'ai pris soins de prendre une belle photo et d'y mettre des annotations!!




5- Vous devriez entendre votre Arduino se déconnecter et se reconnecter et Windows va certainement chercher un driver mais n'en trouvera pas. Allez donc dans le gestionnaire de périphériques ou vous y trouverez un périphérique inconnue. Clic droit dessus puis “mise a jour des drivers” et choisissez de parcourir votre ordinateur.
Par chance ce driver a été téléchargé en même temps que FLIP. Pointez ce dossier et Windows fera le reste:

Program Files/Atmel/Flip 3.4.7/usb

6- Lancez le programme FLIP. Cliquez sur l’icône en haut a gauche (en forme de composant électronique) et sélectionnez ATMega16U2 dans la liste qui apparait.

7- L’icône câble Usb, a droit de l’icône composant électronique, devrait devenir cliquable. Cliquez dessus et sélectionnez "usb" puis cliquez sur "open". L'ensemble des icônes devrait devenir actif et “USB ON” devrait remplacer “COMMUNICATION OFF” en bas a droite de la fenêtre.

8- Veillez a ce que les 4 étapes au dessus du bouton “RUN” soient cochées.

9- Chargez le fichiez .hex en cliquant sur “LOAD HEX FILES” (icône livre avec une flèche pointant vers le bas). Sélectionnez le fichier Arduino-keyboard-0.3.hex précédemment téléchargé.

10- Cliquez sur “RUN”. Une barre de téléchargement devrait apparaitre.

11- Débranchez votre Arduino puis rebranchez la. Windows devrait la reconnaitre comme un nouveau périphérique usb et devrait installer un nouveau driver qui rendra l'Arduino visible comme un clavier.

Et Voila votre Arduino émule désormais un clavier !!
Vous êtes content? Ben maintenant il va falloir tout refaire pour remettre l'ancien firmware sur l'Arduino (Arduino-usbserial-uno.hex). Pourquoi? Tout simplement car vous ne pouvez uploader de programme sur votre Arduino qu'avec le firmware d'origine. Le logiciel IDE Arduino ne peut accéder qu'a des périphériques série.
Développer un code et le tester va impliquer un va et vient entre le firmware d'origine et le firmware émulateur de clavier.

On va maintenant faire un petit test pour vérifier que tout fonctionne parfaitement.
Extrayez l'archive UNO-HIDKeyboard-Library-master et renommer le dossier cree "HIDKeyboard". Le logiciel Arduino n'aime pas les noms de librairie avec des caractères loufoques. Déplacez ou copiez ce dossier dans le dossier suivant:

~Program Files/Arduino/librairies

Ouvrer le logiciel Arduino et vérifiez que la nouvelle librairie a été installée:

Cliquez dans le menu sur Sketch >Import library. Vous devriez trouver dans la liste deroulante "HIDKeyboard"
Si il n'y est pas, cliquez sur "Add library" en haut de cette liste et sélectionnez le dossier HIDKeyboard dans votre dossier Arduino.

Maintenant faites "files > examples > HIDKeyboard > Browser"
Le programme Browser s'ouvre.

Si vous ne l'avez pas encore fait, réinstallez le firmware d'origine de votre Arduino en suivant exactement la même procédure vu précédemment mais en utilisant le firmware Arduino-usbserial-uno.hex que vous trouverez, sans surprise, ici:

C:/Program Files/Arduino/hardware/arduino/firmwares/atmegaxxu2/arduino-usbserial

Une fois ceci fait, uploader le programme "Browse" dans votre Uno et refaite la manip pour installer le firmware Keyboard.
Si tout se passe bien, une page internet devrait s'ouvrir a l'adresse suivante : www.sparkfun.com

Je vous détaillerais plus tard comment utilisez cette librairie mais c'est relativement simple.
Lisez le "Read me" qui se trouve dans le dossier HIDKeyboard.

Et voila pour un premier Tuto. Bientot je partagerais mon premier programme pour orbiter. Je dois le remettre en forme mais il fonctionne! pour preuve:
<a href="http://www.youtube.com/watch?v=vccAhepP2KM" target="_blank">http://www.youtube.com/watch?v=vccAhepP2KM</a>

hysot

Offline DanSteph

  • Administrator
  • Legend
  • *****
  • Posts: 15001
  • Karma: 175
  • Hein, quoi !?
    • FsPassengers
Reply #1 - 26 October 2013, 01:42:38
Wow, je suis admiratif !  :wor:

« Last Edit: 26 October 2013, 02:13:28 by DanSteph »

Offline Fast_toche

  • Legend
  • ******
  • Posts: 1329
  • Country: France fr
  • Karma: 34
  • Time is nothing...
Reply #2 - 26 October 2013, 01:54:30
Chapeau bas! Trés interessant en plus! :wor:


Offline hysot

  • Full Member
  • ***
  • Posts: 110
  • Country: Canada ca
  • Karma: 8
Reply #3 - 26 October 2013, 01:57:49
Merci! J’espère que mes explications futures aideront d'autres a se lancer. C'est incroyable ce qu'on peux faire avec une Arduino a 20e.

hysot

Offline nulentout

  • Legend
  • ******
  • Posts: 3264
  • Country: France fr
  • Karma: 220
Reply #4 - 26 October 2013, 10:22:34
Voui voui voui, c'est tout à fait interessant pour ceux qui désirent se créer un tableau de bord.
Perso j'attend de voir (Par curiosité) comment tu fais pour partir d'un bouton électrique quelconque générer par cet émulareur clavier un ou des caractères et ainsi interfacer Orbiter. Ton approche est sympa vu qu'elle élimine toutes les couches logicielles de gestion de l'USB.
Bravo, c'est très accrocheur comme activité : Nulentout

La sagesse est un trésor ... tellement bien caché.

Offline Joffrey

  • Global Moderator
  • Legend
  • *****
  • Posts: 933
  • Country: France fr
  • Karma: 52
  • L'intelligence cruelle rend soluble.
Reply #5 - 26 October 2013, 13:42:53
Et bien et bien, c'est vraiment sympa tout ça !


Offline hysot

  • Full Member
  • ***
  • Posts: 110
  • Country: Canada ca
  • Karma: 8
Reply #6 - 26 October 2013, 16:02:16
Voui voui voui, c'est tout à fait interessant pour ceux qui désirent se créer un tableau de bord.
Perso j'attend de voir (Par curiosité) comment tu fais pour partir d'un bouton électrique quelconque générer par cet émulareur clavier un ou des caractères et ainsi interfacer Orbiter. Ton approche est sympa vu qu'elle élimine toutes les couches logicielles de gestion de l'USB.
Bravo, c'est très accrocheur comme activité : Nulentout

Je devrais poster le programme dans la journée. Il faut juste comprendre que L'arduino ne fait qu'envoyer des impulsions de touches a chaque changement d’état d'un interrupteur. Orbiter ne lui envoie aucunes données. J'ai rédigé le programme de l'arduino pour que les LEDs s'allume en fonction de la position des interrupteurs. Ce programme est indépendant d'Orbiter et peut être sujet a des désynchronisations.

« Last Edit: 26 October 2013, 18:23:50 by hysot »
hysot

Offline Well

  • Legend
  • ******
  • Posts: 2722
  • Karma: 46
    • L'Atelier Wellographique
Reply #7 - 26 October 2013, 16:55:18
Joli travail ! Félicitation  ;)


Offline Manu-RT

  • Ce n'est pas le monde qui change, c'est l'homme qui l'idéalise.
  • Hero Member
  • *****
  • Posts: 754
  • Country: France fr
  • Karma: 23
  • Hey!
Reply #8 - 26 October 2013, 21:56:12
C'est incroyable  :eek: il faudrait faire un "gros" simulateur avec orbiter
http://www.flightexperience.fr/


Offline hysot

  • Full Member
  • ***
  • Posts: 110
  • Country: Canada ca
  • Karma: 8
Reply #9 - 27 October 2013, 00:14:40
Je poursuis avec la programmation de l'Arduino Uno R3
Je vais vous présenter quelques exemples basiques qui pourront s'appliquer a Orbiter, puis je vous montrerai le programme que j'ai réalisé.
Je n'ai aucune prétention, je partage simplement avec vous mes travaux. Je débute en programmation et mon programme pourra certainement être amélioré. Mon but est simplement d’étoffer un peu plus la documentation pour la réalisation de simpit pour orbiter. Ça serait d’ailleurs cool que d'autres face de même pour Orb:connect  :badsmile:

Le bouton poussoir

C'est la base de l’émulation clavier. Reprendre le principe de la touche clavier. On appuie sur le bouton, la carte ecrit la lettre correspondante (définis dans le programme), on relâche le bouton. Si on maintient le bouton appuyé, la carte enverra continuellement la lettre jusqu’à ce que le bouton soit relâché.

Voici le schéma électrique a réaliser pour cette exemple (schéma du site Arduino.cc)

La valeur de la résistance est 10 K ohms

Pour l’émulation clavier, nous allons devoir utiliser la librairie HIDKeyboard. Les librairies nous permettent d'utiliser de nouvelles fonctionnalités inexistantes de base. Pour utiliser cette libraire nous allons l'inclure au début du programme puis l'initialiser par ces deux lignes de commande:

Code: [Select]
#include <HIDKeyboard.h>

HIDKeyboard keyboard;

Ensuite nous allons déclarer quelques variables. La première va indiquer sur quelle Pin lire le statut du bouton, c'est a dire si le bouton est appuyé ou non. Si on appuie sur le bouton, le circuit sera ferme et un courant électrique sera envoyé a cette Pin.
C'est la Pin numéro 2 sur notre schéma.

Code: [Select]
#include <HIDKeyboard.h>

HIDKeyboard keyboard;

int Buttonpin = 2;

La seconde variable a déclarer va être celle qui va nous donner l’état du bouton. Appuyé ou sur ON (HIGH), relâché ou sur OFF (LOW). On lui donnera la valeur 0 pour le moment.

Code: [Select]
#include <HIDKeyboard.h>

HIDKeyboard keyboard;

int Buttonpin = 2;                              //Le bouton est branche sur la pin 2
int ButtonState = 0;                         //L’état de du bouton: ON (HIGH) ou OFF (HIGH). On lui donne pour le moment la valeur 0

Maintenant que les variables ont été déclarées nous allons les initialiser dans le setup. Le setup ne sera lu qu'une seule fois.
Nous allons initialiser la variable Buttonpin comme une entrée. En effet, la pin 2 recevra du courant. Si une pin est utilisée pour allumer une LED comme nous le verrons plus tard, elle devra être initialisée comme une sortie car elle enverra du courant dans le circuit. C'est une étape très importante.

Code: [Select]
#include <HIDKeyboard.h>

HIDKeyboard keyboard;

int Buttonpin = 2;                              //Le bouton est branche sur la pin 2
int ButtonState = 0;                         //L’état de du bouton: ON (HIGH) ou OFF (HIGH). On lui donne pour le moment la valeur 0

void setup()
{
  pinMode(Buttonpin, INPUT);                //On initialise la pin 2 comme une entrée
}

L'initialisation suivante est celle de la communication avec l'ordinateur. On commence la communication puis on attend 2 secondes pour que l'arduino soit reconnue comme un clavier

Code: [Select]
#include <HIDKeyboard.h>

HIDKeyboard keyboard;

int Buttonpin = 2;                              //Le bouton est branche sur la pin 2
int ButtonState = 0;                         //L’état du bouton: ON (HIGH) ou OFF (HIGH). On lui donne pour le moment la valeur 0

void setup()
{
  pinMode(Buttonpin, INPUT);                //On initialise la pin 2 comme une entrée
 
  keyboard.begin();                                // Commence la communication
  delay(2000);                                       // Attend que le périphérique soit reconnue comme un clavier
}

Nous allons maintenant créer une boucle (loop) qui sera lue et relue continuellement. C'est dans cette boucle que nous allons mettre les actions a réaliser.
Pour écrire la lettre A par exemple, il va falloir que l'on sache l’état du bouton. Est il sur ON (HIGH) ou sur OFF (LOW). Pour cela on va devoir aller lire la pin 2 pour voir si du courant y passe ou non et on stockera son état dans la variable ButtonState.

Code: [Select]
#include <HIDKeyboard.h>

HIDKeyboard keyboard;

int Buttonpin = 2;                              //Le bouton est branche sur la pin 2
int ButtonState = 0;                          //L’état du bouton: ON (HIGH) ou OFF (HIGH). On lui donne pour le moment la valeur 0

void setup()
{
  pinMode(Buttonpin, INPUT);                //On initialise la pin 2 comme une entrée
 
  keyboard.begin();                                // Commence la communication
  delay(2000);                                       // Attend que le périphérique soit reconnue comme un clavier
}

void loop()
{
  ButtonState = digitalRead(Buttonpin);     //On lit l’état de la pin 2 et on le stocke dans la variable ButtonState
}

Nous voulons écrire la lettre A que si on appuie sur le bouton. Si on ne touche pas au bouton, rien ne doit être envoyé.
On va donc utiliser une condition "if". SI le bouton est appuyé alors écrire la lettre A. Pour écrire la lettre A, on simule l'appuie sur la touche A, attendre 100ms, puis relâcher la touche.


Code: [Select]
#include <HIDKeyboard.h>

HIDKeyboard keyboard;

int Buttonpin = 2;                              //Le bouton est branche sur la pin 2
int ButtonState = 0;                          //L’état du bouton: ON (HIGH) ou OFF (HIGH). On lui donne pour le moment la valeur 0

void setup()
{
  pinMode(Buttonpin, INPUT);                //On initialise la pin 2 comme une entrée
 
  keyboard.begin();                                // Commence la communication
  delay(2000);                                       // Attend que le périphérique soit reconnue comme un clavier
}

void loop()
{
  ButtonState = digitalRead(Buttonpin);     //On lit l’état de la pin 2 et on le stocke dans la variable ButtonState
 
  if (ButtonState == HIGH)                  //Si le bouton est appuyé, écrire la lettre A
  {
    keyboard.pressKey('A');
    delay(100);
    keyboard.releaseKey();
    delay(50);
  }
}

J'ai ajoute un "delay(50);" pour attendre 50ms après l'appuie pour être sur que la lettre A est écrite une seule fois par impulsion.
Voila pour le bouton poussoir! Pour tester le programme je vous conseille d'ouvrir Notepad avant d'appuyer sur le bouton.

L'interrupteur

Nous allons modifier légèrement le programme précédant pour permettre l'utilisation d'interrupteur deux positions.
Le schéma électrique est le même. Si vous avez un interrupteur sous la main, vous pouvez le mettre a la place du bouton poussoir, sinon il vous suffira de simuler les deux états en gardant le bouton appuyé.

Qu'est ce que nous voulons que le programme fasse? Vous voulez que la lettre A soit envoyée a chaque changement de position de l'interrupteur et qu'elle soit envoyée une seule vois. Pour détecter un changement d’état, il suffit de comparer l’état précédent avec le nouvel état. La lettre A devra être envoyée a chaque fois que ces états diffèrent. Comme cette ligne de commande sera inscrite dans la boucle du programme, ces états seront comparés plusieurs fois par seconde.
Nous allons donc déclarer une nouvelle variable ou l'on stockera l’état précédent de l'interrupteur:

Code: [Select]
#include <HIDKeyboard.h>                    // Inclue la librairie HIDKeyboard au programme

HIDKeyboard keyboard;                       // Initialise la librairie

int Buttonpin = 2;                           //Le bouton est branche sur la pin 2
int ButtonState = 0;                        //L’état du bouton: ON (HIGH) ou OFF (HIGH). On lui donne pour le moment la valeur 0
int PreviousButtonState = 0;            //Le précédent état du bouton

Ensuite nous allons devoir vérifier si le bouton a changé d’état.

Code: [Select]
#include <HIDKeyboard.h>                    // Inclue la librairie HIDKeyboard au programme

HIDKeyboard keyboard;                       // Initialise la librairie

int Buttonpin = 2;                          //Le bouton est branche sur la pin 2
int ButtonState = 0;                        //L'etat du bouton: ON (HIGH) ou OFF (HIGH). On lui donne pour le moment la valeur 0
int PreviousButtonState = 0;                //Le precedent etat du bouton

void setup()
{
  pinMode(Buttonpin, INPUT);                //On initialise la pin 2 comme une entree
 
  keyboard.begin();                         // Commence la communication
  delay(2000);                              // Attend que le peripherique soit reconnue comme un clavier
}

void loop()
{
  ButtonState = digitalRead(Buttonpin);     //On lit l'etat de la pin 2 et on le stocke dans la variable ButtonState
 
  if (ButtonState != PreviousButtonState)   //On compare les deux états. Si ils différents, la condition est validée et on écrit la lettre A
  {
    PreviousButtonState = ButtonState;      //On enregistre le nouvel état du bouton dans la variable PreviousButtonState pour
                                                             //la prochaine boucle.
    keyboard.pressKey('A');
    delay(100);
    keyboard.releaseKey();
    delay(50);
  }
}

Et voila vous pouvez désormais utiliser des boutons poussoir :)

Allumer une LED avec un interrupteur

Enfin je voudrai juste vous montrer comment allumer une LED en utilisant la condition if...else. Cette condition est a deux entrées, si (if) l'interrupteur est sur ON on allume la LED, sinon (else) on éteint la LED.

Code: [Select]
#include <HIDKeyboard.h>                    // Inclue la librairie HIDKeyboard au programme

HIDKeyboard keyboard;                       // Initialise la librairie

int Buttonpin = 2;                          //Le bouton est branche sur la pin 2
int ButtonState = 0;                        //L'etat du bouton: ON (HIGH) ou OFF (HIGH). On lui donne pour le moment la valeur 0
int PreviousButtonState = 0;                //Le precedent etat du bouton

int Ledpin = 13;                            //La LED est branche sur la pin 13
int LedState = 0;                           //L'etat de la LED

void setup()
{
  pinMode(Buttonpin, INPUT);                //On initialise la pin 2 comme une entree
  pinMode(Ledpin, OUTPUT);                  //On initialise la pin 13 comme une sortie
 
 
  keyboard.begin();                         // Commence la communication
  delay(2000);                              // Attend que le peripherique soit reconnue comme un clavier
}

void loop()
{
  ButtonState = digitalRead(Buttonpin);     //On lit l'etat de la pin 2 et on le stocke dans la variable ButtonState
 
  if (ButtonState != PreviousButtonState)   //On compare les deux etats. Si ils differents, la condition est validee et on ecrit la lettre A
  {
    PreviousButtonState = ButtonState;      //On enregistre le nouvel etat du bouton dans la variable PreviousButtonState.
    keyboard.pressKey('A');
    delay(100);
    keyboard.releaseKey();
    delay(50);
  }
  if(ButtonState == HIGH)                  //Si l'interrupteur est sur ON
  {
    LedState = HIGH;                       //On allume la LED
  }
    else                                   //Sinon
  {
    LedState = LOW;                        //On eteind la LED
  }
  digitalWrite(Ledpin, LedState);      //Enfin on envoie le nouvel état de la LED a la pin 13 pour que la LED s'allume
 
}

Piouf voila pour les bases de l’émulation clavier avec l'Arduino. Ensuite avec un peu plus de connaissance on peut jouer avec des compteurs, avec plus de variables,....

Finalement je vais vous laisser digérer ça et je repasserais demain avec mon programme :). Je vous remercie de votre attention, je sais c’était long!


« Last Edit: 27 October 2013, 00:22:55 by hysot »
hysot

Offline antoo

  • Legend
  • ******
  • Posts: 3531
  • Country: France fr
  • Karma: 149
  • 2, breaking left!
    • Forum de mon Asso d'Echasses Urbaines
Reply #10 - 27 October 2013, 21:35:05
c'est merveilleux!
Mon frère et moi avons fait à peu près le même chose (http://orbiter.dansteph.com/forum/index.php?topic=5587.msg78517#msg78517 ou bien http://spartacus-megatronic.blogspot.fr/p/lll.html ) ... mais avec des prises de tête terribles au niveau programmation!
Tu as l'air très à l'aise, je t'encourage et te soutiens, un super départ!

---------------------------------------------------------------------------------------------------
"ET C´EST PARTI!!" Youri Gagarine au lancement de vostok 1 le 12 avril 1961
Ma chaîne Youtube : Airsoft, FPS, Simulation : http://www.youtube.com/channel/UCrzIPMeULZU6lR4M6DVsH2g

Offline hysot

  • Full Member
  • ***
  • Posts: 110
  • Country: Canada ca
  • Karma: 8
Reply #11 - 27 October 2013, 21:53:11
Merci!
Oui j'ai suivie votre programme dans l'ombre. Mais je n'aurais pas la place de faire si gros.
Beau boulot!

hysot

Offline nulentout

  • Legend
  • ******
  • Posts: 3264
  • Country: France fr
  • Karma: 220
Reply #12 - 28 October 2013, 18:09:17
Bonjour les copains,
Juste une petite question : Quand tu dis que "si l'on laisse le bouton enfoncé le système envoie la lettre en répétition", s'agit t'il d'un caractère au format IBM, c'est à dire début de caractère, puis code du caractère en répétition jusqu'au relacher du bouton, alors seulement la fin de caractère est envoyée ?
Autre question : Si on utilise un inverseur ... il ne faut pas de répétition à l'état stable. Bref, c'est pas simple l'émulation d'un tableau de bord vers une interface clavier.

La sagesse est un trésor ... tellement bien caché.

Offline hysot

  • Full Member
  • ***
  • Posts: 110
  • Country: Canada ca
  • Karma: 8
Reply #13 - 28 October 2013, 22:01:25
Si tu ouvres ton éditeur de texte et que tu maintiens le bouton poussoir appuyé, tu verras "GGGGGGGGGGGGGG" si tu as programme la carte pour qu'elle t'envoie la lettre G.
Donc logiquement dans orbiter tu auras l'interrupteur du train d'atterrissage qui va basculer entre les deux positions très rapidement.

Alors que pour l'interrupteur, toujours dans ton editeur de texte du verra la lettre "G" apparaitre quand tu passeras ton interrupteur sur ON et la lettre "G" apparaitra une seconde fois quand tu passeras ton interrupteur sur OFF.

Post Merge: 28 October 2013, 23:03:46
Je réfléchis a un truc qui pourrais être ajoute. Je pourrais prendre en considération les 110 minutes de réserves de l'APU. Un compteur viendrait décrémenter ce compteur a chaque fois que l'APU est en marche. Ce qui permettrait de ne pas allumer la LED de l'APU si sa réserve de carburant est vide. Un Ecran LCD et un Potar pourrait être ajoute pour régler ce compteur si par exemple on eteind Orbiter pour X raison (bug, interruption de la mission pour aller faire dodo,...). C'est peut etre beaucoup pour pas grand chose. on va dire que ca pourrait juste être marrant de le programmer.

Je travaille encore sur mon bout de programme, J’essaie d’intégrer un interrupteur pour choisir entre XR5 et XR2. Cette interrupteur viendrait changer des compteurs et désactiver des boutons/interrupteurs. Par exemple les portes de la soute cargo mettent 20 secondes pour s'ouvrir sur le XR2 et 30 sur le XR2. Ça éviterait des décalages.

J'ai ajoute une fonction actionnée par un interrupteur qui va désactiver l'envoi de touche au PC. Ça me permettra rapidement de changer la position d’où bouton/interrupteur en cas de désynchronisation avec Orbiter.

Post Merge: 29 October 2013, 02:10:06
Bon voila mon bout de programme.
Il n'y a que l'interrupteur/LED pour l'APU, l'interrupteur/LEDs pour l'ouverture/fermeture du cone avant et l'interrupteur Interruption de l'envoi des impulsions de touche clavier.
En gros que fait ce programme:
 - envoi de CTRL A a chaque changement de position de l'interrupteur APU
 - Clignotement de la LED APU pendant 2,5 secs (cf doc des XR) puis extinction ou allumage continu de la LED.
 - envoi de CTRL K a chaque changement de position de l'interrupteur Nose Cone
 - Clignotement de la LED jaune Transit pendant 20 secs (cf doc des XR) puis extinction ou allumage continu de la LED verte Open.
 - Si la l'APU est éteinte, aucunes LED de l'interrupteur Nose Cone ne s'allumera mais CTRL-K sera tout de même envoyé pour recevoir le message d'alerte (Warning APU offline) sur le HUD tertiaire.
 - Le clignotement de la LED jaune Transit s'adapte au temps de transit. Si l'on vient interrompre la séquence d'ouverte au bout de 11 secondes, la LED clignotera pendant 11 secs et non 20 pendant la séquence de fermeture. De même pour une séquence fermeture/ouverture.
 - L'interrupteur Arduino/PC COMM sert a interrompre l'envoi d'impulsion de touche clavier au PC. Tres pratique si par malchance un interrupteur du panel est sur OFF et non sur ON comme sur orbiter. Passez l'interrupteur Arduino/PC COMM sur OFF et repositionnez l'interrupteur sur ON. Inconvénient, les LEDs continueront de fonctionner.

Voici le circuit:



Les interrupteurs sont ici représentes par des boutons poussoirs.
Les résistances reliées aux interrupteurs sont des 10K Ohms.
Les résistances reliées aux LED sont des 330 Ohms

Et voila le code. J'ai prise soin d'ajouter pleins d'annotation pour expliquer chacune des lignes de codes. Vous les trouverez après les //

Code: [Select]
/*********************************************************************************
 * OrbiterPanel.ino
 * Written by Yoan SOILEN, October 22, 2013
 *
 * NOTE: This example will not work on a "normal" UNO. It requires that the
 * arduino-keyboard firmware be installed on the ATMega8U2. Please see
 *   https://github.com/SFE-Chris/UNO-HIDKeyboard-Library
 *
 *
 ********************************************************************************/

#include <HIDKeyboard.h>                 //Include the Library HIDKeyboard to the program

HIDKeyboard keyboard;                    // Initialize HIDKeyboard object


//------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
//----------VARIABLES COMM ARDUINO/PC-----------------------------------------------------------------------------------------------------------------------

int Switchpin = 13;                      // L'interrupteur de l'Arduino/PC COMM est branche sur la pin 13
int SwitchState = 0;                     // L’état de l'interrupteur de l'Arduino/PC COMM: ON (HIGH) ou OFF (HIGH).

//------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
//----------VARIABLES DE L'INTERRUPTEUR DE L'APU------------------------------------------------------------------------------------------------------

int LedAPUpin = 9;                       // La LED de l'APU est branchée sur la pin 9
int SwitchAPUpin = 8;                    // L'interrupteur de l'APU est branché sur la pin 8

int LedAPUState = LOW;                   // Enverra la valeur 1 (HIGH) ou 0 (LOW) a la LED de l'APU pour l'allumer ou l'éteindre

int SwitchAPUState = 0;                  // L’état de l'interrupteur de l'APU: ON (HIGH) ou OFF (HIGH).
int PreviousSwitchAPUState = 0;          // L’état précédent de l'interrupteur : ON (HIGH) ou OFF (HIGH).

int apu = 0;                             // Variable utilisée pour éviter de faire clignoter la LED juste après la mise en route de l'Arduino

unsigned long PreviousAPUMillis = 0;     // Stockera la dernière fois que la LED a été mise a jour (en ms)
unsigned long currentAPUMillis = 0;      // Enregistrera le temps indique par l'horloge (ms)
unsigned long SwitchAPUTimer = 0;        // Sera utilise pour savoir quand commencer a compter les 2.5 secs


//------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
//-----------VARIABLES DE L'INTERRUPTEUR D'OUVERTURE/FERMETURE DU CONE DE NEZ---------------------------------------------------------------------------------------------------------

int LedNCOpenpin = 10;                    // La LED verte qui indiquera si le cône est ouvert est branchée sur la pin 10
int LedNCTransitpin = 11;                  // La LED jaune qui indiquera si le cône s'ouvre ou se ferme est branchée sur la pin 11
int SwitchNCpin = 12;                       // L'interrupteur du cône est branche sur la pin 12

int LedNCOpenState = LOW;             // Enverra la valeur 1 (HIGH) ou 0 (LOW) a la LED verte pour l'allumer ou l’éteindre
int LedNCTransitState = LOW;           // Enverra la valeur 1 (HIGH) ou 0 (LOW) a la LED jaune pour l'allumer ou l’éteindre

int SwitchNCState = 0;                      // L’état de l'interrupteur du cône: ON (HIGH) ou OFF (HIGH)
int PreviousSwitchNCState = 0;          // L’état précédent de l'interrupteur: ON (HIGH) ou OFF (HIGH)

int nc = 0;                                  // Variable utilisée pour éviter de faire clignoter la LED juste après la mise en route de l'Arduino

unsigned long PreviousNCMillis = 0;     // Stockera la dernière fois que la LED a été mise a jour (en ms)
unsigned long currentNCMillis = 0;        // Enregistrera le temps indique par l'horloge (ms)
unsigned long SwitchNCTimer = 0;       // Sera utilise pour savoir quand commencer a compter les 2.5 secs
unsigned long TimerNC = 0;                // Sera utilise pour savoir combien de temps la LED clignotera.


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


void setup()
{
  //-------COMM ARDUINO/PC------------------------------------------------------------------ 
  pinMode(Switchpin, INPUT);                   // initialise la pin comme une entrée
 
  //-------INTERRUPTEUR APU ----------------------------------------------------------------
  pinMode(LedAPUpin, OUTPUT);             // initialise la pin comme une sortie
  pinMode(SwitchAPUpin, INPUT);            // initialise la pin comme une entrée
   
  //-------INTERRUPTER CONE-----------------------------------------------------------------
  pinMode(LedNCOpenpin, OUTPUT);        // initialise la pin comme une sortie
  pinMode(LedNCTransitpin, OUTPUT);      // initialise la pin comme une sortie
  pinMode(SwitchNCpin, INPUT);               // initialise la pin comme une entrée
 
  //-------KEYBOARD------------------------------------------------------------------------- 
  keyboard.begin();                                    // Commencer la communication
  delay(2000);                                          // Attend que le périphérique soit reconnue comme un clavier
}

void loop() // //DEBUT DE LA BOUCLE
{
//-----------------------------------------------------------------------------------------
// -----LIRE L’ÉTAT DES INTERRUPTEURS------------------------------------------------------
 
    SwitchAPUState = digitalRead(SwitchAPUpin);
    SwitchNCState = digitalRead(SwitchNCpin);
    SwitchState = digitalRead(Switchpin); 
   
//-----------------------------------------------------------------------------------------
//-------INTERRUPTEUR DE L'APU-------------------------------------------------------------
   
    if(SwitchAPUState != PreviousSwitchAPUState) // Si l’état de 'interrupteur a change, envoyer CTRL+A. != veut dire "différent
                                                                          //de"
    {
      if(SwitchState == LOW)   // Cette condition activera l'envoi de touche si le bouton Arduino/PC COMM est sur ON
      {     
      // Envoyer CTRL+A
      keyboard.pressKey(CTRL, 'A');
      delay(100);
      keyboard.releaseKey();
      delay(50);
      }
     
      apu = 1;   // Mettre cette variable a 1, empêchera la LED de clignoter juste après que l'Arduino soit mise en marche
           
      SwitchAPUTimer = millis(); // Enregistrer le temps indiqué par l'horloge
     
      // Pour être sur que la première condition ne sera pas validée lors des prochaines boucles, il faut mettre a jour la variable   
      // "PreviousSwitchAPUState" au nouvel état de l'interrupteur   .
      if(SwitchAPUState == HIGH)  //
      {                           
         PreviousSwitchAPUState = HIGH;               
      }
      if(SwitchAPUState == LOW)
      {
         PreviousSwitchAPUState = LOW;             
      }
    }
   
    //La séquence de clignotement commence ici
    if (millis() < SwitchAPUTimer + 2500 && apu == 1) // Faire clignoter la LED jusqu’à ce que les 2,5 secs soient écoulées et
                                                                             //tant que la variable apu est a 1.
    {
       currentAPUMillis = millis();   // Enregistrer le temps indique par l'horloge
   
       if(currentAPUMillis - PreviousAPUMillis > 250) // Si le temps passé depuis la précédente boucle est supérieur a 250ms,
                                                                          // changer l’état de la LED
       {                                             
         PreviousAPUMillis = currentAPUMillis;        // Mettre a jour la variable "PreviousAPUMillis"
                                                   
         if (LedAPUState == LOW)         
         {
           LedAPUState = HIGH;   // Si la LED était éteinte, l'allumer
         }   
     
         else
         {
           LedAPUState = LOW;   // Si la LED était allumée, l’éteindre
         }
       }
    }
   
    if (millis() > SwitchAPUTimer + 2500) // Si les 2,5 secs sont passées, Allumer ou éteindre la LED
    {
      if(SwitchAPUState == HIGH) 
      {       
        LedAPUState = HIGH;    // Si la LED était allumée, la laisser allumer
      }
 
      if(SwitchAPUState == LOW)
      {       
        LedAPUState = LOW;  // Si la LED était éteinte, la laisser éteinte
      }
    }
    digitalWrite(LedAPUpin, LedAPUState);  // Envoyer l’état de la LED a la pin
       
//-----------------------------------------------------------------------------------------------------
//-------INTERRUPTER CONE--------------------------------------------------------------
 
   
   
    if(SwitchNCState != PreviousSwitchNCState) // Si l’état de 'interrupteur a changé, envoyer CTRL+K. != veut dire "différent de"
    {
      if(SwitchState == LOW)   // Cette condition activera l'envoi de touche si le bouton Arduino/PC COMM est sur ON
      {
      // Envoyer CTRL+K
      keyboard.pressKey(CTRL, 'K');
      delay(100);
      keyboard.releaseKey();
      delay(50);
      }
     
      TimerNC = 20000;     // Régler le timer a 20 secs
     
      nc = 1;  // Mettre cette variable a 1, empêchera la LED de clignoter juste après que l'Arduino soit mise en marche
     
      // Au cas ou l'interrupteur change d’état avant que les 20 secs soient passées, on a besoin de déterminer une nouvelle
      // valeur pour TimerNC. Par exemple, on commence l'ouverture du cône et 11 secondes après on décide de le fermer. La
      // LED aura clignoté pendant 11 secs pour l'ouverture et devra clignoter pendant 11 secs pour la fermeture. Si on ne
      // recalcule pas TimerNC, la LED va clignoter pendant 20 secs et non 11 durant la séquence de fermeture.
     
      if(millis() > SwitchNCTimer && millis() < SwitchNCTimer + 20000) // Si la LED a clignote depuis plus de 0 secs et moins de
                                                                                                    // 20 secs
      {
        TimerNC = millis() - SwitchNCTimer;  // Calculer le nouveau TimerNC en comparant le temps indiqué par l'horloge et
                                                              // le moment ou la LED a commencé a clignoter en utilisant la variable
                                                              // SwitchNCTimer enregistrée lors du précédent changement d’état de l'interrupteur
      }     
      SwitchNCTimer = millis(); // Mettre a jour la variable SwitchNCTimer pour savoir quand l'interrupteur a change d’état.
     
      // Pour être sure que la première condition ne sera pas validée lors des prochaines boucles, il faut mettre a jour la variable
      // "PreviousSwitchAPUState" au nouvel état de l'interrupteur   
      if(SwitchNCState == HIGH) 
      {
        PreviousSwitchNCState = HIGH;   
      }
      if(SwitchNCState == LOW)
      {
        PreviousSwitchNCState = LOW;
      }
     
    }
   
    if(LedAPUState == HIGH)   // On veut s'assurer que la LED ne clignotera pas tant que la LED de l'APU n'aura pas arrête de
                                            // clignoter (et donc que l'APU ne sera pas ON)
      {
      //La séquence de clignotement commence ici
      if (millis() < SwitchNCTimer + TimerNC && nc == 1) // Faire clignoter la LED jusqu’à ce que les 20 secs (ou moins) soient
                                                                                // écoulées et tant que la variable nc est a 1.
      {
        currentNCMillis = millis();   // Enregistrer le temps indique par l'horloge
   
        if(currentNCMillis - PreviousNCMillis > 250)  // Si le temps passe depuis la précédente boucle est superieur a 250ms,
                                                                       // changer l'etat de la LED.
        {
          PreviousNCMillis = currentNCMillis; // Mettre a jour la variable "PreviousAPUMillis"
     
          if (LedNCTransitState == LOW)   
          {
            LedNCTransitState = HIGH; // Si la LED etait eteinte, l'allumer
          }   
     
          else
          {
            LedNCTransitState = LOW; // Si la LED etait eteinte, la laisser eteindre
          }
        }
      }
     
      if(millis() >= SwitchNCTimer + TimerNC)  // Si les 20 secs (ou moins) sont passees, Allumer ou eteindre la LED
      {
        if(SwitchNCState == HIGH) // Si la LED etait allumee, la laisser allumer
        {       
          LedNCOpenState = HIGH;
          LedNCTransitState = LOW;
        }
     
        if(SwitchNCState == LOW) // Si la LED etait eteinte, la laisser eteindr
        {       
          LedNCOpenState = LOW;
          LedNCTransitState = LOW;
        }
      }
    }
    digitalWrite(LedNCOpenpin, LedNCOpenState); // Envoyer l'etat de la LED a la pin
    digitalWrite(LedNCTransitpin, LedNCTransitState); // Envoyer l'etat de la LED a la pin
   
}

// FIN DE LA BOUCLE
 

« Last Edit: 29 October 2013, 02:14:09 by hysot »
hysot

Offline nulentout

  • Legend
  • ******
  • Posts: 3264
  • Country: France fr
  • Karma: 220
Reply #14 - 29 October 2013, 09:26:30
Mon petit grain de sel :
C'est au sujet des LED. Sur ta carte d'essais tu as mis des 220 ohms. Donc le courant qui les traverses est un peu plus important. En fait, en fonction de la couleur des LED et surtout de leur rendement, si l'on veut des luminosités analoges il faut expérimenter avec des résistances de valeurs différentes et observer visuellement l'effet obtenu.
Si j'observe ton image, je vois qu'en bas il y a cinq entrées analogiques. C'est en général très utile quand on veut gérer des tableaux de bord. par exemple pour ajuster le compensateur, des commandes de ce type ...
Cette carte me semble tout à fait interressante, d'autant plus que visiblement elle simplifie énormément le codage puisque on programme déjà dans un langage "évolué".

La sagesse est un trésor ... tellement bien caché.

Offline antoo

  • Legend
  • ******
  • Posts: 3531
  • Country: France fr
  • Karma: 149
  • 2, breaking left!
    • Forum de mon Asso d'Echasses Urbaines
Reply #15 - 29 October 2013, 11:15:37
je sens que tu vas nous faire une merveille toi :top: ! Les LED et tout :bave: !

---------------------------------------------------------------------------------------------------
"ET C´EST PARTI!!" Youri Gagarine au lancement de vostok 1 le 12 avril 1961
Ma chaîne Youtube : Airsoft, FPS, Simulation : http://www.youtube.com/channel/UCrzIPMeULZU6lR4M6DVsH2g

Offline hysot

  • Full Member
  • ***
  • Posts: 110
  • Country: Canada ca
  • Karma: 8
Reply #16 - 29 October 2013, 13:39:44
Mon petit grain de sel :
C'est au sujet des LED. Sur ta carte d'essais tu as mis des 220 ohms. Donc le courant qui les traverses est un peu plus important. En fait, en fonction de la couleur des LED et surtout de leur rendement, si l'on veut des luminosités analoges il faut expérimenter avec des résistances de valeurs différentes et observer visuellement l'effet obtenu.
Si j'observe ton image, je vois qu'en bas il y a cinq entrées analogiques. C'est en général très utile quand on veut gérer des tableaux de bord. par exemple pour ajuster le compensateur, des commandes de ce type ...
Cette carte me semble tout à fait interressante, d'autant plus que visiblement elle simplifie énormément le codage puisque on programme déjà dans un langage "évolué".

Sur le site Arduino, il recommande effectivement dans leur montage avec LED, d'utiliser des 220 Ohms mais pour le moment je n'ai que 2 types de résistance, des 4,7K Ohms et des 330 Ohms. Une commandes de résistance devrait arriver dans la semaine pour étoffer un peu mon stock.
Pour les entrées analogiques, on peut aussi les utiliser pour multiplier le nombre de bouton poussoir. J'ai pu connecter 5 boutons poussoir sur la même pin analogique. En branchant une résistance différentes sur chaque bouton, on a 5 courants différents.
Pour utiliser des compensateurs et autres, il faudrait que je change le firmware pour émuler un joystick. Je pense pas pouvoir faire a avec une émulation clavier. Je pense investir dans une arduino Mega2560 qui pourra émuler clavier et a 54 pins. Je pourrais utiliser la Uno comme joystick. On verra l'annee prochaine

hysot

Offline hysot

  • Full Member
  • ***
  • Posts: 110
  • Country: Canada ca
  • Karma: 8
Reply #17 - 07 November 2013, 22:50:46
Depuis une bonne semaine, je me bats pour faire fonctionner 6 potentiomètres sur mon Arduino. En effet je souhaiterais utiliser l'Arduino Uno comme un joystick pour contrôler les RCS et le Hover. J'ajouterai une Arduino Mega2560 émulée en clavier pour le contrôle de la plus part des fonctions de mon panel. Certaines fonctions comme les trims et le train d’atterrissage pourront être commandes par la Uno.

J'ai réussi a trouve plusieurs firmwares tres interessant:

- Joystick de Daran. 2 axes 2 boutons. Il fonctionne tres bien mais est tres limite
- Big Joystick de Daran. 8 axes 40 boutons. Impossible de faire quoi que se soit de convainquant avec le programme qu'il met a disposition avec son firmware. C'est une simple demo, qui va faire bouger les axes et les boutons en boucle (voir le controleur de jeux de windows pour les voir bouger). J'ai essaye pas mal de chose mais pas moyen de trouver un programme pour faire fonctionner ce firmware avec de vrai potentiomètre. Je vois d'ailleurs pas l’intérêt de mettre a disposition une telle demo...
- Unojoy. 6 axes 40 boutons...en théorie!! car on vous mets a disposition un firmware qui n’émule que 4 axes et 13 boutons. Il y a apparemment moyen de changer ça, j'ai essaye...sans succes...L'avantage c'est que le programme fournis avec fonctionne parfaitement
- MegaJoy. 12 axes 64 boutons. Il faut une Arduino Mega2560 pour celui mais apparemment il fonctionnerait quand meme sur la Uno. De meme, j'ai essaye, sans succes...

Au final, je me retrouve donc avec le firmware Unojoy qui malgre son nombre d'axes limites, fonctionne tres bien.
Mon idée d'avoir deux joysticks comme celui la pour les RCS (LIN et ROT) tombe a l'eau. J'en utiliserai qu'un avec un bouton pour changer de mode.

Pour les curieux, le firmware Unojoy pour la Uno R3 se trouve la

Alors j'avoue que le dossier téléchargé est en gros bordel...Ce qui nous intéresse ici est le dossier ATmega8U2Code et le dossier UnoJoyArduinoSample.
Dans le premier vous y trouverez le firmware pour la Uno R3. Oui le dossier s'intitule ATmega8U2Code (puce des Uno R1/R2) et non ATmega16U2Code (puce de la Uno R3) mais le firmware est bien pour la R3. L'auteur a fait un mise a jour du firmware pour la R3 et a simplement mis un nouveau sous dossier sans se préoccuper de renommer le dossier (l'ancien firmware se trouve d'ailleurs toujours la dans le dossier Old Hex Files.
Vous trouverez donc ce firmware ici :
~/unojoy-1faabcad9ff6/ATmega8u2Code/HexFiles/UnoJoy.hex

Copiez le fichier UnoJoy.hex et placez le dans le dossier:

C:/Program Files/Arduino/hardware/arduino/firmwares/atmegaxxu2/arduino-usbserial

Dans le second dossier, UnoJoyArduinoSample, vous y trouverez le sketch (programme) pour obtenir les 4 axes et les 13 boutons. Déplacer le dossier dans votre dossier contenant vos autres sketches.

Uploader le sketch dans l'Arduino puis uploader le firmware comme il se doit et voila!

Pour le montage, les potars doivent être relies au pin A0, A1, A2, A3.
Les pins A4 et A5 ont été configure pour être utilise comme des pins digital, donc de simple bouton poussoir y seront relies.
Les 11 autres boutons poussoirs seront relies au pins 2 a 12.

et voila! je commence a travailler sur le design de mon panel.


hysot

Offline Mars Bleu

  • Hero Member
  • *****
  • Posts: 635
  • Karma: 31
Reply #18 - 08 November 2013, 08:45:56
Bravo, Hysot, pour ton projet et la clarté de tes explications.
L'idée de construire un panel me semble bonne, quand on manque de place.
Ce sera la voie que je vais choisir, en suivant ton cours.

Je travaille depuis plusieurs semaines sur la possibilité d'extraire des données
liées au vaisseau via la console LUA intégrée à Orbiter 2010. L'idée étant
d'avoir les afficheurs de niveau de carburant, la commande des gaz (peut-être
asservie aux pilotes autos), l'état des divers auxiliaires du vaisseau, etc...
En lisant la doc, j'ai trouvé le moyen d'obtenir certaines valeurs.

Je bute sur la synchronisation des commutateurs du ou des panels avec l'état logique du vaisseau
au moment du lancement d'Orbiter. Je voulais ouvrir le fichier *.scn, et lire les valeurs associées,
comme par exemple l'état des airbrakes, afin de les communiquer au(x) panel(s). Pour l'instant,
je n'obtiens que "nil".
Les recherches continuent.

Je sens que ce fil va se trouver parmi mes très favoris. Encore bravo pour tout ça. :flower: :flower: :flower:


Mars Bleu




Offline hysot

  • Full Member
  • ***
  • Posts: 110
  • Country: Canada ca
  • Karma: 8
Reply #19 - 08 November 2013, 15:48:55
Salut Mars Bleu,

Merci! :)
N’hésite pas a partager tes trouvailles! Ce genre d'information est très très limites sur le net surtout en restant simple : 1 PC + 1 ou 2 écrans. Beaucoup passe au multi PC des qu'il s'agit de se faire un simpit et ça change la donne sur la structure des programmes.
Un gars de Orbiter-forum a partage son boulot base sur Orb:connect. J'ai pas encore pris le temps de me plonger dedans mais la encore pas de doc :/ . Si ça t’intéresse je peux te filer le lien. Apparemment il n'y a plus qu'a installer le dossier dans le dossier d'orbiter et rédiger le programme de l'arduino.

hysot

Offline Fox-Terrier

  • League of
  • Legend
  • ******
  • Posts: 1426
  • Country: Switzerland ch
  • Karma: 28
  • :D
Reply #20 - 08 November 2013, 19:12:58
Est-ce que c'est possible de concevoir la carte de zéro ? C'est à dire coder en hardware ? Parce que si c'est pour émuler certaines touches du clavier, et allumer quelques LED, c'est faisable, la principale difficulté sera de rédiger un pilote pour ton engin
Par contre, joysticks et autres potentiomètres, ça se complique ...


Offline Mars Bleu

  • Hero Member
  • *****
  • Posts: 635
  • Karma: 31
Reply #21 - 08 November 2013, 22:33:43
Beaucoup de projets de simpit n'ont pas abouti. C'est pour ça que je
suis encore dans l'étude de la faisabilité selon mes dispos en temps
et mes compétences.
La simplicité doit être une ligne de conduite.

Dans orbiter forum, Widdernix a mis des choses pas mal dans "Talking
to serial devices" à http://orbiter-forum.com/showthread.php?p=208099
Ca peut servir, je ne sais pas encore comment.
J'ai regardé Orb:connect, mais je n'ai pas compris grand chose  :wonder:
Donc, oui, le lien m’intéresse, en espérant que ça m'aide à comprendre.
Y a-t-il du LUA dans Orb:connect?

Pour la configuration de l'Arduino:
               -si firmware d'origine=>charger le programme dans la carte
               -si firmware émulateur de clavier=> exécution du programme

J'ai bon?

Mais pour la mise au point, ça doit être pas mal de jonglage entre les firmwares.

Mars Bleu


Offline hysot

  • Full Member
  • ***
  • Posts: 110
  • Country: Canada ca
  • Karma: 8
Reply #22 - 08 November 2013, 23:12:38
Pareil, je vais passer mon hiver dans l'etude du project et l'ete prochain si j'ai la possibilite je commencerai la construction.

J'avais pas vu ce topic, je jette un oeil. Merci!

Pour le lien check tes MP

A vrai dire je n'ai aucune idée si il y a du LUA dans Orb:connect car comme toi je n'ai rien compris au fonctionnement de ce dernier.

Oui voila. Le logiciel IDE Arduino qui te sert a éditer les skteches et les uploader dans l'arduino ne detecte que les périphériques séries donc des que tu changes le firmware pour obtenir un clavier ou un joystick et bien le logiciel ne détecte plus ton arduino. Il faut donc jongler entre les deux. C'est pour ça qu'au début changer de firmware fait un peu peur, mais après avoir jongle 40 ou 50 fois ça va tout seul

Post Merge: 08 November 2013, 23:20:57
Est-ce que c'est possible de concevoir la carte de zéro ? C'est à dire coder en hardware ? Parce que si c'est pour émuler certaines touches du clavier, et allumer quelques LED, c'est faisable, la principale difficulté sera de rédiger un pilote pour ton engin
Par contre, joysticks et autres potentiomètres, ça se complique ...

Une Arduino Uno R3 c'est 20 euros...avec toute une communauté derrière qui te propose des firmwares si tu en as besoin, des montages, des programmes,... monter ma propre carte et la programmer de A a Z avec mon niveau en electronique et programmation c'est partir de rien vers l'inconnue... bref pas besoin de tortiller du cul pour chier droit. On me dira, ouai mais pourquoi ne pas acheter une carte émulatrice de clavier? ben c'est pas forcement aussi bien. Jj'en avais une il y a quelques années, 24e pour un truc qui ne peux même pas allumer de LED. Apres il y a un peu plus complexe pour gerer des interrupteurs des LED, des écrans LCD mais pareil c'est dédié a cette tache et rien d'autre (genre les X-Key si mes souvenirs sont bons). Et puis surtout l'Arduino était un cadeau! :P

« Last Edit: 08 November 2013, 23:20:57 by hysot »
hysot

Offline Fox-Terrier

  • League of
  • Legend
  • ******
  • Posts: 1426
  • Country: Switzerland ch
  • Karma: 28
  • :D
Reply #23 - 09 November 2013, 14:29:31
bref pas besoin de tortiller du cul pour chier droit.
:ptdr:

D'un autre côté, l'émulation du clavier, c'est quand quand même du tortillage de cul puisque Orbiter fonctionne très bien avec des périphériques "standards" ;)
Si c'est juste pour les LED, je me demande si c'est pas plus simple de bricoler directement le clavier ...


Offline hysot

  • Full Member
  • ***
  • Posts: 110
  • Country: Canada ca
  • Karma: 8
Reply #24 - 09 November 2013, 18:19:25
Plus simple avec un clavier, oui mais le résultat en sera beaucoup plus basique.
1- Impossible de programme le clavier, donc il ne pourra faire que ce pourquoi il a été conçu. En gros j'appuie et relâche le bouton et il envoie une lettre au PC. Donc ça limite déjà l'utilisation au bouton poussoir. Moins sympa que d'avoir des interrupteurs.

2- Si tu veux allumer des Leds, il doit y avoir moyen oui. Mais va falloir bidouiller du composant (plus cher que taper quelques lignes de code). Mais ça restera du basique. LED On ou Off pas plus.

Une Arduino a été conçu pour être programmée. Avec elle tu peux commander des moteurs, des LEDs, des capteurs de pression, de température, infrarouges, etc.....Tu peux faire des tas et des tas de chose avec. Lui demander d’émuler un clavier n'est pas si compliquer au final. Le programme pour lui faire écrire une lettre lorsque j'appuie sur un bouton est très basique et se résume en quelques lignes. Certes avec un clavier j'aurais pas eu a programmer, mais avec l'arduino je peux utiliser des timer et des conditions par exemple pour faire clignoter une LED toutes les x secondes pendant x secondes si et seulement si l'interrupteur a été basculer sur ON dans les 30 dernières secondes. Certes c'est un peu plus complique qu'un simple clavier mais ca permet d'avoir un resultat bien plus sexy ;) . La communauté Arduino est impressionnante.
Et puis si demain ce projet tombe a l'eau, je me retrouverais pas avec une carte qui ne peux qu’émuler un clavier, ou qu'être un contrôleur de jeu. Si je veux la transformer en contrôleur d’humidité du sol  pour commander l'arrosage automatique de mon jardin, alimentée simplement par un panneau solaire et qu'elle m'envoie les données sur mon PC ou sur mon portable et bien je peux et il y aura une communauté sur le net pour m'aider a réaliser ce projet.

hysot