mardi 30 décembre 2014

Secouons cet accéléromètre!

Aujourd'hui, j'ai ressorti mon accéléromètre MMA7455 dont je vous avais brièvement parlé en mars 2013, mais que je n'avais jamais vraiment utilisé. Le but, aujourd'hui, est de mesurer à quel point l'accéléromètre est énergiquement secoué, sur une échelle de 0 à 10. Si l'accéléromètre est immobile, on affiche zéro, s'il est moyennement secoué, on affiche 5, et s'il est très énergiquement secoué, on affiche 10.

Comme tout matériel, j'ai utilisé un breakout comportant l'accéléromètre MMA7455, fabriqué par LCStudio, et un Arduino Uno.

Connexions:

Il n'y a que 4 fils à brancher:
  • Vcc du breakout au 5 V de l'Arduino
  • GND du breakout au GND de l'Arduino
  • SCL du breakout à l'entrée analogique A5 de l'Arduino
  • SDA du breakout à l'entrée analogique A4 de l'Arduino

(Attention:  Si vous utilisez un autre modèle de breakout que celui qui est illustré ci-dessus, il est possible que vous deviez ajouter des résistances de tirage à SCL et SDA, que vous deviez brancher CS à Vcc, et que l'alimentation appropriée soit de 3,3 V plutôt que de 5 V...).

Bibliothèque MMA7455

Ensuite, nous téléchargeons et installons la bibliothèque spécialement conçue par Moritz Kemper pour utiliser ce genre d'accéléromètre avec l'Arduino.

Petite précaution, par contre:  nous allons devoir corriger un bug dans la bibliothèque (à moins, bien sûr, que le bug ait déjà été corrigé au moment où vous lisez ces lignes).

Ouvrez le fichier "MMA_7455.cpp" au moyen de votre éditeur de texte préféré, et détectez ce paragraphe (ce sont les lignes 30 à 44):


Au début du fichier, l'auteur a soigneusement défini les constantes MMA_7455_4G_MODE et MMA_7455_8G_MODE, mais à cet endroit il les appelle par erreur  MMA_7455_2G_MODE.

Le remède est simple:  si sensitivity vaut 4, il faut écrire "MMA_7455_4G_MODE" (on remplace le 2 par un 4), et si sensitivity vaut 8, il faut écrire  "MMA_7455_8G_MODE" (on remplace le 2 par un 8):


 Bien entendu, vous enregistrez et fermez le fichier.


Le sketch

Voici maintenant le sketch qui affichera sur le moniteur série une valeur de 0 à 10 indiquant à quel point l'accéléromètre est fortement secoué.

La sensibilité de l'accéléromètre peut être réglée à 2 (pour mesurer des accélérations se situant entre -2g et +2g), à 4 (pour mesurer des accélérations se situant entre -4g et +4g), ou à 8 (pour mesurer des accélérations se situant entre -8g et +8g).  Il est parfaitement possible d'atteindre un accélération d'environ 8g en secouant l'accéléromètre de façon très énergique, et nous avons donc réglé la sensibilité à 8.

Il peut être pertinent de calibrer votre accéléromètre.  Lorsqu'il est immobile, à plat sur la table (avec la mention "LCStudio" vers le bas), il devrait indiquer une accélération nulle en x et en y, et une accélération de 15 (valeur correspondant à 1 g, qui est l'effet de la force de gravité) sur l'axe des z.  Le mien indiquait -2, -6 et 17, c'est pourquoi j'utilise "calibrateOffset(2, 6, -2)" pour compenser.

L'accéléromètre mesure les 3 composantes de l'accélération (x, y et z), mais je ne m'intéresse qu'à sa grandeur, peu importe sa direction.  C'est pourquoi je calcule la racine carrée de x²+y²+z² (j'ai appliqué le théorème de Pythagore).  Et puisque cette accélération est loin d'être constante pendant qu'on secoue l'accéléromètre, je fais une moyenne sur une centaine de mesures.

Dans cette version, la valeur est affichée sur le moniteur série de l'ordinateur.  Bien entendu, on pourrait allumer des LEDs, afficher le résultat sur un LCD, etc.

Pour bien des utilisations, vous désirerez simplement détecter si oui ou non l'accéléromètre a été secoué, auquel cas il devrait être facile de modifier mon sketch pour répondre à vos besoins.


La prochaine fois, nous verrons comment utiliser l'accéléromètre pour mesurer une inclinaison.

Yves Pelletier (Twitter: @ElectroAmateur)

samedi 27 décembre 2014

Moteur pas à pas et STM32 Nucleo

Voici donc un cinquième tutoriel mettant en vedette la carte STM32 Nucleo de ST Microelectronics, et l'environnement de programmation en ligne mbed.  Au cours des derniers mois, nous avons vu comment allumer des LEDs et lire l'état de boutons, comment afficher les données à l'écran d'un ordinateur ou sur un afficheur LCD, et comment contrôler un simple moteur cc.  Aujourd'hui, comme vous l'avez certainement deviné en lisant le titre de cet article, nous allons utiliser  la carte STM32 Nucleo pour contrôler un moteur pas à pas.



Matériel nécessaire:

1)  Un moteur pas à pas.  Il peut être bipolaire (4 fils) ou unipolaire (5 ou 6 fils), ça n'a pas vraiment d'importance.  De toute façon, nous ne brancherons que 4 fils.

2)  Une carte STM32 Nucleo.  J'ai utilisé le modèle d'entrée de gamme F030R8, mais n'importe laquelle fera l'affaire.



3)  Un double pont en H L293D qui servira d'intermédiaire entre le microcontrôleurs de la carte Nucleo et le moteur (la carte Nucleo enverra des instructions au L293D, qui se chargera de faire circuler un courant d'intensité suffisante dans le moteur).

