dimanche 16 septembre 2018

Livre: Raspberry Pi et ESP8266

Raspberry Pi et ESP8266
Domotisez votre habitation
par Kevin Sartor
Éditions ENI, collection La Fabrique
256 pages
2018

Voici un livre dont le public cible est parfaitement défini: les bricoleurs qui souhaitent être guidés dans la réalisation d'un système domotique résidentiel constitué d'un Raspberry Pi communiquant par Wi-Fi avec un certain nombre de capteurs et d'actionneurs branchés à des modules ESP8266.

L'objectif: améliorer le confort du domicile tout en diminuant le gaspillage d'énergie,  grâce à un système réalisé soi-même à faible coût.

Vous y trouverez de précieux conseils qui vous permettront, par exemple, de surveiller votre consommation d'électricité, d'eau et de gaz, d'automatiser la ventilation d'une pièce en fonction de son degré d'humidité, de réaliser votre propre thermostat connecté, d'arroser automatiquement votre gazon (mais uniquement lorsqu'il en a besoin), d'être alerté par email lorsque vous avez oublié d'éteindre une lampe, etc.

Pour en arriver là, on vous présente:

  • Une introduction à la domotique: son historique, ses possibilités...
  • Un tour d'horizon des principaux compteurs domestiques (eau, gaz, électricité), et des capteurs et actionneurs qui peuvent être pertinents dans votre installation domotique (interrupteur à lame souple, photorésistance, capteur de température, de pression, d'humidité, détecteurs de présence, relais, moteurs, bipeurs, etc.)
  • La marche à suivre pour installer l'IDE Arduino et le configurer pour programmer un module NodeMCU (la carte de développement qui comporte un ESP8266).  
  • La marche à suivre pour configurer le Raspberry Pi 3 et y installer le logiciel Domoticz.
  • Des exemples de projets spécifiques incluant, bien entendu des schémas de circuit (Fritzing) et des sketches complets et correctement commentés.
Bien que ces projets présentent un certain niveau de complexité (on dépasse nettement le simple clignotement d'une LED...) il me semble que les informations sont suffisamment détaillées pour qu'un néophyte puisse se débrouiller sans disposer d'une très grande quantité de connaissances préalables en électronique ou en programmation.

Yves Pelletier   (TwitterFacebook)

samedi 8 septembre 2018

Servomoteur contrôlé par Wi-Fi (ESP8266)

Il fallait s'y attendre: après avoir contrôlé un moteur à courant continu et un moteur pas à pas, je vous explique aujourd'hui comment j'ai procédé pour contrôler un servomoteur par Wi-Fi, à partir d'une page web.

Matériel

Nous utiliserons un petit servomoteur de type Tower Pro SG90 et un module ESP8266. Sur la photographie ci-contre, vous pouvez constater qu'en fait j'ai utilisé une carte de développement Wemos D1 (dont je vous parlerai probablement avec enthousiasme dans un futur billet) mais puisque le servomoteur n'occupera qu'une seule sortie de l'ESP8266, n'importe quel module ESP8266 devrait convenir (même le modeste ESP-01).

Préparation de l'IDE Arduino

Dans l'hypothèse où il s'agirait de votre première occasion de programmer un module ESP8266 avec l'IDE Arduino, je vous réfère à un précédent billet qui vous fournit les instructions nécessaires à l'installation des fichiers requis.

Circuit

Comme d'habitude, 3 broches de votre module ESP8266 sont connectées à 3,3 V: VCC, RST et CH_PD (aussi appelée "EN" sur certains modules), et deux broches sont connectées à la masse: GND et GPIO0.

La broche RXD de l'ESP8266 est reliée à la broche TX du convertisseur USB-TTL, et la broche TXD de l'ESP8266 est reliée à la broche RX du convertisseur USB-TTL.

Il n'est évidemment pas nécessaire que la sortie utilisée pour le contrôle du servomoteur soit GPIO 04, puisque toutes les sorties de l'ESP8266 peuvent produire un signal PWM.

Sketch

Le sketch utilise la bibliothèque servo, qui est pré-installée par défaut dans l'IDE Arduino.  La fonction "construitPage()" retourne une chaîne de caractères contenant la totalité de la page web, en langage html.  Cette page comporte 3 boutons radio qui permettent à l'utilisateur de sélectionner 3 positions différentes du servomoteur.

Avant d'utiliser le sketch, vous devrez remplacer les astérisques par le nom de votre réseau Wi-Fi et le mot de passe qui permet d'y accéder.



Résultat

Il est utile d'afficher le moniteur série lors du démarrage du sketch, car vous y trouverez l'adresse IP du module ESP8266.



Il s'agit de coller cette adresse dans un navigateur web ayant accès à votre réseau Wi-Fi pour afficher la page web qui permet de contrôler le servomoteur.

Pour un contrôle plus fin de la position du servomoteur, vous pouvez bien sûr ajouter des boutons supplémentaires, ou encore les remplacer par un champ texte dans lequel l'utilisateur entrera directement l'angle désiré en degrés.

Yves Pelletier   (TwitterFacebook)

dimanche 2 septembre 2018

Livre: Arduino, Apprivoisez l'élecronique et le codage



Arduino: Apprivoisez l'électronique et le codage
par Jean-Christophe Quetin
Éditions ENI (Collection La Fabrique), 2018
428 pages

Il est difficile de ne pas s'enthousiasmer devant la jeune collection "La Fabrique" des Éditions ENI, qui comporte déjà quelques bons ouvrages sur l'Arduino.  Certains sont très spécialisés (je pense entre autres à Arduino: Faites-le jouer au train, à paraître en octobre) ou s'adressent à un public déjà expérimenté (Arduino: S'exercer au prototypage électronique de Cédric Doutriaux).

