0 Members and 1 Guest are viewing this topic.
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
#include <HIDKeyboard.h>HIDKeyboard keyboard;
#include <HIDKeyboard.h>HIDKeyboard keyboard;int Buttonpin = 2;
#include <HIDKeyboard.h>HIDKeyboard keyboard;int Buttonpin = 2; //Le bouton est branche sur la pin 2int ButtonState = 0; //L’état de du bouton: ON (HIGH) ou OFF (HIGH). On lui donne pour le moment la valeur 0
#include <HIDKeyboard.h>HIDKeyboard keyboard;int Buttonpin = 2; //Le bouton est branche sur la pin 2int ButtonState = 0; //L’état de du bouton: ON (HIGH) ou OFF (HIGH). On lui donne pour le moment la valeur 0void setup(){ pinMode(Buttonpin, INPUT); //On initialise la pin 2 comme une entrée}
#include <HIDKeyboard.h>HIDKeyboard keyboard;int Buttonpin = 2; //Le bouton est branche sur la pin 2int ButtonState = 0; //L’état du bouton: ON (HIGH) ou OFF (HIGH). On lui donne pour le moment la valeur 0void 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}
#include <HIDKeyboard.h>HIDKeyboard keyboard;int Buttonpin = 2; //Le bouton est branche sur la pin 2int ButtonState = 0; //L’état du bouton: ON (HIGH) ou OFF (HIGH). On lui donne pour le moment la valeur 0void 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 }
#include <HIDKeyboard.h>HIDKeyboard keyboard;int Buttonpin = 2; //Le bouton est branche sur la pin 2int ButtonState = 0; //L’état du bouton: ON (HIGH) ou OFF (HIGH). On lui donne pour le moment la valeur 0void 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); }}
#include <HIDKeyboard.h> // Inclue la librairie HIDKeyboard au programmeHIDKeyboard keyboard; // Initialise la librairieint Buttonpin = 2; //Le bouton est branche sur la pin 2int ButtonState = 0; //L’état du bouton: ON (HIGH) ou OFF (HIGH). On lui donne pour le moment la valeur 0int PreviousButtonState = 0; //Le précédent état du bouton
#include <HIDKeyboard.h> // Inclue la librairie HIDKeyboard au programmeHIDKeyboard keyboard; // Initialise la librairieint Buttonpin = 2; //Le bouton est branche sur la pin 2int ButtonState = 0; //L'etat du bouton: ON (HIGH) ou OFF (HIGH). On lui donne pour le moment la valeur 0int PreviousButtonState = 0; //Le precedent etat du boutonvoid 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); }}
#include <HIDKeyboard.h> // Inclue la librairie HIDKeyboard au programmeHIDKeyboard keyboard; // Initialise la librairieint Buttonpin = 2; //Le bouton est branche sur la pin 2int ButtonState = 0; //L'etat du bouton: ON (HIGH) ou OFF (HIGH). On lui donne pour le moment la valeur 0int PreviousButtonState = 0; //Le precedent etat du boutonint Ledpin = 13; //La LED est branche sur la pin 13int LedState = 0; //L'etat de la LEDvoid 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 }
/********************************************************************************* * 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 programHIDKeyboard keyboard; // Initialize HIDKeyboard object//------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------//----------VARIABLES COMM ARDUINO/PC-----------------------------------------------------------------------------------------------------------------------int Switchpin = 13; // L'interrupteur de l'Arduino/PC COMM est branche sur la pin 13int 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 9int SwitchAPUpin = 8; // L'interrupteur de l'APU est branché sur la pin 8int LedAPUState = LOW; // Enverra la valeur 1 (HIGH) ou 0 (LOW) a la LED de l'APU pour l'allumer ou l'éteindreint 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'Arduinounsigned 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 10int LedNCTransitpin = 11; // La LED jaune qui indiquera si le cône s'ouvre ou se ferme est branchée sur la pin 11int SwitchNCpin = 12; // L'interrupteur du cône est branche sur la pin 12int LedNCOpenState = LOW; // Enverra la valeur 1 (HIGH) ou 0 (LOW) a la LED verte pour l'allumer ou l’éteindreint LedNCTransitState = LOW; // Enverra la valeur 1 (HIGH) ou 0 (LOW) a la LED jaune pour l'allumer ou l’éteindreint 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'Arduinounsigned 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 secsunsigned 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
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é".
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 enginPar contre, joysticks et autres potentiomètres, ça se complique ...
bref pas besoin de tortiller du cul pour chier droit.
Author
Topic: Arduino Uno + Orbiter (Read 106281 times)
Search
Login
Register