Contrôler un servomoteur avec un STM32 Nucleo (mbed)

Je vous invite aujourd'hui à explorer le contrôle d'un servomoteur au moyen d'une carte STM32 Nucleo programmée dans mbed.  Vous pouvez vous référer à d'autres articles de ce blog si vous préférez contrôler votre servomoteur en utilisant un Arduino ou un Raspberry Pi.

Les petits servomoteurs de modélisme sont des dispositifs fascinants: contrairement à un simple moteur, vous pouvez les immobiliser à la position que vous désirez, avec une très grande précision.

La position angulaire du servomoteur dépend du rapport cyclique du signal modulé en largeur d'impulsion (PWM) qu'on lui fournit.  Typiquement, pour un signal d'une période de 20 ms, le servomoteur sera à sa position maximale dans le sens horaire lorsque la durée des impulsions est de 1 ms, il occupera sa position maximale dans le sens antihoraire lorsque la durée des impulsions est de 2 ms, et il sera au centre de sa course lorsque l'impulsion dure 1,5 ms.  Ces valeurs, toutefois, peuvent varier d'un servomoteur à l'autre et c'est en expérimentant que vous pourrez déterminer les valeurs extrêmes qui correspondent à votre servomoteur (par exemple, celui que j'ai utilisé pour cette expérience pouvait accepter des valeurs variant de 0,7 ms à 2,3 ms).

Branchements du servomoteur

Le servomoteur comporte 3 fils: le fil rouge et le fil noir (ou marron) servent à l'alimentation du servomoteur (5 V), alors que l'autre fil (qui est souvent jaune) transmet le signal PWM qui contrôle la position.

Comme c'est le cas pour tous les moteurs, il est généralement préférable d'alimenter le servomoteur avec une source de tension externe, autre que la sortie 5 V de la carte Nucleo.

Les branchements seront donc:

• Fil rouge du servomoteur: borne positive de l'alimentation 5 V.
• Fil noir du servomoteur: borne négative de l'alimentation 5 V et GND du Nucleo
• Fil jaune du servomoteur: broche D5 du Nucleo (ou autre sortie PWM, à la condition de modifier le script en conséquence).

1er exemple: rotation continue

Il existe sur mbed quelques bibliothèques spécialement conçues pour le contrôle d'un servomoteur, mais puisque le contrôle d'un signal PWM n'a rien de bien compliqué, je n'ai pas jugé bon de les utiliser.

Dans ce premier exemple, le servomoteur tourne lentement de sa position minimale à sa position maximale, puis retourne brusquement à sa position minimale.

J'ai supposé que la position minimale correspond à une impulsion de 1000 microsecondes (donc 1 milliseconde) et que la position maximale correspond à une impulsion de 2000 microsecondes (2 millisecondes) mais ça peut varier d'un servomoteur à l'autre.  À vous d'expérimenter si vous désirez utiliser la totalité de l'amplitude du mouvement de votre servomoteur (il s'agit de modifier la valeur numérique des constantes positionMin et positionMax).

2e exemple: rotation contrôlée par un potentiomètre

Dans ce deuxième exemple, on ajoute un potentiomètre branché à l'entrée A0 de la carte Nucleo.  La positon du servomoteur dépend de la positon du potentiomètre.

À lire également

Les cartes Nucleo (et les cartes à base de STM32 en général) peuvent maintenant être programmées avec l'IDE Arduino.  La modulation par largeur d'impulsion a été explorée en détail dans cet article.

Pour piloter un servomoteur, on peut également utiliser une carte Arduino, un module ESP32 ou ESP8266, un Raspberry Pi, un microcontrôleur PIC programmé avec MPLAB Xpress, etc.

Yves Pelletier   (Twitter, Facebook)

Prendre des photos avec le module caméra du Raspberry Pi

Cet article a été mis à jour le 21 décembre 2020.

Aujourd'hui, je vous invite à explorer avec moi diverses façons de prendre une photo avec le module caméra du Raspberry Pi: je vais tour à tour utiliser raspistill, la bibliothèque picamera (python), Scratch et le logiciel Pi Vision.