4) Une alimentation pour votre moteur (pile, alimentation ATX, etc.).  Évitez d'alimenter votre moteur directement sur la pin 5 V de la carte, ça pourrait causer des problèmes en tirant trop de courant.



Comment on branche tout ça?

Le plus simple est d'illustrer le L293D, puisque tous les autres composants y sont reliés:

  •  Les pins 1, 9 et 16 du L293D sont branchées à la sortie 5V du STM32 Nucleo.
  • Les pins 2, 7, 10 et 15 sont branchées respectivement aux sorties D2, D3, D4 et D5 du STM32 Nucleo.
  • Votre moteur pas à pas est constitué de deux bobinages distincts.  Les fils aux extrémités du premier bobinage sont reliés aux pins 3 et 6 du L293D, et les fils aux extrémités du deuxième bobinage sont reliés aux pins 11 et 14 du L293D.  Si votre moteur est monopolaire, vous n'avez pas à brancher le ou les fils correspondant au centre des bobinage.
  • Les pins 4, 5, 12 et 13 du L293D représentent la masse.  Elles communiquent déjà entre elles, mais il est important d'y relier à la fois la masse (GND) du SMT32 Nucleo et la masse (borne négative) de la source d'alimentation du moteur.
  • La borne positive de l'alimentation du moteur est branchée à la pin 8 du L293D.

Le script mbed pour le STM32 Nucleo

Voici un petit script mbed à télécharger dans la carte STM32 Nucleo pour faire tourner le moteur (il effectuera d'abord 200 pas dans un sens, rapidement, puis 20 pas dans l'autre sens, beaucoup plus lentement).   Cet exemple ne nécessite aucune bibliothèque (sauf la bibliothèque de base de mbed), et il vous sera facile de le modifier pour qu'il réponde parfaitement à vos besoins.

Yves Pelletier (Twitter:  @ElectroAmateur)



mercredi 10 décembre 2014

Contrôle d'un moteur pas à pas par un Raspberry Pi

Aujourd'hui, je vous explique comment commander un moteur pas à pas au moyen d'un Raspberry Pi.

(Si vous cherchez plutôt à contrôler un simple moteur à courant continu à partir du Raspberry Pi, je vous suggère plutôt la lecture de cet article.)