"Arduino: Apprivoisez l'électronique" par Jean-Christophe Quetin entrerait plutôt dans la catégorie "manuel général à l'usage du débutant".  Le genre de livre que vous achetez au moment où vous souhaitez vous initier à l'Arduino, et auquel vous continuerez de vous référer à mesure que vous progresserez dans le domaine.

Je le recommande aux débutants, puisqu'il ne présuppose pas de connaissances préalables en électronique ou en programmation.  Si vous ne savez pas faire la différence entre une LED et un condensateur, ça vous sera expliqué.  Vous n'avez pas la moindre idée de ce que signifie l'expression "digitalWrite(LEDROUGE, HIGH);"?  On va vous l'expliquer aussi.  Environ la moitié du livre est consacrée aux concepts de base et à des projets simples impliquant essentiellement des LEDs, des boutons et des potentiomètres.  De plus, tout le langage Arduino est résumé de façon bien ordonnée dans le dernier chapitre.

La deuxième moitié du livre est consacrée à des capteurs et actionneurs plus spécialisés, mais très largement utilisés: photorésistance, capteur de température, télémètre à ultrasons, moteurs, afficheurs, cartes SD, etc.  Les différentes façons d'établir une communication entre deux cartes Arduino sont regroupées dans un même chapitre: I2C, liaison série, bluetooth, radio 433 MHz, infrarouge, ethernet, Wi-Fi (mais rien sur le populaire NRF24L01, toutefois).  On vous présente aussi quelques alternatives au classique Arduino Uno, comme l'ESP8266, l'ATTiny85 ou la fabrication de votre propre clone d'Arduino Uno.

Bref, de quoi vous occuper pendant plusieurs mois, jusqu'à ce que vous ne soyez plus du tout débutant.