Un support pour la caméra

Puisque le module caméra du Raspberry Pi est un petit circuit intégré d'environ 2 cm de côtés, ce n'est pas toujours évident de l'orienter pour qu'il photographie ce qu'on désire photographier.  Vous pouvez le laisser à plat sur la table mais...vous aller alors photographier le plafond, et ce n'est peut-être pas votre but!

De plus, le ruban connecteur fourni avec le module n'est long que d'une dizaine de centimètres et la caméra doit donc rester à proximité du Raspberry Pi.

Tout ça pour dire qu'à mon avis, un module caméra sans support inclinable est à toute fin pratique inutilisable.

Il faut donc penser à un dispositif qui tiendra votre module caméra dans la position désirée.  Vous pouvez en acheter un spécialement conçu à cette fin, en fabriquer un au moyen d'une imprimante 3D, ou en bricoler un avec les moyens du bord.  Comme vous pouvez le constater sur la photographie ci-dessous, j'ai choisi l'option "bricolage avec les moyens du bord": mon support de caméra est constitué de deux petits blocs de bois reliés par une charnière. Le module caméra est fixé à un des blocs au moyen de deux petits clous.  Grâce à la charnière, je peux régler à volonté l'orientation verticale de la caméra.

Remarquez que, dans cette position (ruban connecteur en haut), la caméra est à l'envers, ce qui va m'obliger, dans la suite de cet article, à retourner l'image de façon logicielle.


Connexion de la caméra

Pour éviter d'endommager votre matériel, il est recommandé de brancher le module caméra pendant que le Raspberry Pi est éteint.

La caméra se branche dans le port CSI (camera serial interface) du Raspberry Pi.

Observez le ruban du module caméra:  à une extrémité, pour pouvez voir 15 courtes bandes conductrices: lorsque le ruban est inséré dans le connecteur CSI, ces bandes doivent être orientées vers le connecteur HDMI.

Vous ouvrez le "couvercle" du connecteur CSI en le tirant délicatement vers le haut, tout en poussant vers l'intérieur avec le pouce et l'index.  Vous insérez le ruban connecteur de la caméra le plus profondément possible, avec les connecteurs métalliques orientés vers le connecteur HDMI, et vous refermez le couvercle en poussant vers le bas (ça devrait faire "clic", et le ruban reste bien en place même si vous tirez dessus).

Configuration du Raspberry Pi

Si vous n'avez jamais utilisé de module caméra avec votre Raspberry Pi, il faut l'activer dans le menu "Préférences" / "Configuration du Raspberry Pi":

Dans l'onglet "Interfaces", vous vous assurez que "Caméra" est réglée à "Activé", puis vous cliquez sur le bouton "Valider".

Prendre une photo depuis le terminal (raspistill)

Vous pouvez prendre une photographie à partir du terminal en lignes de commandes, grâce à la fonction raspistill.

Par exemple, écrivez la commande "raspistill -o ma_photo.jpeg"

Résultat:  pendant plusieurs secondes, l'image captée par votre module caméra sera affichée à l'écran, et elle sera ensuite enregistrée dans le répertoire "/home/pi" dans un fichier portant le nom "ma_photo.jpeg".

Le paramètre "-o" signifie "output", et sert à indiquer le nom qu'on désire donner à notre fichier.

Voici donc la photo enregistrée dans le fichier "ma_photo.jpeg":

Tel que mentionné au début de cet article, ma caméra est positionnée à l'envers. Si c'est aussi votre cas, c'est très facile à corriger: il s'agit d'ajouter les paramètres -hf et -vf à raspistill (-hf pour "horizontal flip" et -vf pour "vertical flip").