En plus d'un Raspberry Pi et d'un moteur pas à pas (qu'on peut facilement trouver à l'intérieur d'une vieille imprimante), vous aurez besoin d'un L293D, qui est un circuit intégré spécialement conçu pour piloter un moteur, et d'une source d'alimentation continue pour le moteur (une pile, par exemple).

Le courant nécessaire pour faire tourner le moteur est trop intense pour que ce dernier puisse être directement branché aux pins GPIO du Raspberry Pi.  Le rôle du L293D sera donc, en gros, de faire circuler des courants intenses dans le moteur au moyen de la source d'alimentation, en conformité avec les instructions que lui fournira le Raspberry Pi.

Le moteur:  bipolaire ou unipolaire?

Votre moteur pas à pas peut comporter 4, 5 ou 6 fils.

S'il comporte 4 fils, il s'agit d'un moteur bipolaire.  Deux des fils sont branchées aux extrémités d'une même bobine (située à l'intérieur du moteur), et les deux autres fils sont aux extrémités d'une deuxième bobine.

Au moyen d'un multimètre, il est facile de déterminer quels fils partagent la même bobine.   Par exemple, un de mes moteurs est muni de 4 fils: jaune, orange, brun et noir. La résistance entre le fil jaune et le fil orange est de 31 ohms, et la résistance entre le fil brun et le fil noir est de 31 ohms également. La résistance est infinie pour toutes les autres combinaisons de fils (jaune-noir, jaune-brun, orange-noir, orange-brun). Je peux en déduire qu'une des bobines est alimentée par le fil jaune et le fil orange, et que l'autre bobine est alimenté par le fil brun et le fil noir.

Pour les moteurs unipolaires, les choses se compliquent un peu: chacune des deux bobines est munie de 3 fils: un à chaque extrémité, et un au centre. De plus, il est fréquent que le centre des deux bobines soit branché au même fil.

Par exemple: J'ai un moteur qui comporte 6 fils. La résistance entre le fil 1 et le fil 3 est de 70 ohms, la résistance entre le fil 1 et le fil 5 est de 140 ohms: ces trois fils partagent le même bobinage et le fil 3 est au centre. Un lien similaire existe entre les fils 2, 4 et 6.

Autre exemple: j'ai un moteur muni de 5 fils: blanc, jaune, noir, rouge, brun. La résistance est de 80 ohms entre le fil noir et n'importe quel autre fil, alors qu'elle est de 160 ohms pour toutes les autres paires de fil. J'en déduis que le fil noir est relié au centre des deux bobinages. Mais comment savoir quel fil (parmi jaune, rouge et brun) partage le même bobinage que le fil blanc? Il faudra faire des essais: si on branche les fils de façon incorrecte, le moteur ne tournera pas aussi bien qu'il le devrait (il s'agira alors de permuter les fils jusqu'à ce que le moteur fonctionne correctement).

Le circuit

Le L293D est capable de faire circuler le courant dans les deux sens à travers les bobinages:  il fonctionne donc à la perfection peu importe que votre moteur soit unipolaire ou bipolaire (en fait, si votre moteur est unipolaire, nous n'auront même pas à brancher le ou les fils qui communiquent avec le centre des bobinages:  seuls les 4 fils correspondant aux extrémités des bobinages seront nécessaires).

Voici le circuit (vous pouvez cliquer sur l'image pour l'agrandir...):


  • La pin 1 du L293D est branchée au 5 V du Raspberry Pi
  • La pin 2 du L293D est branchée à la pin GPIO 22 (board 15) du Raspberry Pi
  • La pin 3 du L293D est branchée à une extrémité du premier bobinage du moteur
  • La pin 4 ou la pin 5 du L293D est branchée à la masse (GND) du Raspberry Pi
  • La pin 6 du L293D est branchée à l'autre extrémité du premier bobinage du moteur
  • La pin 7 du L293D est branchée à la pin GPIO 23 (board 16) du Raspberry Pi
  • La pin 8 du L293D est branchée à la borne positive de l'alimentation du moteur (la borne négative de cette alimentation est reliée à la masse GND).
  • La pin 9 du L293D est branchée au 5 V du Raspberry Pi
  • La pin 10 du L293D est branchée à la pin GPIO 25 (board 22) du Raspberry Pi
  • La pin 11 du L293D est branchée à l'exrémité du deuxième bobinage du moteur
  • La pin 12 ou la pin 13 du L293D est branchée à la masse (GND) du Raspberry Pi
  • La pin 14 du L293D est branchée à l'autre extrémité du deuxième bobinage du moteur
  • La pin 15 du L293D est branchée à la pin GPIO 24 (board 18) du Raspberry Pi
  • La pin 16 du L293D est branchée au 5 V du Raspbery PI

Si votre moteur est unipolaire (5 ou 6 fils) le ou les fils relié(s) au centre des bobines n'ont pas à être branchés.


Programme en Python

Ce script vous demande le délai (en millisecondes) qui s'écoulera entre chaque pas du moteur.  Plus ce délai est long, plus le moteur tournera lentement.  Pour une rotation rapide, un  délai d'environ 10 millisecondes devrait faire l'affaire (si le délai est trop court, le moteur ne tourne pas).  Avec un délai de 1000 millisecondes, le moteur tourne d'un pas à chaque seconde, un peu comme la trotteuse d'une horloge.

Le programme vous demande ensuite le nombre de pas que devra effectuer le moteur.  Vous pouvez écrire un nombre positif pour une rotation en marche avant, et un nombre négatif pour une rotation en marche arrière.

Après avoir copié ce programme dans un fichier intitulé "pas_a_pas.py", vous pourrez l'exécuter en tapant "sudo python pas_a_pas.py" dans le terminal.



Références:

Je me suis inspiré de cet article sur le site d'Adafruit, et de celui-ci sur le blog Raspberry Pi Spy.  Et au bout du compte, comme d'habitude, je n'ai fait qu'à ma tête.

Yves Pelletier (Twitter:  @ElectroAmateur)

mardi 9 décembre 2014

Choix d'un Raspberry Pi et de ses accessoires: quelques conseils

Cet article n'a pas la prétention d'être un guide universel pour l'achat d'un Raspberry Pi et de ses accessoires:  il s'agit simplement de quelques conseils et impressions basées sur mon expérience personnelle.

Nous n'achetons pas tous un Raspberry Pi pour les mêmes raisons. Si, tout comme moi, votre intention est d'utiliser principalement le Raspberry Pi pour contrôler des moteurs de robots et lire de capteurs branchées à ses pins GPIO, mes observations seront probablement plus pertinentes que si vous désirez d'abord et avant tout jouer à Minecraft, programmer des jeux avec Scratch,  ou transformer votre Raspberry Pi en "media center".

Commençons par les éléments qui sont strictement nécessaires:

La carte Raspberry Pi

Le Raspberry Pi que j'utilise est le modèle B.   S'il s'agit de votre premier Raspberry Pi et que votre intention est de l'utiliser pour expérimenter plusieurs applications différentes,  le modèle B+ semble un choix évident.

Le modèle A+ est moins cher, mais il me semble plus approprié pour des applications spécifiques, quand vous êtes certains de ne pas utiliser le port Ethernet, par exemple.  Ceci dit, je n'ai encore jamais eu l'occasion d'utiliser ce modèle alors je parle peut-être à travers mon chapeau.

L'alimentation

Il est également essentiel de vous procurer une alimentation continue de 5 V munie d'un connecteur micro-USB.  Assurez-vous que votre alimentation est en mesure de fournir au moins 1 ampère (2 ampères, c'est encore mieux).

Si vous disposez déjà d'une alimentation de labo ou d'une alimentation ATX récupérée d'un ordinateur et que votre seul problème est le connecteur micro-USB, il est parfaitement possible de bricoler un câble qui fera le lien entre votre alimentation et le Raspberry Pi.  Si par erreur vous réglez votre alimentation à plus de 5V, le Raspberry Pi est en principe protégé par un fusible réarmable qui reprendra ses caractéristique normales au bout de quelques dizaines de minutes (ou même quelques heures).

Il est même possible d'alimenter votre Raspberry Pi par ses pins GPIO (5 V et GND), mais cette méthode n'est pas recommandée aux âmes sensibles:  en cas de surtension, le Raspberry Pi ne dispose alors d'aucune protection!


Carte SD

La fondation Raspberry Pi recommande une carte SD de 8 Go, classe 4 (la classe indique la rapidité de la carte:  une carte de classe 2 aura tendance à ralentir les performances de votre Raspberry Pi).

Je ne vois aucun intérêt à payer plus cher pour acquérir une carte dans laquelle le système d'exploitation est déjà installé: ce système peut être téléchargé gratuitement sur le site web de la fondation Raspberry Pi, et son installation est très facile.

Poursuivons avec des accessoires qui peuvent être utiles, mais qui ne sont peut-être pas nécessaires (tout dépend de l'utilisation que vous souhaitez faire de votre Raspberry Pi).

Écran HDMI, Clavier USB, Souris USB

Tout ça sera nécessaire si vous désirez utiliser le Raspberry Pi comme ordinateur autonome, ce que je ne fais pratiquement jamais.

Un des avantages du Raspberry Pi, c'est sa petite taille.  Si vous y branchez en permanence un écran, un clavier et une souris, il se met soudainement à prendre beaucoup d'espace sur votre bureau.  Pour moi, c'est beaucoup plus pratique de commander le Raspberry Pi à distance à partir d'un autre ordinateur, en utilisant les protocoles SSH et VNC.  (Petit bémol: au grand désespoir de mon fils, il semble impossible de jouer à Minecraft sans qu'un moniteur soit directement branché au Raspberry Pi).

Ceci dit, lors du premier démarrage, l'écran, le clavier et la souris nous facilitent la vie lorsque nous effectuons les premiers réglages du Raspberry Pi.  Ma recommandation serait donc:  assurez-vous d'avoir accès à un moniteur HDMI, un clavier USB et une souris USB, que vous pourrez temporairement  "emprunter" d'un autre ordinateur lors du premier démarrage du Raspberry Pi, le temps d'effectuer de façon confortable les réglages qui vous permettront ensuite utiliser votre Raspberry Pi à distance.

Clé USB WI-FI ("dongle")

Pendant quelques mois, chaque fois que désirais utiliser mon Raspberry Pi, ce dernier devait être branché à mon routeur au moyen d'un câble ethernet.  C'était vraiment irritant, car mon routeur est situé loin de l'endroit où je fais habituellement de l'électronique.  Depuis que je me suis procuré ce petit dongle Wi-Fi, je peux contrôler mon Raspberry Pi à partir de n'importe quel ordinateur de mon réseau domestique, peu importe où il se trouve. 

En ce qui me concerne, cet accessoire est essentiel, bien avant un clavier ou un moniteur.


Connecteurs pour les pins GPIO

J'ai utilisé trois méthodes:  un câble en nappe "fabrication maison" qui reproduisait sur une breadboard la même configuration de pins que sur le Raspberry Pi, des câbles "mâle-femelle" permettant de relier individuellement chaque pin GPIO à la breadboard, et finalement un "GPIO Extension Board" comme celui qui est illustré ci-contre.

En ce qui me concerne, l'irritant principal du Raspberry Pi est la numérotation des pins:  puisque ces dernières ne sont pas disposées dans l'ordre de leur numérotation GPIO, les branchements deviennent beaucoup plus simples si le numéro des pins est clairement indiqué sur la breadboard.

Voilà donc en principe un avantage pour le "GPIO Extension Board":  les pins sont clairement identifiées, et ordonnées de façon logique... sauf que ses concepteurs ont eu la drôle d'idée d'utiliser une troisième forme de numérotation!  Ainsi, la pin numéro 11 (en numérotation "board") qui est aussi la GPIO 17 (en numérotation BCM) porte le nom "P0" sur la breadboard!

Néanmoins, la solution qui semble répondre le mieux à mes besoins est une breadboard reliée en permanence au Raspberry Pi par l'entremise d'un "GPIO extension board" et d'un câble en nappe.

Superflu

Boîtier

Je ne sais pas pourquoi on insiste tellement pour essayer de vous vendre un boîtier pour le Raspberry Pi.  Est-ce que vous mettez votre Arduino dans un boîtier, vous?

Si vous avez l'intention d'utiliser les pins GPIO de votre Raspberry Pi, le boîtier va  rendre leur accès plus difficile.

J'ai acheté un boîtier, mais je ne l'utilise plus:  lorsque le Raspberry Pi se trouve dans le boîtier, il n'y a pas assez d'espace pour brancher mon câble en nappe sur les pins GPIO!



Yves Pelletier (Twitter:  @ElectroAmateur)



samedi 15 novembre 2014

Logiciels d'aide à la conception de circuits sur perfboard

Aujourd'hui, nous jetons un oeil sur deux logiciels qui aident à planifier la disposition de vos composants électroniques sur un perfboard avant de commencer la soudure.  Car comme vous l'avez peut-être déjà vous-même constaté, c'est toujours un peu frustrant, après avoir soudé une dizaine de composants sans plan précis, de se rendre compte qu'on aurait mieux fait de tout décaler de deux trous vers la gauche...

Comprenons-nous bien:  aucun de ces deux logiciels n'est doté d'une quelconque forme d'intelligence artificielle permettant d'optimiser automatiquement, à votre place, le design de votre circuit.  Ils remplacent simplement l'utilisation d'une feuille de papier quadrillé, d'un crayon et d'une gomme à effacer:  vous disposez des composants sur un perfboard virtuel, et vous les déplacez à votre guise jusqu'à ce que le résultat vous convienne.

J'ai donc exploré DIY Layout Creator 3.28 et Blackboard Circuit Designer 1.1 sous Linux Mint 17, mais ces deux logiciels gratuits peuvent également être utilisés sous Windows ou MacOS.

Dans les deux cas, je vais créer une perfboard de 24 trous X 18 trous et disposer sur celle-ci un échantillonnage de composants fréquemment utilisés (circuit intégré, résistances, condensateurs, LEDs, diodes, transistors, etc.).  Il s'agit d'un circuit bidon dont le seul but est de voir de quoi a l'air le résultat dans chacun des deux logiciels.


DIY Layout Creator

Commençons donc par le plus ancien des deux logiciels:  DIY Layout Creator.  À l'ouverture du logiciel, nous sommes accueillis par  un espace quadrillé et des onglets qui correspondent aux différentes catégories de composants.   Le logiciel a été créé par des passionnés de guitare électrique, ce qui explique la présence d'un onglet "Guitar".  Pour créer ma perfboard, je clique sur l'icône "Perf Board w/ Pads" sous l'onglet "Board" (d'autres options sont possibles, comme une VeroBoard, par exemple).



Une perfboard de 14 trous X 11 trous apparaît dans la zone quadrillée.  Pour la redimensionner, il s'agit de manipuler un des petits cercles verts au moyen de la souris.



Plaçons un circuit intégré sur notre perfboard:  nous cliquons sur le bouton qui représente un circuit intégré, sous l'onglet "Semiconductors".  Ensuite, nous déplaçons la souris sur la perfboard et cliquons là où nous désirons placer le circuit intégré.





vendredi 14 novembre 2014

Produire 35 volts avec 3 piles AA


J'ai fait quelques tests sur un convertisseur de tension continue DC-DC basé sur le circuit intégré XL6009 (DC-DC Adjustable Step-up Power Converter Module XL6009).  Comme toujours, les commerçants asiatiques nous proposent ces dispositifs pour un prix comparable à celui d'une tasse de café (le miens m'a coûté 1,50 USD).

Ce petit circuit se propose de convertir n'importe quelle tension d'entrée continue située entre 3 V et 32 V en une tension continue comprise entre 5 V et 35 V.

Comme vous pouvez le constater sur la photographie ci-dessus, la tension fournie par 3 piles AA NiMH fraîchement rechargées (4,30 V) peut facilement être transformée en 35.0 V.  En circuit ouvert, j'ai même atteint une tension de sortie de 48 V (un petit potentiomètre permet de régler la tension de sortie au moyen d'un tournevis).

Mais comme l'affirmait ce bon vieux Lavoisier, rien ne se perd et rien ne se créé:  puisqu'il est impossible que la puissance de sortie soit plus grande que la puissance d'entrée, le courant sera plus intense à l'entrée qu'à la sortie.

Par exemple, j'ai réglé le dispositif pour qu'il alimente une résistance de 176 Ω avec une tension continue de 9 V.  Sans surprise, cette résistance était traversée par un courant de 51 mA, donc une puissance de sortie de 0,46 W.  Pendant ce temps, à l'entrée, mes 3 piles AA débitaient 173 mA sous une tension de 3,67 V (donc une puissance d'entrée de 0,63 W).  Rendement:  73%.

Il y a toutefois une limite à l'intensité du courant que peut débiter une simple pile AA.  Pour cette raison, toujours avec ma résistance de charge de 176 Ω, la tension de sortie maximale n'était plus que de 19 V (comparativement aux 48 V atteints en circuit ouvert); pendant ce temps, mes pauvres piles étaient traversées par un courant de 0,812 A.  On est encore loin des 4 A que le convertisseur peut supporter, mais à ce rythme la charge de 1350 mA.h des piles sera vite épuisée.

Yves Pelletier (Twitter:  @ElectroAmateur)

dimanche 9 novembre 2014

Amplificateurs opérationnels (7): source de courant

Nous sommes tous familiers avec les sources de tension.  Une pile AA, par exemple, fournira une tension de 1,5 V peu importe le circuit auquel elle sera branchée.  Si vous branchez à la pile une résistance de 100 Ω, cette dernière sera soumise à une différence de potentiel de 1,5 V, et traversée par un courant de 15 mA.  Si vous branchez plutôt une résistance de 1000 Ω, la tension demeure 1,5 V mais l'intensité de courant ne sera plus que de 1,5 mA.

Aujourd'hui, nous allons voir comment utiliser un amplificateur opérationnel pour produire une source de courant:  peu importe la valeur de la résistance qui sera branchée à cette source, cette résistance sera parcouru par la même intensité de courant.

Matériel
  • Un amplificateur opérationnel (j'ai encore utilisé un UA741, mais comme je le répète depuis le début de cette série d'articles, un autre modèle fera très probablement l'affaire:  utilisez ce que vous avez).
  • Une source de tension continue pouvant fournir +12 V, +5 V et -12 V.  Comme d'habitude, j'ai utilisé une  alimentation ATX récupérée d'un vieil ordinateur.
  • Un multimètre qui nous servira à mesurer l'intensité de courant fournie par notre source de courant.
  • Une résistance de 1kΩ et un potentiomètre de 1kΩ.
À vos breadboards!

Voici le circuit:  rien d'exagérément compliqué ici.



Si vous tournez le bouton du potentiomètre, vous devriez constater que l'intensité de courant qui traverse le potentiomètre est de 5 mA, peu importe la résistance de ce dernier.  Il s'agit bel et bien d'une source de courant constante.

Quelques explications

 1) La tension à l'entrée non-inverseuse est nulle, puisque cette entrée est directement reliée à la masse.

2)  La tension à l'entrée inverseuse est également nulle.  Ça découle de l'équation
Vsortie = A ( V+ - V - ) .  Avec un gain "A" considéré comme infini, on trouve V+= V -.

3)  La résistance R1 est donc soumise à une différence de potentiel de 5 V (le potentiel est de 5V à sa gauche, et nul à sa droite).  Si on applique la loi d'Ohm, on en déduit qu'elle sera traversée par un courant de 5 mA (dans mon cas, la valeur exacte de la résistance R1 était de 965 Ω, j'ai donc mesuré un courant de 5,20 mA).

4)  Puisque l'impédance d'entrée de l'entrée inverseuse est vraiment très grande (idéalement infinie), tout le courant qui traverse la résistance R1 devra également traverser la résistance R2.   Le courant qui traverse R2 sera donc de 5 mA, peu importe ce que vaut R2!


Il y a quand même des contraintes à considérer lors de la conception de notre source de courant:

1)  Il y a un courant maximal que la sortie de l'amplificateur opérationnel ne peut pas dépasser (c'est environ 20 mA pour l'UA741).  Je ne pourrais pas, par exemple, mettre une résistance R1 de 100 Ω, car ça nécessiterait un courant de 50 mA, supérieur à la valeur maximale admissible.

2)  Il y a une tension maximale que la sortie de l'amplificateur opérationnel ne peut pas dépasser (idéalement 12 V, puisque c'est ce qui alimente l'amplificateur, mais significativement moins en pratique, à cause des pertes internes).  Par exemple, vous ne pourrez pas faire circuler un courant de 5 mA à travers une résistance R2 de 10 kΩ, car ça nécessiterait une tension de sortie de 50 V...

