dimanche 8 juillet 2018

Capteur de force résistif et Arduino


Un capteur de force résistif (aussi appelé "résistance à capteur de force" ou FSR pour "force sensing resistor") est un petit dispositif dont la résistance électrique varie selon la pression qui lui est appliquée (à ne pas confondre avec un capteur piézoélectrique qui, lui, génère une tension lorsqu'on le soumet à une pression).

Fabriqué à partir d'un polymère conducteur, un tel capteur est facile à utiliser puisque sa résistance varie de façon importante avec la force (contrairement à une jauge de contrainte, dont l'utilisation nécessite un pont de Wheatstone capable de détecter de très faibles variations de résistance).  De plus, ces capteurs sont très petits, minces et flexibles.  Ils ne sont toutefois pas appropriés pour des mesures de précision (on parle au mieux d'une précision de 5% à 10%) et chaque capteur doit être calibré individuellement (soumis à la même force, deux capteurs de même modèle n'auront pas nécessairement la même résistance).

Grâce à ce genre de capteur, on peut construire, par exemple, un instrument de musique sensible à la force exercée par les doigts de musicien: le son pourra être différent selon que vous appuyez fortement ou pas sur la touche.

J'ai fait quelques tests avec le modèle RP-C7.6-LT (choisi à cause de son prix très modique).  Je n'ai pas trouvé de fiche technique complète mais, selon les informations fournies par le vendeur, ce capteur est conçu pour réagir à des forces situées entre 20 grammes et 1500 grammes.

Il est habituellement déconseillé de souder les connecteurs de ce genre de capteur, car la chaleur pourrait abîmer sa partie active.  J'ai d'abord essayé d'insérer les broches du capteur directement dans une breadboard, mais le contact se faisait mal et les broches ressortaient d'elles-mêmes (broches trop courtes, peut-être).  J'ai obtenu de meilleurs résultats en insérant les broches du capteur dans un bornier à vis, lui-même placé sur une breadboard.

J'ai ensuite utilisé un multimètre afin d'observer comment varie la résistance de mon capteur lorsque je le soumet à différentes forces.


Lorsqu'aucune force n'est exercée sur le capteur, le multimètre indique une résistance infinie.  Une légère pression sur le capteur produit une résistance plutôt instable qui peut tourner autour de 20 kΩ à 25 kΩ.   La résistance est ensuite de plus en plus faible à mesure qu'on augmente la force, jusqu'à atteindre une valeur minimale d'environ 1,5 kΩ.

Pour brancher le capteur sur un microcontrôleur (une carte Arduino, par exemple), il faut que cette résistance variable provoque une tension variable.  Pour ce faire, nous allons construire le traditionnel circuit diviseur de tension, en plaçant notre capteur de force en série avec une résistance fixe, et en branchant la jonction des deux résistances à une entrée analogique de l'Arduino:

Deux versions sont possibles, selon nos besoins: dans le circuit A, la tension mesurée à l'entrée A0 augmente à mesure qu'on augmente la force sur le capteur (puisque cette augmentation de force a pour effet de diminuer la résistance du capteur), alors que dans le circuit B, la tension mesurée à l'entrée A0 diminue à mesure qu'on augmente la force sur le capteur.

Il nous reste à choisir la valeur de la résistance fixe.  En général, on souhaite que la variation de résistance de notre capteur cause une forte variation de tension à l'entrée analogique du microcontrôleur.  La plus grande variation de tension est obtenue pour une résistance fixe égale à la racine carrée du produit des résistances extrêmes pouvant être atteintes par le capteur:

Rfixe = (Rmin * Rmax)1/2

(Si vous vous y connaissez un peu en calcul différentiel, il s'agit de la valeur pour laquelle la dérivée de la variation de la tension est nulle).

Dans mon cas, en considérant que la résistance de mon capteur peut varier entre Rmin  = 1,5 kΩ et Rmax = 25 kΩ, la résistance fixe pour laquelle la variation de tension est la plus grande est d'environ 6 kΩ:

Rfixe = (Rmin * Rmax)1/2 = (1,5 * 25)1/2 = 6 kΩ

Toutefois:  même si ce n'est pas spécifié dans les informations fournies par le vendeur de mon capteur, on conseille généralement de ne pas dépasser un courant maximal d'environ 1 mA par cm2 de surface utile du capteur (il s'agit de la région circulaire qui porte un motif constitué de droites parallèles).  Sur mon capteur, ce cercle a un diamètre de 6 mm, donc une aire de 0,3 cm2...il ne faudrait pas que le courant traversant le capteur dépasse significativement 0,3 mA!

Avec une tension de 5 V, la résistance totale doit être d'au moins 16,7 kΩ pour que le courant ne dépasse pas 0,3 mA.  Puisque la résistance du capteur ne descend pas en dessous de 1,5 kΩ, j'ai donc besoin d'au moins 15 kΩ comme résistance fixe: c'est ce que j'ai utilisé.  La variation de tension ne sera pas aussi grande que si j'avais utilisé une résistance fixe de 6 kΩ , mais je m'assure que le courant ne dépassera pas la valeur maximale admissible.

Il va sans dire que vous devrez faire vos propre calculs en utilisant les valeurs extrêmes du capteur de force que vous utiliserez.

Voici donc mon circuit: un capteur de force résistif, une résistance de 15 kΩ, et une carte Arduino.



On peu ensuite utiliser le sketch "AnalogReadSerial", disponibles dans le menu Exemples, pour afficher les valeurs dans le moniteur série.





Le reste dépend de votre imagination: la force exercée sur le capteur peut servir à allumer des LEDs, faire tourner un servomoteur, modifier la fréquence d'un son...


Yves Pelletier   (TwitterFacebook)

vendredi 22 juin 2018

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.







Yves Pelletier   (TwitterFacebook)

lundi 18 juin 2018

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

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/Bureau/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 sur le bureau (si votre Rasbperry Pi parle anglais, ce sera "Desktop" plutôt que "Bureau").  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   (TwitterFacebook)


Related Posts Plugin for WordPress, Blogger...