Par défaut, la photo est prise à la résolution maximale du module caméra, c'est à dire 2592 X 1944.  Si vous désirez une résolution plus faible (pour économiser l'espace sur votre carte SD, par exemple), vous pouvez utiliser les paramètres -w et -h (où -w représente la largeur en pixels, et -h représente la hauteur en pixels.

Dans ce nouvel essai, je vais prendre une photo retournée, de résolution 640 X 480, qui va s'enregistrer dans un fichier intitulé "ma_photo2.jpeg".  Pour ce faire, j'écris la commande "raspistill -hf -vf -w 640 -h 480 -o ma_photo2.jpeg"...

Résultat: la photo est maintenant dans le bon sens, et sa résolution n'est plus que de 640 X 480:

Par défaut, l'aperçu de la photo apparaît à l'écran pendant 5 secondes avant que la photo ne soit prise.  Si vous désirer modifier ce délai, vous utilisez le paramètre "-t" accompagné du délai désiré en millisecondes.  Par exemple, "raspistill -t 10000 -o photo.jpeg" affichera l'aperçu pendant 10 secondes avant d'enregistrer la photo, ce qui vous laisse plus de temps pour ajuster le cadrage.

D'autres paramètres vous permettent d'ajuster la luminosité, de modifier la saturation, d'ajouter des filtres.  Pour connaître toutes les options disponibles, tapez simplement "raspistill", sans paramètres, dans le terminal.

Voici, par exemple, le résultat obtenu avec la commande "raspistill -hf -vf -ifx colourswap -o photo.jpeg": une succulente pomme bleue!:

Prendre une photo avec le logiciel Pi Vision

Si vous désirez prendre une photo de temps à autre, écrire de longues commandes dans le terminal n'est probablement pas l'option la plus agréable: il faut retenir la syntaxe, éviter les fautes de frappe...  Il existe évidemment quelques applications à interface graphique spécialement conçues pour contrôler le module caméra.

J'ai testé Pi Vision, que vous pouvez télécharger ici.  Après avoir décompressé le fichier "PiVision.RPi.tar.gz", vous obtenez un fichier inexplicablement intitulé "rpiCC".  Avant de l'ouvrir, il est important de modifier les permissions de "rpiCC" pour le rendre exécutable.

Pour prendre une photo, il s'agit de cliquer sur l'onglet "Photo", de modifier les paramètres en fonction de nos préférences, puis de cliquer sur le bouton "Take a Picture".  On nous présente ensuite les dialogues habituels nous permettant de choisir le nom du fichier et l'endroit où on désire l'enregistrer.

Prendre une photo avec un script en Python

Grâce à la bibliothèque picamera, il n'est pas très difficile de contrôler le module caméra au moyen d'un script en langage python (cette bibliothèque est déjà installée par défaut dans Raspbian, et la documentation complète qui la concerne se trouve ici).



L'instruction "camera.resolution = (1024,768)", qui règle la résolution de la photo qui sera enregistrée en fichier, est optionnelle.  Si vous l'omettez, la résolution sera, par défaut, de 1440 X 900.

L'instruction "camera.rotation = 180 " sert à retourner la photo, puisque mon module caméra est placé à l'envers.  Cette ligne est évidemment inutile si votre module caméra est à l'endroit.

L'instruction "camera.start_preview(fullscreen = False, window = (50,50,640,480))" fait apparaître l'aperçu à l'écran, dans un rectangle de 640 pixels de largeur et de 480 pixels de hauteur.  Si j'avais simplement écrit "camera.start_preview()", l'aperçu remplirait tout l'écran.  Mais attention: en cas de bug quelque part dans votre script, le programme s'interrompt sans se rendre à l'instruction "camera.stop_preview()", et l'aperçu demeure stupidement affiché à l'écran, vous empêchant d'accéder aux contrôles de votre IDE pour python...je le sais, car ça m'est arrivé!  Pour cette raison, je préfère éviter que l'aperçu couvre la totalité de l'écran.

C'est l'instruction "camera.capture('/home/pi/Pictures/image.jpeg')" qui fait la partie la plus importante du travail: enregistrer la photo dans un fichier!  Ici, j'ai écrit le chemin d'accès complet du fichier pour qu'il s'enregistre  dans le répertoire destiné à stocker des images.  Vous pouvez vous contenter d'écrire le nom du fichier désiré ("camera.capture('image.jpeg)") pour qu'ils s'enregistre dans le répertoire "/home/pi".