Article suivant:  Amplificateurs opérationnels (8):  oscillateur à pont de Wien 

Article précédent:  Amplificateurs opérationnels (6):  sommateur et le soustracteur

Yves Pelletier (Twitter:  @ElectroAmateur)

samedi 8 novembre 2014

Contrôle d'un ou deux moteurs CC avec STM32 Nucleo et L293D

Je continue de m'amuser avec ma carte STM32 Nucleo qui, rappelons-le, ne coûte pas très cher et est facile à programmer au moyen du compilateur en ligne mbed.

Cette fois, nous allons contrôler deux moteurs à courant continu, qui pourront tourner dans un sens ou dans l'autre à une vitesse que nous pourrons faire varier.   Ça nous sera certainement utile si l'envie nous prend de construire un robot dont le cerveau serait un STM32...


Le circuit

Il est hors de question de brancher nos moteurs directement sur les sorties de la carte Nucleo, ça risquerait de l'endommager sérieusement.  Le circuit intégré L293D (dont le nom officiel est "double pont en H") nous servira d'intermédiaire entre la carte Nucleo et les moteurs.  En gros, le Nucleo enverra des directives au L293D, et ce dernier utilisera ces directives pour faire tourner les moteurs dans la bonne direction et à la vitesse désirée.


Le circuit L293D sera alimenté par la carte Nucleo, mais nous avons besoin d'une alimentation dédiée aux moteurs (encore une fois dans le soucis de ne pas endommager notre carte avec des courants trop intenses).  Quelques piles placées en série feront l'affaire, assurez-vous simplement de ne pas dépasser la tension maximale supportée par vos moteurs.

