Différences
Ci-dessous, les différences entre deux révisions de la page.
Les deux révisions précédentes Révision précédente | |||
start:projet:arduino:controle_arduino_clavier [2015/02/25 15:17] – [La partie Processing] nrabeson | start:projet:arduino:controle_arduino_clavier [2015/03/23 18:48] (Version actuelle) – nrabeson | ||
---|---|---|---|
Ligne 1: | Ligne 1: | ||
+ | ====== Contrôle d'un servo-moteur depuis son PC ====== | ||
+ | <note important> | ||
+ | |||
+ | ===== Prérequis ===== | ||
+ | |||
+ | |||
+ | * Processing, un logiciel de programmation ressemblant furieusement à Arduino | ||
+ | Lien pour le télécharger : [[https:// | ||
+ | * Un Arduino | ||
+ | * Un servo-moteur (??) | ||
+ | * Avoir des bases de C (créer des variables et les modifier) et un tout petit peu de programmation objet... | ||
+ | * Un tout petit peu de Java (mais ça ressemble à du C, que vous connaissez déjà) | ||
+ | |||
+ | |||
+ | ===== I. Servo-moteur vous dites ? ===== | ||
+ | |||
+ | Un servo-moteur est un moteur intelligent (il possède un servo...) qui est capable de se placer tout seul à une angle donné (compris entre 0 et 180). C'est avec ces composants que l'on peut faire des **panneaux solaires** suivant la trajectoire du Soleil ou des **caméras** balayant une pièce. | ||
+ | Ici nous allons justement prendre le contrôle de l'un de ces engins avec l'aide du **clavier** de notre ordinateur, mais après ce tutoriel vous serez tout à fait capable de prendre le contrôle avec votre **souris** ou des **fruits** (c'est même plus simple !) | ||
+ | |||
+ | ===== II. Ce que nous allons faire ===== | ||
+ | |||
+ | Nous allons faire deux tutoriels en un seul : | ||
+ | - Savoir contrôler un servo-moteur | ||
+ | - Savoir envoyer depuis un ordinateur des données à un arduino | ||
+ | |||
+ | Avec comme but de contrôler un servo-moteur avec votre clavier | ||
+ | |||
+ | ===== III. Le montage ===== | ||
+ | |||
+ | Un servo-moteur possède trois entrées : deux correspondant à l' | ||
+ | * Rouge : Alimenter en 5V | ||
+ | * Noir : Connecter la masse | ||
+ | * Autre (souvent jaune ou blanc) : C'est elle qui permet d' | ||
+ | |||
+ | Le montage (difficile (< | ||
+ | |||
+ | Vous pouvez brancher la patte jaune à l' | ||
+ | |||
+ | {{: | ||
+ | |||
+ | On peut désormais passer à la partie suivante : | ||
+ | |||
+ | ===== IV. Le code arduino pour contrôler un servo-moteur ===== | ||
+ | |||
+ | Nous avons besoin d'une bibliothèque pour utiliser le servo-moteur facilement : la bibliothèque Servo.h | ||
+ | Cette bibliothèque permet d' | ||
+ | <note important> | ||
+ | |||
+ | Pour utiliser les fonctions offertes par Servo.h vous devez implanter la ligne suivante en début de votre code Arduino : | ||
+ | |||
+ | #include < | ||
+ | | ||
+ | <note important> | ||
+ | |||
+ | Maintenant il faut créer un **objet** qui va permettre de commander votre servo-moteur. On va le nommer " | ||
+ | |||
+ | Servo monServo; | ||
+ | |||
+ | < | ||
+ | |||
+ | Dans votre boucle setup() vous aurez besoin de dire à votre objet " | ||
+ | |||
+ | monServo.attach(9); | ||
+ | | ||
+ | < | ||
+ | Votre objet **monServo** est comme je le disais une variable avec des fonctions plus puissantes. C'est réellement une machine. Ici nous lui demandons, grâce à la fonction attach() de monServo, de se souvenir que monServo est l' | ||
+ | \\ | ||
+ | \\ | ||
+ | Si vous voulez maintenant dire à votre servo-moteur de se placer à un angle de 45 degrés, vous n'avez qu'à utiliser la ligne suivante dans votre boucle loop : | ||
+ | |||
+ | monServo.write(45); | ||
+ | | ||
+ | N' | ||
+ | \\ | ||
+ | //Voalà// le code entier : | ||
+ | |||
+ | #include < | ||
+ | | ||
+ | Servo monServo; | ||
+ | | ||
+ | void setup() | ||
+ | { | ||
+ | monServo.attach(9); | ||
+ | } | ||
+ | | ||
+ | void loop() | ||
+ | { | ||
+ | monServo.write(45); | ||
+ | } | ||
+ | |||
+ | ===== V. Le code pour interagir entre l' | ||
+ | |||
+ | Nous savons commander un servo-moteur depuis l' | ||
+ | |||
+ | Le code s' | ||
+ | * Un code qui va être téléversé sur l' | ||
+ | * Un code qui va être exécuté sur l' | ||
+ | |||
+ | ==== La partie Arduino === | ||
+ | |||
+ | Pour pouvoir faire communiquer un Arduino avec un PC, nous devons d' | ||
+ | |||
+ | Serial.begin(9600); | ||
+ | | ||
+ | Le fonctionnement de serial ressemble furieusement à celui du servo, et c'est normal : Serial est un objet qui représente tout simplement la connexion entre l' | ||
+ | \\ | ||
+ | Pour lire une valeur que l'on aurait envoyé à l' | ||
+ | |||
+ | int variable; // La variable pour sauvegarder ce que nous envoie l' | ||
+ | if(Serial.available()) //On vérifie qu'il y a quelque chose à lire | ||
+ | { | ||
+ | variable = Serial.read(); | ||
+ | } | ||
+ | |||
+ | Super ! On sait lire des données depuis un ordi !\\ | ||
+ | Supposons maintenant que cette variable correspond à l' | ||
+ | |||
+ | monServo.write(variable); | ||
+ | | ||
+ | Voici le code Arduino entier pour placer un servo-moteur à la position " | ||
+ | |||
+ | #include < | ||
+ | | ||
+ | Servo monServo; | ||
+ | | ||
+ | void setup() | ||
+ | { | ||
+ | monServo.attach(9); | ||
+ | Serial.begin(9600); | ||
+ | } | ||
+ | | ||
+ | void loop() | ||
+ | { | ||
+ | int variable; // Je déclare la variable | ||
+ | if(Serial.available()) // Je vérifie qu'il y a quelque chose à enregistrer | ||
+ | { | ||
+ | variable = Serial.read(); | ||
+ | } | ||
+ | monServo.write(variable); | ||
+ | } | ||
+ | |||
+ | //Mais dis moi Jamie, comment on envoie des données vers un ordinateur ?\\ | ||
+ | //Minute papillon, j'y arrive | ||
+ | |||
+ | ==== La partie Processing ==== | ||
+ | |||
+ | Aaaahhhh on arrive enfin à la partie la plus intéressante, | ||
+ | \\ | ||
+ | Du concret plutôt que du blabla : | ||
+ | |||
+ | void setup() | ||
+ | { | ||
+ | size(400, | ||
+ | } | ||
+ | void draw() | ||
+ | { | ||
+ | ellipse(40, 40, 20, 20); // Dessiner une ellipse de coordonnés (40, 40) et de rayon horizontal 20 et vertical 20 | ||
+ | } | ||
+ | | ||
+ | Ce code affiche une fenêtre avec un cercle à l' | ||
+ | * Le **setup()** de Processing est le strict équivalent du setup() de Arduino. Il sert notamment à définir la taille de la fenêtre ou que l'on veut écrire à l' | ||
+ | * Le **draw()** de Processing est le strict équivalent de loop() de Arduino. Pas besoin d'en dire beaucoup plus... | ||
+ | |||
+ | |||
+ | Revenons à nos moutons. \\ | ||
+ | Nous allons voir comment dire à notre Arduino de se mettre à un angle de 45° en appuyant sur gauche, et à un angle de 135 si nous appuyons à droite. | ||
+ | \\ | ||
+ | \\ | ||
+ | Il va falloir d' | ||
+ | |||
+ | import processing.serial.*; | ||
+ | | ||
+ | Puis ensuite créer un objet représentant notre connexion, ici nommé " | ||
+ | |||
+ | Serial monPort; | ||
+ | | ||
+ | Pour ouvrir le port placez le code suivant dans votre boucle **setup()**. | ||
+ | String nomPort = Serial.list()[0]; | ||
+ | monPort = new Serial(this, | ||
+ | | ||
+ | <note important> | ||
+ | | ||
+ | Explication :\\ | ||
+ | Quand nous communiquons avec un Arduino, nous utilisons les ports COM1, COM2, COM3, etc. Le nombre que vous mettez dans Serial.list()[i] correspond au ième port COM ouvert. Il faut donc bien trouver celui correspondant à l' | ||
+ | Le " | ||
+ | \\ | ||
+ | Cool, nous savons ouvrir un port ! Maintenant il faut envoyer des infos. Ce que nous allons faire, c'est envoyer 45 à l' | ||
+ | |||
+ | monPort.write(45); | ||
+ | | ||
+ | |||
+ | Mais je veux envoyer des ordres à l' | ||
+ | \\ | ||
+ | Ok pas de panique, maintenant souvenez vous de la partie arduino : Nous avons fait un code qui attendait de l' | ||
+ | \\ | ||
+ | Voici un petit résumé du coup de tout ce qu'on a écrit, c' | ||
+ | * Connecter un ordinateur avec un Arduino | ||
+ | * Envoyer des valeurs à l' | ||
+ | |||
+ | import processing.serial.*; | ||
+ | Serial monPort; | ||
+ | | ||
+ | void setup() | ||
+ | { | ||
+ | // Connexion avec l' | ||
+ | String nomPort = Serial.list()[0]; | ||
+ | monPort = new Serial(this, | ||
+ | } | ||
+ | | ||
+ | void draw() | ||
+ | { | ||
+ | monPort.write(45); | ||
+ | } | ||
+ | | ||
+ | Si votre Arduino est bien connectée avec le code que je vous ai demandé de téléverser, | ||
+ | Si ce n'est pas le cas tentez un autre paramètre pour la fonction Serial.list() jusqu' | ||
+ | |||
+ | |||
+ | ==== Utiliser son clavier pour contrôler un Arduino ==== | ||
+ | |||
+ | Nous voulons désormais contrôler l' | ||
+ | |||
+ | void setup() | ||
+ | { | ||
+ | size(400, | ||
+ | } | ||
+ | | ||
+ | void draw() | ||
+ | { | ||
+ | ellipse(40, 40, 20, 20); // Dessiner une ellipse de coordonnés (40, 40) et de rayon horizontal 20 et vertical 20 | ||
+ | } | ||
+ | | ||
+ | void keyPressed() // Si une touche est pressée | ||
+ | { | ||
+ | if (keyCode == LEFT) // Si j'ai appuyé sur gauche | ||
+ | { | ||
+ | println(1); // Afficher 1 dans la console | ||
+ | } | ||
+ | if (keyCode == RIGHT) // Si j'ai appuyé sur droite | ||
+ | { | ||
+ | println(0); // Afficher 0 dans la console | ||
+ | } | ||
+ | } | ||
+ | | ||
+ | Si vous appuyez sur gauche ou droite, vous verrez des 0 ou des 1 apparaître dans la partie noire en dessous de votre code sur Processing. \\ | ||
+ | Nous allons maintenant créer une variable dans processing, que nous allons mettre égale à 45 si nous appuyons sur gauche, et égale à 135 si nous appuyons sur droite. Comme je suis trop gentil je vous ai écrit le code : | ||
+ | |||
+ | int variable = 0; | ||
+ | | ||
+ | void setup() | ||
+ | { | ||
+ | size(400, | ||
+ | } | ||
+ | | ||
+ | void draw() | ||
+ | { | ||
+ | println(variable); | ||
+ | } | ||
+ | | ||
+ | void keyPressed() // Si une touche est pressée | ||
+ | { | ||
+ | if (keyCode == LEFT) // Si j'ai appuyé sur gauche | ||
+ | { | ||
+ | variable = 45; // Mettre dans variable la valeur 45 | ||
+ | } | ||
+ | if (keyCode == RIGHT) // Si j'ai appuyé sur droite | ||
+ | { | ||
+ | variable = 135; // Mettre dans variable la valeur 135 | ||
+ | } | ||
+ | } | ||
+ | | ||
+ | Quand vous appuyez sur une touche, vous voyez dans la console noire que variable change effectivement de valeur.\\ | ||
+ | Pour contrôler le servo-moteur , nous n' | ||
+ | \\ | ||
+ | \\ | ||
+ | \\ | ||
+ | \\ | ||
+ | ... | ||
+ | \\ | ||
+ | \\ | ||
+ | \\ | ||
+ | \\ | ||
+ | Du mal ? | ||
+ | \\ | ||
+ | \\ | ||
+ | \\ | ||
+ | \\ | ||
+ | Bon... | ||
+ | \\ | ||
+ | \\ | ||
+ | \\ | ||
+ | \\ | ||
+ | Ok fin de l' | ||
+ | \\ | ||
+ | Voici la correction : | ||
+ | |||
+ | import processing.serial.*; | ||
+ | | ||
+ | Serial monPort; // Objet représentant notre port de communication | ||
+ | | ||
+ | int nombre = 0; // Initialise la variable | ||
+ | | ||
+ | void setup() | ||
+ | { | ||
+ | String nomPort = Serial.list()[0]; | ||
+ | | ||
+ | monPort = new Serial(this, | ||
+ | } | ||
+ | | ||
+ | void draw() | ||
+ | { | ||
+ | monPort.write(nombre); | ||
+ | } | ||
+ | | ||
+ | void keyPressed() | ||
+ | { | ||
+ | if (keyCode == LEFT) // Si on appuie sur gauche | ||
+ | { | ||
+ | nombre = 45; | ||
+ | } | ||
+ | if (keyCode == RIGHT) // Si on appuie sur droite | ||
+ | { | ||
+ | nombre = 135; | ||
+ | } | ||
+ | } | ||
+ | | ||
+ | Si vous compilez ce code, avec votre carte Arduino connectée à l'ordi avec le code que je vous ai demandé de téléverser auparavant, et que vous êtes connectés au bon port, et que vous appuyez sur les flèches du clavier, votre servo-moteur va se mettre à bouger !\\ | ||
+ | C'est exactement ce que nous souhaitions faire.\\ | ||
+ | \\ | ||
+ | ===== Pour aller plus loin ===== | ||
+ | |||
+ | Vous savez désormais prendre le contrôle d'un Arduino avec l'aide d'un servo-moteur. Vous pouvez faire beaucoup de choses désormais, pourquoi ne pas tenter les choses suivantes : | ||
+ | * Une caméra qui tourne à gauche quand on appuie sur gauche et inversement | ||
+ | * Des lumières qui s' | ||
+ | * Récupérer la luminosité d'une pièce grâce à un Arduino (la connexion se fait dans l' | ||
+ | * Fabriquer une imprimante 3D... | ||
+ | * etc. | ||
+ | |||
+ | Bon pour faire tout ce que je vous ai dit au dessus il faut un peu chercher sur internet. Un tuto spécifiquement dédié aux connexions Ordinateur - Arduino arrive, il vous permettra de faire tout ce que vous voulez. |