Prendre une photo avec Scratch?!?!

La version de Scratch conçue pour le Raspberry Pi permet de prendre une photo avec le module caméra.

Dans l'onglet "Costumes", si vous cliquez sur le bouton "Camera", une petite fenêtre montrant un aperçu de la photo apparaît à l'écran.

Si vous cliquez sur le bouton qui présente une icône en forme de caméra, le lutin a maintenant, comme costume, la photo prise par la caméra.

Le bouton "Fait" permet de faire disparaître la fenêtre, lorsque vous avez terminé.

Dans mon cas, clic avec le bouton droit pour mettre la photo à l'endroit...

Ce n'est pas tout: vous pouvez concevoir des programmes qui prennent des photos.  Pour ce faire, vous devez d'abord d'abord démarrer le serveur GPIO:

Vous prenez une nouvelle photographie grâce à un bloc "envoyer à tous" qui envoie le message "photo":

Le costume du lutin est remplacé par une nouvelle photo:

Yves Pelletier   (Twitter, Facebook)

MIDI par usb avec Arduino Leonardo

Jusqu'à maintenant, chaque fois que j'ai abordé un projet impliquant le protocole MIDI, j'ai utilisé les traditionnels connecteurs DIN à 5 broches.  Ces connecteurs sont tout à fait appropriés lorsqu'on veut brancher une carte Arduino à un clavier MIDI, par exemple.  Mais pour établir une communication MIDI entre l'Arduino et un ordinateur, un simple câble usb s'avère plus pratique (surtout si vous ne possédez pas d'instruments de musique compatibles MIDI).

Dans ce tuto, nous explorons donc l'utilisation d'une carte Arduino Leonardo pour établir une communication MIDI avec un ordinateur.  Plutôt qu'un Leonardo, n'importe quelle carte Arduino pouvant se comporter comme un périphérique USB pourrait faire l'affaire (Zero, Due, 101...); toutefois, ce projet ne fonctionnera pas avec une carte Arduino Uno.

Installation d'un logiciel MIDI sur l'ordinateur

Nous aurons besoin d'un logiciel compatible MIDI sur l'ordinateur auquel nous brancherons le Leonardo.  Si vous avez déjà l'habitude de jouer avec des contrôleurs MIDI, utilisez votre logiciel préféré.  Sinon, je vous propose VMPK, ou Virtual MIDI Piano Keyboard qui est léger, gratuit, et convient parfaitement à nos besoins.  Le logiciel est disponible pour Windows, Linux et Mac, mais j'ai fait mes tests sous Windows 7.

Installation de la bibliothèque MIDIUSB

Vous devez également installer la bibliothèque MIDIUSB dans votre IDE Arduino.  Attention, il ne s'agit pas de la bibliothèque MIDI conventionnelle que vous avez peut-être déjà installée dans le passé.

Exemple 1:  communication de l'Arduino vers l'ordinateur (MIDI out)

Une première utilisation possible consiste à envoyer des instructions MIDI de la carte Arduino vers l'ordinateur (le Leonardo agit comme contrôleur MIDI).  L'exemple "MIDIUSB_write" qui accompagne la bibliothèque MIDIUSB envoie à l'ordinateur une même note de façon répétitive; j'ai modifié cet exemple pour jouer en boucle une courte mélodie constituée de 16 notes.

Le sketch

Le sketch contient une fonction noteOn qui permet de jouer une note.  Cette fonction nécessite trois paramètres:  channel (le canal MIDI utilisé), pitch (la note de la gamme à jouer) et velocity (le volume sonore avec lequel la note doit être jouée).

Ainsi,  "noteOn(0, 0x48, 64)" jouera la note "do du 5e octave" avec une vélocité de 64 (moyenne) sur le canal 0.

Dans le protocole MIDI, chaque note est jouée aussi longtemps qu'elle n'est pas interrompue par un message "noteOff", qui prend les mêmes arguments que la fonction "noteOn".

Les 16 notes qui constituent notre mélodie sont stockées dans un tableau bidimensionnel nommé "melodie":  le premier élément est le "pitch", et le deuxième est la durée en millisecondes.  J'aurais pu ajouter un troisième élément pour la vélocité mais, dans cette exemple, toutes les notes de la mélodie sont jouées avec la même intensité.



Réglages du logiciel MIDI

Pour que la mélodie émise par l'Arduino soit jouée par l'ordinateur, il faut faire en sorte que Virtual MIDI Piano Keyboard utilise la carte Leonardo comme entrée MIDI.  Pour  ce faire, vous choisissez "Connexions MIDI" dans le menu "Éditer".

Si la carte est branchée à un port USB de l'ordinateur, "Arduino Leonardo" devrait être disponible dans la liste proposée pour "Connexion du port d'entrée MIDI".  Il vous faut également un pilote capable de jouer les sons ("Pilote MIDI OUT").  Dans mon cas, on me propose "Windows MM", probablement parce que Windows Movie Maker était déjà installé sur l'ordinateur.  Si la liste "Pilote MIDI OUT" est vide pour vous, vous devrez installer un pilote sur votre ordinateur (VirtualMIDISynth, par exemple).

La mélodie devrait maintenant être jouée sur la carte de son de l'ordinateur.  Notez que vous pouvez modifier le "programme" (l'instrument utilisé pour jouer la mélodie): ça peut être un son de piano, de trompette, de clarinette, etc.