Vous me ferez peut-être remarquer (avec raison) que des livres pour s'initier à l'Arduino, il y en a déjà bien d'autre.  Alors celui-ci, qu'est-ce qu'il a de particulier?
  • L'approche pédagogique est efficace et élégante.  Le lecteur acquiert progressivement de nouvelles connaissances en réalisant une suite de mini-projets concrets ordonnés de façon logique.  Chaque nouveau projet est une occasion d'apprendre un nouvel élément. Par exemple, les conditions (if, switch...case) et les différents types de boucles (while, do...while, for...) sont présentées au moment où elles se révèlent utiles dans un projet qui consiste à varier la luminosité d'une LED par PWM;  les tableaux (arrays) sont expliqués au moment de jouer une mélodie avec la fonction tone;  les registres à décalage sont présentés au moment de piloter un afficheur à 7 segments.  En ce qui me concerne, ce mode d'apprentissage est optimal.
  • Il va droit au but.  Vous y trouverez les informations nécessaires pour faire fonctionner les montages courants (incluant un schéma Fritzing et un exemple de code), mais les digressions non-essentielles sont rares. Avantage ou inconvénient?  Ça dépend du lecteur.  Je suppose que certaines personnes pourraient regretter l'absence de certaines informations complémentaires.
  • Les projets présentés sont très classiques: simulation de feux de circulation, jeu Simon (mémorisation musicale)...ce sont des applications éducatives déjà bien éprouvées qu'on retrouve dans d'autres livres et, bien sûr, sur de nombreux sites internet.  Au départ, je croyais que le "piano banane" était une création de l'auteur, mais non: Google m'a prouvé qu'il s'agit d'un projet bien connu déjà réalisé par des tas de gens.  L'auteur n'a pas tenté d'être original à tout prix en proposant un "piano raisin" ou des feux pour piétons contrôlables par une banane, si vous voyez ce que je veux dire.  Pour cette raison, j'hésiterais à conseiller ce livre à quelqu'un qui possède déjà d'autres livres sur l'Arduino.  (Seule exception notable:  11 pages sont consacrées à la Kitco, petite console de jeu dont je ne me souviens pas avoir entendu parler auparavant, et qui se voit ici accorder autant d'importance que l'ATTiny85,  l'ESP8266 ou le Leonardo.)
  • Le style de codage est uniforme tout le long du livre: les commentaires ainsi que les noms des variables et des routines sont en français; le nom des constantes est en majuscule et le noms des variables est en minuscules, etc. 
  • Comme les autres livres de la même collection, il a été écrit en français par un auteur francophone. En pratique, ça n'ajoute peut-être rien à la qualité intrinsèque de l'ouvrage, mais ça me semble quand même plus sympa que la traduction d'un livre précédemment publié dans une langue étrangère.
Pour terminer, je souligne quelques imperfections mineures:
  • J'ai remarqué à plus d'un endroit l'utilisation de l'expression "un courant de 5 V". Hérésie!!! (C'est bien sûr la tension qui est de 5 V.  Le courant, lui, se mesure en ampères.)
  • Je doute fortement que quelqu'un qui ne sait pas déjà comment piloter un moteur pas à pas avec une carte Arduino puisse apprendre à le faire en lisant les quelques lignes qui sont consacrées à ce sujet...il n'y a ni schéma de montage, ni indication sur la façon de brancher le moteur. C'est d'autant plus troublant que, dans les pages précédentes, le moteur à courant continu et le servomoteur sont couverts adéquatement.
  • Dans la version imprimée, les schémas Fritzing ne sont pas en couleur, ce qui complique parfois l'interprétation des schémas les plus complexes.
Si vous le désirez, vous pouvez feuilleter le livre sur le site web de la maison d'édition.

Yves Pelletier   (TwitterFacebook)

dimanche 26 août 2018

Moteur pas à pas contrôlé par WiFi (ESP8266)

Il y a quelques semaines, nous nous sommes amusés à contrôler un moteur à courant continu par WiFi grâce à un module ESP8266.

L'expérience d'aujourd'hui est dans le même ordre d'idées, sauf  que nous contrôlerons cette fois-ci un moteur pas à pas.

Une page web nous permettra de choisir le nombre de pas effectués par le moteur, la direction de sa rotation (horaire ou antihoraire) ainsi que le temps écoulé entre deux pas consécutifs (ce qui influencera évidemment la vitesse de rotation du moteur).

Matériel nécessaire

Un moteur pas à pas (j'ai utilisé un moteur bipolaire provenant d'une vieille imprimante), un module ESP8266 comportant un grand nombre de broches GPIO (j'ai utilisé le modèle ESP-12), un double pont en H (j'ai utilisé un module L298N), un convertisseur USB-TTL pour programmer votre ESP8266 (à moins que votre ESP8266 ne se trouve déjà sur une carte de développement complète), et un accès à un réseau WiFi.

Préparation de l'IDE Arduino

L'IDE Arduino ne dispose pas par défaut des fichiers nécessaires pour programmer un module ESP8266: si ce n'est pas déjà fait, il faut d'abord les installer.

Le circuit

Sans trop de surprise, le circuit est très similaire à celui que nous avions utilisé pour le contrôle d'un moteur électrique conventionnel, sauf que le moteur pas à pas accapare toutes les sorties du module L298N (cliquez sur le schéma pour l'agrandir).


L'ESP8266 nécessite une alimentation de 3,3 V, ce qui est trop faible pour la plupart des moteurs pas à pas, d'où les deux alimentations distinctes.

  • 3 broches de l'ESP8266 sont connectées à 3,3 V:  VCC, RST et CH_PD (aussi appelée "EN" sur certains modèles).
  • 2 broches de l'ESP8266 sont connectées à la masse:  GND et GPIO0.
  • La broche RXD de l'ESP8266 est reliée à la broche TX du convertisseur USB-TTL, et la broche TXD de l'ESP8266 est reliée à la broche RX du convertisseur USB-TTL.
  • Les broches GPIO4, GPIO5, GPIO14 et GPIO16 de l'ESP8266 sont branchées à IN1, IN2, IN3 et IN4 du module 298N, puisqu'elles sont responsables de contrôler le moteur.
  • Toutes les masses sont reliées ensemble (GND de l'ESP8266, du convertisseur USB-TTL et du module L298N).
Avant de procéder au téléchargement du sketch, branchez la broche RST à la masse pendant quelques secondes, avant de la rebrancher à 3,3 V.


Le sketch

La fonction "construitPage()" retourne une chaîne de caractères contenant la totalité de la page web, en langage html.  Cette page web contient un champ qui permettra à l'utilisateur de déterminer de combien de pas il veut faire tourner le moteur, une paire de boutons radio permettant de choisir le sens de rotation, un champ permettant de choisir le délai en millisecondes entre deux pas consécutifs, et finalement un bouton "appliquer" qu'on clique pour que les nouveaux paramètres soient pris en compte par le microcontrôleur.

La fonction "gestionPage()" est appelée lors d'un clic sur le bouton "Appliquer".  Elle met à jour quelques variables globales en fonction des choix faits par l'utilisateur de la page web, et indique les paramètres choisis dans le moniteur série (ce qui sera surtout utile pour le débogage).

prochainStep() et gestionMoteur() sont responsable de faire tourner le moteur avec les paramètres spécifiés (j'ai choisi de ne pas utiliser la bibliothèque Stepper).


Le résultat

Au démarrage du programme, l'adresse de la page web construite par l'ESP8266 est affichée dans le moniteur série.  Il suffit de coller cette adresse dans un navigateur web pour accéder à la page.


La page web vous permet de choisir le nombre de pas de la prochaine rotation du moteur, le sens de cette rotation, et le délai en millisecondes entre chaque pas.  Le moteur devrait se mettre à tourner lorsque vous cliquez sur le bouton "Appliquer".


Yves Pelletier   (TwitterFacebook)

vendredi 10 août 2018

Moteur électrique contrôlé par WiFi (ESP8266)

Ça faisait une éternité que je ne m'étais pas amusé avec mon ESP8266, le petit microcontrôleur très économique spécialement conçu pour le WiFi. Aujourd'hui, je vais lui connecter un petit moteur à courant continu, qui pourra être contrôlé à distance à partir d'une page web.

Matériel

Nous utiliserons une version de l'ESP8266 qui comporte un nombre suffisant de sorties, un circuit intégré de type "pont en H" (L298, L293D ou autre) pour piloter le moteur, et un petit moteur électrique à courant continu.  Bien entendu, vous devez avoir accès à un réseau WiFi.

Pour ma part, lors du développement de ce projet, j'ai utilisé le module ESP-12, un module L298N et un moteur muni d'une boîte d'engrenages.  Un convertisseur USB-TTL fonctionnant à un niveau logique de 3,3 V a aussi été nécessaire pour la programmation de l'ESP8266,

Préparation de l'IDE Arduino

S'il s'agit de votre premier projet impliquant la programmation de l'ESP8266 avec l'IDE Arduino, assurez-vous d'installer les extensions nécessaires dans votre copie de l'IDE.

Circuit

Voici le schéma complet du circuit qui permet à la fois de programmer l'ESP8266 et d'utiliser le circuit de contrôle du moteur (cliquez sur le schéma pour l'agrandir).

L'ESP8266 exige une alimentation de 3,3 V, alors que le module L298 fonctionne avec au moins 5 V, d'où les deux alimentations distinctes.  De plus, l'ESP8266 est assez capricieux en matière d'alimentation: si cette dernière n'est pas impeccablement stable, il risque d'avoir un comportement imprévisible (c'est une bonne idée de placer un condensateur entre les deux bornes de la source de tension).

  • 3 broches de l'ESP8266 sont connectées à 3,3 V:  VCC, RST et CH_PD (aussi appelée "EN" sur certains modèles).
  • 2 broches de l'ESP8266 sont connectées à la masse:  GND et GPIO0.
  • La broche RXD de l'ESP8266 est reliée à la broche TX du convertisseur USB-TTL, et la broche TXD de l'ESP8266 est reliée à la broche RX du convertisseur USB-TTL.
  • Les broches GPIO4 et GPIO5 de l'ESP8266 sont branchées à IN1 et IN2 du module 298N, puisqu'elles sont responsables de contrôler le moteur.
  • Toutes les masses sont reliées ensemble (GND de l'ESP8266, du convertisseur USB-TTL et du module L298N).

Ne pas oublier de brancher la broche RST à la masse pendant quelques secondes juste avant de faire le téléchargement du sketch.

Sketch

Les bibliothèques pour l'ESP8266 font l'essentiel du travail pour nous.  Essentiellement, le sketch construit une page web comportant 3 boutons radio permettant de sélectionner la vitesse du moteur (arrêt, lent et rapide), et 3 boutons radio permettant de sélectionner le sens de rotation (horaire ou antihoraire), et contrôle le moteur en fonction des paramètres de la page web lorsque l'utilisateur clique sur le bouton "Appliquer".

Le moteur se contrôle de la façon habituelle: il tourne dans un sens lorsque la broche GPIO4 est à l'état logique haut pendant que la broche GPIO5 est à l'état logique bas, et dans l'autre sens si c'est le contraire.  La vitesse du moteur se règle grâce à un signal PWM (notez que pour l'ESP8266, la valeur maximale est de 1023 pour le PWM).

Évidemment, pour que ça fonctionne, vous devez mettre le nom de votre réseau Wifi ainsi que le mot de passe dans les variables "ssid" et "password" avant de le transférer dans l'ESP8266.

Résultats

Lors du démarrage de l'ESP8266, ouvrez le moniteur série de l'IDE Arduino afin de connaître l'adresse IP qui lui a été assignée.


Vous entrez ensuite cette adresse IP dans le navigateur web de n'importe quel appareil branché au même réseau local.


Une page web apparaît, présentant 3 boutons radio pour le réglage de la vitesse du moteur (arrêt, lent, rapide) et deux boutons pour le sens de rotation du moteur (horaire et antihoraire).  Le moteur devrait tourner selon vos spécifications lorsque vous cliquez sur le bouton "Appliquer".

Yves Pelletier   (TwitterFacebook)

mardi 7 août 2018

Livre: Arduino, le guide complet, par J. M. Hugues

Arduino, le guide complet
par J.M. Hugues
Éditions First
628 pages
Publié en 2018

J'aimerais bien qu'on m'explique comment un livre intitulé "Arduino, a technical reference" peut s'affubler en français d'un  titre aussi pompeux et trompeur que "Arduino, le guide complet".  Bien que ce livre présente certaines qualités, il est très, très loin d'être complet.

Dans son introduction, l'auteur indique lui-même que le livre s'adresse à ceux "qui ont exploité le plus possible les livres d'initiation et les guides pratiques de création de projets".  J'en déduis que l'auteur n'a jamais eu la prétention d'avoir écrit un guide complet!

Je qualifierais plutôt ce livre de "référence complémentaire", car l'auteur choisit souvent d'insister sur des aspects qui ne sont pas abordés dans les autres livres portant sur l'Arduino.  L'aspect positif de ce choix, c'est que ça rend ce livre pertinent si vous avez déjà lu quelques livres sur l'Arduino.  Par contre, le choix des sujets traités semble parfois arbitraire, et j'ai vraiment eu l'impression de lire 3 ou 4 livres différents rassemblés dans un même volume.

La première partie (chapitres 2 à 6), beaucoup plus aride que ludique, pourrait s'intituler "Ce que vous n'avez pas vraiment besoin de savoir pour programmer l'Arduino". On y présente, par exemple,  les caractéristiques techniques des microcontrôleurs AVR, quelques éléments de langage assembleur, comment programmer l'Arduino en utilisant autre chose que l'IDE Arduino (que le traducteur appelle "l'atelier Arduino").  Bref, le genre de connaissances qui étaient peut-être nécessaires pour programmer un microcontrôleur AVR lorsqu'Arduino n'existait pas, mais qui ne le sont plus maintenant qu'Arduino existe.

Le chapitre 7 présente en détail les bibliothèques fournies avec l'IDE Arduino, en énumérant les classes et méthodes de chacune de ces bibliothèques. Il s'agit à mon avis d'une initiative intéressante, car je ne me souviens pas avoir vu ce genre de référence dans d'autres livres.  Mais puisqu'il s'agit, selon le titre, du guide complet sur l'Arduino, on peut s'étonner qu'il n'y ait nulle part une liste des fonctions régulières du langage Arduino (domme digitalWrite(), delay(), etc.). Je mentionnerais aussi que certaines des bibliothèques qui ne sont pas fournies avec l'IDE Arduino (et qui ne sont donc pas présentées dans le livre) sont beaucoup plus utilisées que des bibliothèques ultra spécialisées comme Esplora...

Les chapitres 8 et 9 empruntent un style radicalement différent de tous ceux qui ont précédé: ça devient un genre de catalogue qui énumère une très grande quantité de boucliers (shields) et capteurs pouvant être branchés à une carte Arduino. Ça peut permettre au débutant d'avoir une idée de ce qui existe sur le marché.  Toutefois, les descriptions sont extrêmement brèves, et sont totalement insuffisantes pour permettre d'utiliser ces produits lorsque vous en avez fait l'acquisition.

Pourtant, dans son introduction, l'auteur déclarait "En tant qu'ingénieur, je suis souvent déçu d'acheter quelque chose d'intéressant, pour devoir constater qu'il n'y a aucune documentation. Cela m'oblige à me lancer dans une longue quête afin de trouver un peu de documentation sur Internet, et dans une langue que je peux comprendre (donc par exemple pas en chinois)."  À mon avis, ces chapitres ne font absolument rien pour régler ce problème!  On trouve bien quelques schémas de circuit ici et là, mais la grande majorité des descriptions vous fournissent moins d'informations qu'une annonce typique sur eBay.

Finalement, les derniers chapitre du livre adoptent un autre style différent: il s'agit maintenant de présenter, de façon détaillée, 4 projets spécifiques: le Greenshield (un système de surveillance et de contrôle pour l'horticulture), le Switchinator (14 sorties programmables), un générateur de signal et un thermostat intelligent. Il s'agit de projets assez ambitieux, incluant la conception de circuits imprimés au moyen des logiciels Eagle et Fritzing.  C'est la partie du livre qui m'a semblé la mieux réussie.

Bien qu'on mentionne à quelques reprise que les fichiers de code source sont disponible "sur le site de l'éditeur ainsi que sur GitHub", l'url n'est fourni nulle part dans le livre.  Voici un lien direct.

Je termine par une courte liste d'erreurs ou de négligences qui me semblent un peu embarrassantes:

Page 340, dans un paragraphe consacré aux photorésistances: "Ils réagissent bien moins vite que les composants basés sur une diode ou un transistor, mais cela suffit à créer par exemple un jeu de lumière piloté par de la musique".  (Détecter de la musique au moyen d'une photorésistance me semble une véritable prouesse technique.)

Page 353, dans une brève explication du principe de fonctionnement d'un télémètre à ultrasons: "Il suffit de diviser par deux le délai entre l'émission et la réception pour connaître la distance. Cette mesure est possible parce que la fréquence des ultrasons est bien inférieure à celle de la lumière. Il n'est donc pas difficile de distinguer les deux moments, si le programme va suffisamment vite."  (La mesure du délai est possible parce que la vitesse des ultrasons est beaucoup plus faible que celle de la lumière, peu importe leur fréquence.)

Page 270, au sujet de la fabrication de nos propres shields pour Arduino: "Vous pouvez faire le vôtre avec une plaque à pastilles et les connecteurs appropriés que vous trouverez chez tous les fournisseurs. Je rappelle que les connecteurs des cartes Arduino sont à la norme industrielle de 2,54 mm d'espacement (un dixième de pouce). Tous les électroniciens possèdent ce genre de connecteurs dans leur stock de base".  (Cette distance de 2,54 mm  n'est pas respectée entre les broches 7 et 8, ce qui complique considérablement l'utilisation d'une plaque à pastilles conventionnelle).

En résumé: un livre sans véritable fil conducteur, pas du tout conseillé aux débutants et, contrairement à ce que prétend le titre, pas du tout complet!

Yves Pelletier   (TwitterFacebook)

jeudi 19 juillet 2018

Bluetooth et MPLAB Xpress Evaluation Board

Voici un petit tutoriel qui pourrait vous être utile si vous désirez envoyer ou recevoir de l'information par bluetooth avec une carte MPLAB Xpress Evaluation Board (ou un autre microcontrôleur PIC).

Pour ce faire, nous utiliserons un module bluetooth HC-06 et, bien entendu, un appareil pouvant converser en bluetooth (télépĥone, tablette...).

Avant d'aller plus loin, je vous mentionne tout de suite que si vous désirez plutôt communiquer en bluetooth avec un Raspberry Pi, un Arduino, un MSP430 Launchpad ou un STM32 Nucleo, vous trouverez sur ce blog des tutos spécialement conçus pour votre plateforme de développement préférée!  Si vous voulez programmer vous-même l'application android qui conversera avec votre carte, c'est déjà couvert aussi.

Connexions

Nous allons régler la carte MPLAB Xpress Evaluation Board afin qu'elle émette un signal UART par sa broche RB1, et qu'elle le reçoive sur sa broche RB0.  Par conséquent, les quatre connexions sont:
  • RXD du module HC-06 ----- RB1 de la carte MPLAB Xpress
  • TXD du module HC-06 ----- RB0 de la carte MPLAB Xpress
  • GND du module HC-06 ----- GND de la carte MPLAB Xpress
  • VCC du module HC-06 ----- 5 V de la carte MPLAB Xpress
(Je crois que certains modules HC-06 sont conçus pour une alimentation de 3,3 V.  Le mien indique clairement "Power 3.6 V - 6 V" même si le niveau logique est de 3.3 V.)




Exemple 1: transmission d'information (carte MPLAB Xpress vers téléphone)

Dans ce premier exemple, la carte MPLAB Xpress va émettre par bluetooth une série de messages qui pourront être captés par un téléphone ou une tablette.

Configuration dans MCC

Après avoir créé un nouveau projet dans l'IDE en ligne MPLAB Xpress, nous ouvrons le logiciel MPLAB Xpress Code Configurateur, afin d'effectuer quelques réglages.

Nous devons d'abord ajouter un module "EUSART" à notre projet.  Pour ce faire, nous cliquons deux fois sur "EUSART" dans la liste "Device Resources"...


On coche les cases "Enable Transmit" et "Redirect STDIO to EUSART". Si votre module HC-06 est réglé à une vitesse autre que 9600 bauds, vous en profitez pour modifier ce paramètre aussi.



On clique ensuite sur les petits cadenas correspondant au port B0 pour EUSART RX, et au port B1 pour EUSART TX.


Ne pas oublier de cliquer sur le bouton "Generate" afin que ces réglages soient transmis à MPLAB Xpress.

Script

Le script ci-dessous (à insérer dans le fichier main.c de votre projet), permet d'émettre un message par bluetooth chaque seconde.



Couplage avec un appareil hôte

S'il s'agit de la première utilisation de ce module HC-06 avec le deuxième appareil (smartphone, tablette, ordinateur) il faut coupler les deux dispositifs.  Voici la procédure pour l'appairage avec un appareil android (c'est similaire si vous utilisez autre chose qu'un appareil android).

Dans Paramètres, Bluetooth, assurez-vous d'abord que Bluetooth est activé.  S'il est alimenté, le module HC-06 devrait figurer dans la liste des appareils disponibles.



Cliquez sur le nom du module. Le mot de passe par défaut est généralement "1234" (si ce mot de passe ne vous plaît pas, il est possible de le modifier).


Si tout se passe bien, le HC-06 apparaît ensuite dans la liste des périphériques couplés.



À cette étape, la LED rouge du module HC-06 continue de clignoter.  Ce n'est que lorsque la connexion sera établie avec une application de l'appareil android qu'elle demeurera allumée de façon continue.

Appli bluetooth

Il existe tout plein d'applications android permettant la communication bluetooth.  Pour effectuer mes tests, j'ai utilisé Serial Bluetooth Terminal par Kai Morich.

Après avoir démarré Serial Bluetooth Terminal, il est important d'établir la communication bluetooth avec le Nucleo en cliquant sur le bouton illustré ci-dessous:


Lorsque la communication est établie, le bouton change de forme, et la LED rouge du module HC-06 cesse de clignoter.

Résultats

Les messages émis de façon répétitive par la carte MPLAB Xpress s'affichent à l'écran de la tablette.



Exemple 2: réception d'information (téléphone vers carte MPLAB Xpress)

Dans ce deuxième exemple, nous contrôlerons les 4 LEDs intégrées à la carte MPLAB Xpress par bluetooth, à partir d'un téléphone ou d'une tablette.

Configuration dans MCC

Il s'agit des mêmes réglages que pour le premier exemple, sauf qu'il n'est pas nécessaire de cocher la case "Enable Transmit". De plus, dans la zone des cadenas, il est important de définir les ports A0, A1, A2 et A3 comme des sorties:  "GPIO output" (elles sont reliées aux  LEDs de la carte).


Script

On peut ensuite utiliser le script ci-dessous (à coller dans le fichier main.c).  Si on reçoit par bluetooth le message "a", on allume la première LED. Si on reçoit le message "b", on allume la deuxième, etc.



Résultats

La zone située dans le bas de l'écran de l'appli Serial Bluetooth Terminal permet d'envoyer un message. Si vous écrivez la lettre a, puis cliquez sur le bouton de droite, la première LED de la carte MPLAB Xpress Evaluation Board s'allume.


Yves Pelletier   (TwitterFacebook)

lundi 16 juillet 2018

Contrôle d'un servomoteur avec MPLAB Xpress Evaluation Board


Je continue ma série de tutoriels concernant la programmation de la carte MPLAB Xpress Evaluation Board de Microchip, tout en vous rappelant que ces tutos sont facilement utilisables avec d'autres microcontrôleurs PIC.  Au programme aujourd'hui: le contrôle d'un servomoteur.



Servomoteur et PWM

Pour contrôler la position angulaire d'un servomoteur, vous devez le soumettre à un signal modulé en largeur d'impulsion (PWM) dont la fréquence est typiquement de 50 Hz (période de 20 ms). Le servomoteur occupe la position centrale pour une impulsion d'une durée d'environ 1,5 ms, alors que les deux positions extrêmes sont atteintes pour une impulsion de 1 ms (dans une direction) ou 2 ms (dans l'autre direction).

Ceci étant dit, il semble bien établi qu'il n'est pas obligatoire que la fréquence du signal soit de 50 Hz: la plupart des servomoteurs fonctionnent très bien pour une plage de fréquences assez large. De plus, les valeurs de 1 ms et 2 ms ne sont qu'approximatives et varient d'un servomoteur à l'autre.

Pour ce tuto, je vais malgré tout respecter la fréquence de 50 Hz (période de 20 ms),  cette valeur étant confirmée dans la fiche technique du servomoteur que j'ai utilisé, soit le modèle Tower Pro SG90.

Circuit

Le circuit est donc constitué de la carte MPLAB XPress Evaluation Board et d'un petit servomoteur branché à sa propre alimentation continue de 5 V.  Ce servomoteur sera contrôlé par la sortie RA0 (vous pouvez évidemment choisir une autre sortie de la carte et en tenir compte dans les réglages décrits plus loin dans ce billet).



Remarquez qu'un servomoteur de faible puissance peut très bien être alimenté par la sortie 5 V de votre carte; l'alimentation externe devient nécessaire si vous avez plusieurs servomoteurs sur la même carte, ou si vous utilisez un servomoteur plus gourmand en puissance.

Réglages dans MPLAB Xpress Code Configurator

Après avoir créé un nouveau projet vierge dans MPLAB Xpress, nous ouvrons MPLAB Xpress Code Configurator (si vous n'êtes pas familier avec ces outils, ce serait une bonne idée de consulter d'abord ce billet).

Je crois n'avoir rien changé concernant l'oscillateur, dans la fenêtre "System Module", mais je partage quand même son contenu, au cas où il ne s'agirait pas des valeurs par défaut.


Lorsqu'on veut utiliser un module PWM, il faut obligatoirement l'associer à un timer (2, 4 ou 6). Dans la fenêtre "Device Resources", nous cliquons deux fois sur TMR4.


Nous avons quelques modification à apporter dans les paramètres du timer numéro 4:

  • Assurez-vous que "Enable Timer" est bien coché (il devrait déjà l'être par défaut).
  • "Clock Source" doit être réglé à FOSC/4.  
  • "Prescaler" doit être réglé à 1:32 (afin qu'une période de 20 ms soit possible)
  • Vous remplacez la valeur qui se trouve dans "Timer Period" par 20 ms.

Assurez-vous ensuite que "Actual Period" affiche environ 20 ms (19.928 ms pour être précis).

Ajoutons maintenant un module PWM, en cliquant deux fois sur PWM6 dans la fenêtre "Device Resources":

On associe PWM6 au Timer4 ("Select a Timer") et on s'assure que l'option "Enable PWM" est cochée.  La valeur du "Duty Cycle" peut être réglée à une valeur située entre 5% et 10%  (entre 1 ms et 2 ms, donc)


Remarquez les informations situées au bas de la fenêtre: la période PWM est bien de 20 ms, la fréquence PWM est de 50 Hz, et la résolution PWM est de 9 bits.

Il ne reste plus qu'à indiquer à quelle sortie de la carte ce signal PWM sera acheminé. J'ai choisi le port A0, puisque le servomoteur est branché à la sortie RA0.


Pour terminer avec MPLAB XPress Code Configurator, on clique sur le bouton "Generate" dans la zone "Project Resources", afin que les fichiers appropriés soit ajoutés dans notre projet MPLAB Xpress récemment créé.


Script

Voici un script qui place le servomoteur à sa position minimale, attend une seconde, le place à sa position médiane, attend une seconde, le place à la position maximale, attend une seconde...

Attention: les valeurs utilisées comme argument pour PWM6_LoadDutyValue() sont celles qui correspondent le mieux au servomoteur que j'ai utilisé pour mes tests, et il sera probablement approprié de les modifier pour utilisation avec un autre servomoteur.

Si j'ai bien compris, la valeur maximale de l'argument de PWM6_LoadDutyValue() dépend de la résolution de notre signal PWM. À la fréquence de 50 Hz, cette résolution est de 9 bits, donc la valeur maximale est de 29 = 512.

La valeur médiane devrait être atteinte pour un temps de 1,5 ms correspondant à un rapport cyclique de 7,5%, donc 38; toutefois, mon servomoteur était mieux centré avec une valeur de 50.


Vidéo

Pour terminer: un courte vidéo du résultat.



Yves Pelletier   (TwitterFacebook)

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...