Voici ce que je vous propose comme circuit.  Prenez soin de brancher ensemble toutes les masses (une pin GND du Nucleo, les 4 pins GND du L293D et la borne négative de l'alimentation des moteurs).   Bien entendu, si vous n'avez besoin que d'un seul moteur, il n'est pas nécessaire d'en brancher un deuxième...




  • Pin 1 du L293D :  Pin D9 du Nucleo
  • Pin 2 du L293D : Pin D3 du Nucleo
  • Pin 3 du L293D: Une des bornes du premier moteur
  • Pins 4, 5, 12, 13 du L293D:  GND du Nucleo et borne négative de l'alimentation des moteurs
  • Pin 6 du L293D:  L'autre borne du premier moteur
  • Pin 7 du L293D:  Pin D4 du Nucleo
  • Pin 8 du L293D:  Borne positive de l'alimentation des moteurs
  • Pin 9 du L293D:  Pin D10 du Nucleo
  • Pin 10 du L293D:  pin D5 du Nucleo
  • Pin 11 du L293D:  Une des bornes du deuxième moteur
  • Pin 14 du L293D: L'autre borne du deuxième moteur
  • Pin 15 du L293D: Pin D6 du Nucleo
  • Pin 16 du L293D:  Pin 5V du Nucleo
  •  
Le script

Voici un exemple de script que vous pourrez installer dans le Nucleo au moyen du compilateur mbed (voir mes articles précédents pour plus d'informations sur la façon d'utiliser mbed).

Pour chaque moteur, le sens de la rotation dépend des deux sorties numériques qui lui sont assignées.  La vitesse du moteur est réglée au moyen d'un signal PWM.

- -

Yves Pelletier (Twitter:  @ElectroAmateur)

mercredi 5 novembre 2014

Utiliser le moniteur série de l'IDE Arduino pour autre chose qu'une carte Arduino

Le moniteur série (ou "serial monitor") de l'environnement Arduino est drôlement utile lorsque vous avez besoin de déboguer un sketch, ou simplement d'afficher à l'écran d'un ordinateur des valeurs mesurées par des capteurs branchés à l'Arduino.

Lorsque vous programmez d'autres microcontrôleurs, toutefois, il peut arriver que vous soyez obligé d'utiliser un environnement de développement qui ne comporte pas un moniteur série intégré.  C'est le cas, par exemple, pour l'IDE Pinguino, et pour mbed (IDE en ligne utilisé pour programmer les cartes STM32 Nucleo).  Il demeure alors parfaitement possible d'afficher à l'écran de l'ordinateur des informations qui proviennent du microcontrôleur, à la condition d'utiliser un autre logiciel.

Cet autre logiciel peut être, par exemple,  TeraTerm ou PuTTY (si vous utilisez Windows) ou Moserial (si vous utilisez Linux).  Mais, si vous le désirez, vous pouvez tout simplement utiliser le moniteur série de l'IDE Arduino.


Exemple de sketch Pinguino, pour communication série par USB

Pour qu'un Pinguino envoie des informations à l'ordinateur par l'entremise du câble USB, on utilise la fonction "CDC.printf" (CDC pour Communications Device Class).  Cette fonction utilise la même syntaxe que la fonction "printf", bien connue des programmeurs expérimentés en langage C. Le sketch ci-dessous, par exemple, envoie 2 fois par seconde un nombre entier, l'augmentant d'une unité avant chaque transmission.  Vous pouvez installer ce sketch dans votre Pinguino, en utilisant, bien entendu, l'IDE Pinguino.

---
---

Exemple de sketch STM32 Nucleo / mbed, pour communication série par USB

Pour qu'une carte STM32 Nucleo envoie des informations à l'ordinateur par le câble USB, on utilise la fonction "pc.printf", qui utilise la syntaxe habituelle de "printf".  L'exemple ci-dessous, qui sera installé dans le Nucleo au moyen de l'IDE en ligne mbed fait la même chose que le sketch Pinguino présenté plus haut.

---
---

Exemple de sketch Arduino, pour communication série par USB

Si vous préférez envoyer sagement vos messages au moyen d'une carte Arduino (ou d'une carte msp430 Launchpad programmée au moyen d'Energia), le sketch accomplissant la même tâche aura plutôt cette allure:

---
---

Réglages de l'IDE Arduino pour recevoir et afficher les messages

Maintenant que votre carte (Pinguino, Nucleo, Launchpad ou Arduino) convenablement programmée est branchée au port USB de l'ordinateur, il ne reste plus qu'à démarrer votre environnement de programmation Arduino, et sélectionner le port série correspondant à votre carte.


Ensuite, vous affichez le moniteur série, en cliquant sur le bouton en haut à droite de la fenêtre.


Vous vous assurez que la vitesse de transmission des données est à 9600 baud.


Si tout va bien, le moniteur série affichera les messages qui proviennent de la carte, sans discrimination, qu'il s'agisse ou non d'une carte Arduino.


Il va sans dire que tous les exemples de sketches de cet article demeurent identiques si vous choisissez de recevoir les messages sur un autre logiciel de communication série.


Yves Pelletier (Twitter:  @ElectroAmateur)

samedi 1 novembre 2014

STM32 Nucleo et afficheur LCD

Il y a quelques mois, je vous avais parlé de la carte STM32 Nucleo et de sa programmation au moyen du compilateur en ligne mbed.   Aujourd'hui, je vous propose la suite:  ce petit tutoriel concernant le contrôle d'un afficheur à cristaux liquides (LCD).



Matériel

Vous aurez besoin:

  • d'une carte STM32 Nucleo (j'ai utilisé le modèle bas de gamme F030R8)
  • d'un afficheur LCD 2 X 16 (2 lignes de 16 caractères) muni d'un driver de type Hitachi HD44780.  Si vous avez un modèle conçu pour fonctionner sous une tension de 3,3 V, c'est parfait.  Si votre modèle fonctionne sous 5 V, il y a de bonnes chance que ça fonctionne (mais ce n'est pas sûr à 100% puisque le Nucleo communique avec 3,3 V).
  • d'un ordinateur branché à internet.  J'ai fait des tests concluants avec Windows 7 et Linux Mint.