D'autres exemples de MIDI out

Comme je l'ai déjà mentionné, l'exemple "MIDIUSB_write" fournit avec la bibliothèque MIDIUSB fait la même chose, mais avec une seule note.  De plus, des informations apparaissent dans le moniteur série de l'IDE Arduino, ce qui peut aider au débogage.

Si vous préférez fabriquer un petit contrôleur MIDI, jetez un oeil sur la page MidiDevice du site officiel Arduino: on vous guide dans la fabrication d'un clavier MIDI constitué de 7 boutons poussoirs.


Exemple 2:  communication de l'ordinateur vers l'Arduino (MIDI in)

Dans ce deuxième exemple, nous allons envoyer des messages MIDI de l'ordinateur vers l'Arduino.  Pour vérifier que ça fonctionne, vous pouvez essayer l'exemple "MIDIUSB_read" fourni avec la bibliothèque MIDIUSB: lorsque vous jouez une note sur le clavier du logiciel Virtual MIDI Piano Keyboard, elle s'affiche dans le moniteur série de l'IDE Arduino.

Pour ma part, j'ai essayé quelque chose qui me semblait un tout petit peu plus amusant:  chaque fois que je clique sur une note du logiciel Virtual MIDI Piano Keyboard, l'Arduino produit cette note à travers un haut-parleur.  Le Leonardo servira donc de synthétiseur MIDI (remarquez que la pertinence du projet est un peu discutable: la carte de son de l'ordinateur produit un son de bien meilleur qualité que la fonction tone de l'Arduino...).

Circuit

Le haut-parleur est relié à la broche 8 du Leonardo, par l'entremise d'un transistor pour éviter que le haut-parleur, à cause de sa très faible impédance, ne draine trop de courant (plus de détails ici).

Sketch

Lorsque le Leonardo reçoit un message "noteOn", il établit une correspondance entre le code MIDI qui indique la hauteur de la note (pitch) et la fréquence qui devra être émise par le haut parleur.  La variable MidiToFreq est un tableau bi-dimensionnel qui contient, pour chaque pitch MIDI, la fréquence en hertz.  Une fois la fréquence connue, on utilise la fonction tone pour jouer cette note sur le haut-parleur (broche 8).  Lorsqu'on reçoit un message "noteOff", on utilise noTone pour interrompre le signal PWM de la broche 8.



Réglages du logiciel MIDI

Pour que le logiciel Virtual MIDI Piano Keyboard achemine les messages vers la carte Leonardo, il faut effectuer quelques réglages, en passant par "Connexions MIDI" dans le menu Éditer.

Si la carte est branchée à un port USB de l'ordinateur, "Arduino Leonardo" devrait être disponible dans la liste "Connexion du port de sortie".

Chaque fois que vous cliquez sur une touche du clavier de piano dans la fenêtre du logiciel Virtual MIDI Piano Keyboard, la note se fait entendre dans le haut-parleur branché à l'Arduino (pour que toutes les touches fonctionnent, réglez le paramètre "Octave de base" à 3).

À lire également:

D'autres projets impliquant l'Arduino Leonardo:

• Émuler une souris avec l'Arduino Leonardo
• Data logging avec Arduino Leonardo
• Contrôle d'un diaporama Powerpoint avec Arduino Leonardo

Yves Pelletier   (Twitter, Facebook)

Data logging avec Arduino Leonardo

Les microcontrôleurs constituent un outil précieux dans le domaine scientifique, grâce à la possibilité d'y brancher différents capteurs afin de prendre des mesures. 

Lorsqu'il s'agit de mesures nombreuses, étalées sur une certaine plage de temps, il faut penser à un moyen d'enregistrer ces données et les rendre disponibles à l'utilisateur.

Pour ce faire, il existe plusieurs méthodes, et j'en ai déjà exploré quelques-unes  dans ce blog: enregistrer un fichier "csv" sur une carte SD, ajouter une macro à votre tableur pour qu'il recueille les données par communication série, utiliser un service en ligne comme carriots, ou simplement utiliser le moniteur série et/ou le traceur série intégrés dans l'IDE Arduino...

Aujourd'hui, je procède autrement:  puisque la carte Arduino Leonardo peut se comporter comme un clavier USB, il est facile de la programmer pour qu'elle écrive les données dans un tableur.

Ce n'est probablement pas la façon la plus élégante de procéder; l'utilisateur devra prendre soin d'ouvrir un tableur (Excel, Google Sheets, Libre Office Calc), d'y sélectionner la cellule qui recevra la première donnée, et de conserver le logiciel à l'avant-plan pendant toute la durée de la mesure... Mais ça fonctionne, et ce n'est pas très difficile à réaliser.

Le circuit

Pour faire mes tests, j'ai fabriqué un capteur de température constitué d'une thermistance et d'une résistance.  Lorsque la température augmente, la thermistance devient moins résistive, ce qui a pour effet de diminuer la tension acheminée à l'entrée A0 de la carte Leonardo.

Évidemment, vous pouvez remplacer ce capteur par n'importe quel autre, peu importe qu'il soit analogique ou numérique (il peut même y en avoir plusieurs), en apportant des modifications mineures au sketch présenté plus bas.

Le sketch

Le bref programme présenté ci-dessous "tape au clavier" le temps écoulé depuis le démarrage de la carte (fonction"millis"), envoie le code ASCII de la touche "tab" pour passer à la cellule voisine de droite, écrit la valeur lu à l'entrée analogique A0, envoie le code ASCII de la touche "enter" pour descendre d'une ligne, puis attend 1 seconde avant de recommencer.

Prenez note d'une importante précaution qui nous permet d'interrompre au besoin la prise de données:  la routine s'effectue à la condition que la broche 2 de la carte soit au niveau logique haut (5 V).  Ainsi, lorsque vous désirez reprogrammer la carte, vous reliez la broche 2 à GND pour éviter que les mesures soient dactylographiées à l'intérieur de votre sketch!!!



Le résultat

Après avoir ouvert un tableur, vous sélectionnez  une de ces cellules, puis vous reliez la broche 2 à 5 V.  Les données s'écrivent sur deux colonnes: le temps dans la colonne de gauche, et la mesure de l'entrée A0 dans la colonne de droite.