Branchements

L'afficheur LCD comporte 16 connexions situées au-dessus de la zone d'affichage.  Nous pouvons les brancher de la façon suivante:

  • Pin 1 du LCD (VSS):  Pin GND du Nucleo
  • Pin 2 du LCD (VDD):  Pin 3V3 du Nucleo si votre LCD est conçu pour fonctionner sous cette tension, ou Pin 5V du Nucleo si votre LCD est le modèle (plus répandu) qui fonctionne sous 5 V.
  • Pin 3 du LCD (VO):  branchée à un potentiomètre qui permettra d'ajuster la tension à une valeur située entre 0 et 3,3 V (ou entre 0 et 5 V), de façon à ajuster le contraste de l'affichage.
  • Pin 4 du LCD (RS):  Pin D2 du Nucleo
  • Pin 5 du LCD (RW):  Pin GND du Nucleo
  • Pin 6 du LCD (E):  Pin D3 du Nucleo
  • Pins 7, 8, 9 et 10 du LCD (D0, D1, D2, D3):  Pas utilisées
  • Pin 11 du LCD (D4):  Pin D4 du Nucleo
  • Pin 12 du LCD (D5):  Pin D5 du Nucleo
  • Pin 13 du LCD (D6):  Pin D6 du Nucleo
  • Pin 14 du LCD (D7): Pin D7 du Nucleo
  • Pin 15 du LCD (A):  Pin 3V3 ou 5V du Nucleo, selon votre modèle de LCD (c'est pour le rétroéclairage).
  • Pin 16 du LCD (K):  Pin GND du Nucleo

Programmation dans mbed

Voyons maintenant comment construire votre programme dans mbed.  Vous vous rendez d'abourd sur le site http://developer.mbed.org, vous vous identifiez (ou vous vous inscrivez s'il s'agit de votre première visite), vous branchez votre carte STM32 Nucleo au port usb de votre ordinateur, et vous cliquez sur le bouton "compiler" en haut à droite de la fenêtre pour accéder au compilateur en ligne.


Pour créer un nouveau programme, vous cliquez le bouton "New..."/"New Program..."


...ce qui fait apparaître la fenêtre de dialogue illustrée ci-dessous.  Si votre carte est branchée au port USB, "Platform" devrait déjà montrer le bon numéro de modèle.  Vous pouvez créer votre nouveau programme au moyen d'un modèle (j'ai choisi un programme vide), et vous choisissez un nom pour votre nouveau programme (j'ai choisi "Afficheur LCD").


Ce "nouveau programme" est en fait un répertoire dans lequel nous devons maintenant ajouter un fichier.  Nous cliquons à nouveau sur le bouton "New...", mais cette fois nous sélectionnons "New File...".


Nous baptisons ce fichier "main.cpp".



Vous pouvez copier et coller le script ci-dessous à l'intérieur du fichier main.cpp:






Notre script utilise deux bibliothèques, que nous devrons importer dans notre répertoire au moyen du bouton "Import".  Vous cliquez ensuite sur l'onglet "Libraries", vous sélectionnez dans la liste les bibliothèques désirées ("mbed" et "text_LCD"), et vous cliquez sur le bouton "Import!" (Remarque:  le bouton "Import!" (avec un point d'exclamation) et le bouton "Import" (sans point d'exclamation) sont deux boutons différents...


Maintenant, votre répertoire "Afficheur_LCD" devrait contenir, en plus de votre fichier "main.cpp", la blibliothèque "mbed" et la bibliothèque "text_LCD".

Il ne vous reste plus qu'à compiler le programme (bouton "Compile") et à transférer le fichier ".bin" obtenu dans votre Nucleo.

Yves Pelletier (Twitter:  @ElectroAmateur)

dimanche 26 octobre 2014

Communication RF 433 MHz entre Raspberry Pi et Arduino

Nous avons déjà abordé la communication entre le Raspberry Pi et l'Arduino au moyen d'un câble USB, ce qui imposait une certaine proximité entre les deux cartes.

Aujourd'hui, nous nous débarrassons du câble:  l'Arduino et le Raspberry Pi s'échangeront des informations par ondes radio, à une fréquence de 433 MHz.


Matériel nécessaire

En plus du Raspberry Pi et de l'Arduino, nous utiliserons un émetteur et un récepteur 433 MHz, le modèle ultra-économique qu'on peut trouver sur eBay pour environ 1 euro.  Une antenne constituée d'un fil conducteur d'environ 17 cm vous permettra d'augmenter considérablement la portée de votre paire émetteur-récepteur.

Émetteur
Récepteur


Installation des bibliothèques 

Du côté de l'Arduino, j'ai utilisé la bibliothèque VirtualWire même si elle n'est plus mise à jour par son auteur (je ne me suis pas encore converti à RadioHead).  Donc, si ce n'est pas déjà fait, vous devriez télécharger et installer VirtualWire dans votre IDE Arduino.

Du côté du Raspberry Pi, j'ai utilisé le module Python rédigé par Joan du Forum Raspberry Pi.  Donc vous téléchargez le fichier vw.py et vous le placez dans le même répertoire que votre script Python (voir plus loin pour les scripts).  Ce n'est pas tout:  ce module requiert la bibliothèque pigpio .  Pour installer cette bibliothèque dans votre Raspberry Pi, vous tapez ces lignes de commande dans le terminal:

wget abyz.co.uk/rpi/pigpio/pigpio.zip
unzip pigpio.zip
cd PIGPIO
make
make install


Transmission de l'Arduino vers le Raspberry Pi

Branchez l'émetteur à l'Arduino de la façon suivante: 
  • Broche DATA de l'émetteur à la sortie 12 de l'Arduino
  • Broche Vcc de l'émetteur à la sortie 5 V de l'Arduino
  • Broche GND de l'émetteur à une des broches GND de l'Arduino

 Branchez le récepteur au Raspberry Pi de la façon suivante:
  • Une des broches DATA du récepteur (peu importe laquelle) à la pin GPIO 11 du Raspberry Pi.
  • Broche 5 V du récepteur à une des pins 5 V du Raspberry Pi
  • Broche GND du récepteur à une des pins GND du Raspberry Pi
Voici le sketch à installer dans l'Arduino (chaque message envoyé par l'Arduino sera numéroté, ce qui nous permet de vérifier si tous les messages envoyés sont reçus).