Le graphique ci-dessous a été produit dans Google Sheets: j'ai tenu la thermistance entre mon pouce et mon index pour la réchauffer, puis je l'ai laissé reprendre sa température initiale.

Si vous voulez, vous pouvez préparer le tableur pour que les données soient présentées sous forme de graphique à mesure qu'elles sont prises.  Vous pouvez également effectuer les calculs nécessaires pour convertir les mesures (soit dans le sketch Arduino, soit dans le tableur).


Yves Pelletier   (Twitter, Facebook)

Émuler une souris avec l'Arduino Leonardo

Une caractéristique intéressante des cartes Arduino Leonardo, c'est que les ordinateurs les reconnaissent comme de véritables périphériques USB.  On peut donc programmer le Leonardo afin qu'il se comporte comme un clavier ou une souris.

Le langage Arduino vous propose 7 fonctions permettant de reproduire le mouvement d'une souris d'ordinateur:

• Mouse.begin() est nécessaire pour initialiser l'émulation et utiliser les autres fonctions décrites ci-dessous.  Typiquement, vous l'utilisez à l'intérieur de setup().  Si vous désirez interrompre l'émulation de la souris, utilisez Mouse.end().

• Mouse.move(x, y, wheel) permet de faire bouger le pointeur de souris à l'écran de l'ordinateur.  x est le nombre de pixels dont on désire faire bouger le pointeur horizontalement, alors que y est le nombre de pixels dont on désire déplacer le pointeur verticalement.  Notez que ces déplacements sont relatifs à la position initiale du pointeur sur l'écran.

• Avec Mouse.click(), votre Leonardo aura le même comportement que si vous aviez cliqué avec le bouton gauche de la souris.  Si vous désirez produire un clic sur le bouton droit, vous utilisez Mouse.click(MOUSE_RIGHT).

• Mouse.press() ressemble à Mouse.click(), sauf que le bouton demeure enfoncé jusqu'à ce que vous appeliez Mouse.release().

• Mouse.isPressed() est un booléen dont la valeur sera vraie si une le bouton d'une souris reliée à l'ordinateur est enfoncé.

Le site officiel Arduino présente deux exemples très clairs pour construire votre propre souris au moyen de 5 boutons poussoirs, ou pour contrôler le pointeur au moyen d'un joystick analogique.

Question de ne pas refaire inutilement des projets qui existent déjà, je vous propose un petit sketch inutile mais rigolo qui vous permettra  de jouer un tour à vos amis: la souris truquée.  Lorsque vous branchez l'Arduino Leonardo au port USB de l'ordinateur, le pointeur de souris se mettra à bouger avec une trajectoire circulaire, comme dans la vidéo ci-dessous.  Avec une telle souris hyperactive, l'utilisateur aura bien du mal à contrôler son ordinateur...

Mais prenez garde de ne pas vous piéger vous-mêmes: si le pointeur se met à faire des cercles aussitôt que la carte Leonardo est branchée à votre ordinateur, vous serez incapable de téléverser un autre sketch dans la carte, lorsque vous en aurez assez de celui-ci.  Pour cette raison, il faut prévoir un moyen de d'empêcher la carte d'exécuter sa routine.  Dans le sktech ci-dessous, nous vérifions d'abord l'état de la broche numéro 2 de l'Arduino.  Si elle est au niveau logique haut, nous faisons bouger le pointeur de la souris, mais si elle est au niveau logique bas, nous ne faisons rien.  Donc vous reliez la broche 2 à la sortie 5 V au moyen d'un fil conducteur lorsque vous voulez faire tourner le pointeur à l'écran, mais vous la reliez à la masse (GND) lorsque vous souhaitez reprogrammer la carte.

À lire également:

D'autres projets impliquant l'Arduino Leonardo:

• Data logging avec Arduino Leonardo
• Contrôle d'un diaporama Powerpoint avec Arduino Leonardo
• Midi par USB avec Arduino Leonardo

Yves Pelletier   (Twitter, Facebook)