Et voici le script Python à installer dans le Raspberry Pi.  N'oubliez pas d'installer ce script dans le même répertoire que le fichier vw.py. 

Avant d'exécuter le script, vous devez mettre en marche le "démon pigpio" au moyen de cette ligne de commande:

sudo pigpiod

Et vous exécutez le script en tapant:

python recepteur433MHz.py






Transmission du Raspberry Pi vers l'Arduino 

 Branchez l'émetteur au Raspberry Pi de la façon suivante: 
  • Broche DATA de l'émetteur à la pin GPIO 25 du Raspberry Pi
  • Broche Vcc de l'émetteur à une des pins 5 V du Raspberry Pi
  • Broche GND de l'émetteur à une des pins GND du Raspberry Pi

 Branchez le récepteur à l'Arduino de la façon suivante:
  • Une des broches DATA du récepteur (peu importe laquelle) à l'entrée 11 de l'Arduino.
  • Broche 5 V du récepteur à la sortie 5 V de l'Arduino 
  • Broche GND du récepteur à une des pins GND de l'Arduino

Voici le sketch à installer dans l'Arduino (n'oubliez pas d'afficher le moniteur série, où les résultats reçus seront affichés):



Et voici le script Python à installer dans le Raspberry Pi (n'oubliez pas d'installer ce script dans le même répertoire que le fichier vw.py). 

Avant d'exécuter le script, vous devez mettre en marche le "démon pigpio" au moyen de cette ligne de commande:

sudo pigpiod

Et vous exécutez le script en tapant:

python emetteur433Mhz.py





C'est quand même pas mal, ne trouvez-vous pas?   Je ne dispose malheureusement pas d'un deuxième Raspberry Pi pour faire des tests, mais les deux scripts en Python pourraient certainement être utilisés pour permettre à deux Raspberry Pi de communiquer entre eux.

Si vous préférez une communication 433 MHz entre deux Arduinos, référez-vous à cet article.  Et j'ai tout plein d'articles sur le Raspberry Pi qui vous plairont peut-être.

Yves Pelletier (Twitter:  @ElectroAmateur)

Related Posts Plugin for WordPress, Blogger...