Et pendant ce temps, dans un blog près de chez vous... (3)

Voici une nouvelle sélection de billets publiés dans différentes blogs au cours des dernières semaines.

RitonDuino:

• STM32 : boîtier ST-LINK
• STM32-duino : déboguer
• STM32 : environnements de développement
• Arduino, ESP8266 et ESP32 une librairie timers
• Arduino, ESP8266, ESP32 et STM32 : une librairie console / logger
• Arduino: sauvegarde de données en EEPROM en cas de coupure d'alimentation

iTechnoFrance:

• Utilisation du bus One-Wire avec le capteur de température DS18B20 en MicroPython
• Utilisation du capteur de gestes PAJ7620 en MicroPython
• Bras robotisé 5 servos SG90 piloté par un ESP32 en MicroPython
• Une interface humaine à l’aide du capteur de geste PAJ7620 en MicroPython
• Piloter le bras robotique via le capteur de gestes PAJ7620 en MicroPython
• Finalisation du bras robotique

Arduiblog:

• Débuter en MicroPython
• Les sorties du Micro:Bit
• Micro:Bit et LED RGB

Framboise314:

• J’ai testé pour vous : un Graveur Laser 3000mW
• Commencer avec l’Arduino
• Station météo simple à base d’Arduino et de Raspberry Pi

Anderson69s:

• NRF52840 BreakOut HolyIOT
• ESP12-Domo
• AirBarDuino

Programmer un Raspberry Pi avec Arduino Create

Depuis quelques mois, il est possible de contrôler les broches GPIO d'un Raspberry Pi grâce à un sketch Arduino réalisé sur l'éditeur en ligne "Arduino Create". Malgré les quelques réserves que j'entretiens à l'égard cet IDE en ligne, j'étais curieux de savoir comment ça fonctionne, et j'ai donc décidé d'en faire l'essai.

Nous supposerons que vous disposez déjà d'un compte sur Arduino Create. Si ce n'est pas le cas, vous trouverez quelques directives dans ce vieil article (qui date de l'époque où le service était encore en version beta: je suppose que la procédure d'inscription est plus simple maintenant).

Une fois dans mon compte Arduino Create, je clique sur le bouton "Device Manager":

La page "Device Manager" comporte une partie intitulée "My Linux Devices", réservée aux cartes fonctionnant sous Linux. J'ai cliqué sur le bouton bleu  "Add New Device".

On me présente alors une liste des cartes supportées. Évidemment, je clique sur "Set up a Raspberry Pi".

La page suivante m'explique qu'on va installer le plugin "Arduino Create" sur mon ordinateur (dans mon cas, c'est déjà fait), ainsi que le logiciel "Arduino Connector" sur mon Raspberry Pi.  J'ai cliqué sur le bouton "Next", au bas de la page.

On me demande ensuite de m'assurer que le Raspberry Pi est connecté sur le même réseau local que l'ordinateur que j'utilise actuellement.

On m'offre ensuite deux options pour identifier mon Raspberry Pi. J'ai choisi celle qui consiste à entrer son adresse ip.

Il faut ensuite entrer le nom d'utilisateur et le mot de passe qui permet d'ouvrir une session sur le Raspberry Pi.

Arduino Create établit une connexion avec mon Raspberry Pi, et y installe "Arduino Connector".

Je choisis ensuite un nom pour identifier mon Raspberry Pi (ce sera particulièrement utile si mon réseau en comporte plusieurs).

Mon Raspberry Pi est maintenant visible dans le "Device Manager".

En cliquant sur le bouton associé à mon Raspberry Pi, quelque chose a mal tourné. On m'a avisé que le package "NetworkManager" est absent de mon système (ma version de Raspbian n'a pourtant rien d'exotique, et elle est raisonnablement à jour). J'ai cliqué à quelques reprises sur le bouton "INSTALL", ce qui ne semble pas avoir eu le moindre effet. J'ai fini par me résigner et cliquer sur le bouton "NEVER MIND". Comme nous le verrons par la suite, ça ne semble pas avoir entraîné d'inconvénient majeur.

Je me suis ensuite dirigé vers l'Arduino Web Editor, car c'est là que les choses deviennent intéressantes: mon Raspberry Pi est figure maintenant dans la liste des cartes que je peux programmer.

Ce n'est pas le moment d'être original: je branche une LED à la broche GPIO18 du Raspberry Pi, dans l'espoir de la faire clignoter.

Il ne me reste qu'à écrire le classique sketch qui fait clignoter une LED. Une chose qu'il est important de savoir, c'est qu'on utilise le mode de numérotation "BOARD" plutôt que "BCM": la broche GPIO18 porte donc le numéro 12.

Le téléversement du sketch est un succès...

Et bien entendu, la LED se met à clignoter!

Dans la page Device Manager, lorsque je clique sur le dessin de mon Rasbperry Pi, j'accède à une console qui affiche la liste des sketches que j'y ai téléversés. Un bouton me permet de démarrer ou d'interrompre chaque sketch de la liste. Plusieurs sketches peuvent être exécutés simultanément.

On peut donc constater que je suis parvenu à contrôler une broche GPIO du Raspberry Pi grâce à un sketch Arduino tout ce qu'il y a de plus classique, en utilisant les fonctions digitalWrite() et delay(). Tout ce processus s'est déroulé à l'intérieur d'Arduino Create, sans que j'aie à ouvrir moi même une session sur le Raspberry Pi.

Cette façon de programmer le Raspberry ne conviendra pas à tout le monde, mais on peut facilement imaginer que tout ceci puisse plaire à quelqu'un qui est déjà familier avec la programmation d'un Arduino, et qui ne connaît rien à Linux.

Ça demeure un peu étrange que je sois obligé d'aller sur internet pour contrôler un Raspberry Pi qui se trouve devant moi. Une fois le sketch Arduino téléversé dans le Raspberry Pi, ce serait chouette de pouvoir l'exécuter par une commande tapée dans le terminal, sans être obligé de recourir à Arduino Create. Est-ce faisable? Pour l'instant, je n'ai malheureusement pas la réponse à cette question.

Il me reste aussi à vérifier si les principales bibliothèques de l'univers Arduino sont supportées. S'il est possible de transposer au Raspberry Pi, sans trop de modifications, un sketch Arduino relativement complexe impliquant quelques capteurs SPI ou I2C , un afficheur, etc., ça pourrait devenir vraiment intéressant.

Je prévois donc continuer à expérimenter ça encore un peu...

Lire la suite

Yves Pelletier   (Twitter, Facebook)

Livre: Réparez vous-même vos appareils électroniques (2e édition)

Réparez vous-même vos appareils électroniques
(2e Édition)
Par Jean Boyer
Publié en 2019 chez Eyrolles (Collection Serial Makers)
408 pages

Je signale la parution de la deuxième édition de cet intéressant guide de réparation, qui semble être le seul de sa catégorie actuellement disponible sur le marché.

C'est étrange, quand on y pense: dans l'esprit de la plupart des gens, quelqu'un "qui se débrouille en électronique" sera forcément en mesure de réparer un téléviseur, une chaîne hi-fi ou une console de jeux vidéo. On trouve en librairie une grande quantité de livres qui expliquent comment réaliser ses propres montages électroniques, ainsi qu'un grand nombre de manuels théoriques de niveau universitaire qui permettent de comprendre pourquoi un transistor à effet de champ se comporte comme il le fait. Cependant, quelqu'un peut maîtriser tous ces sujets et, malgré tout, être totalement désemparé face à un téléviseur qui ne fonctionne plus correctement...d'où la nécessité de ce genre de livre.

Sans surprise, cet ouvrage devrait vous convenir si vous avez souvent l'occasion de réparer un appareil défectueux: on y expose des conseils et des méthodes de diagnostic qui aident à déceler les problèmes les plus fréquents pour diverses catégories d'appareils, mais ça demeure forcément assez général. Si, une seule fois dans votre vie, vous faites face à un problème très spécifique concernant un appareil en particulier, une recherche sur internet sera probablement plus fructueuse que la lecture de ce bouquin. Dans le même ordre d'idée, quelqu'un qui désire tenter de réparer sa cafetière en panne n'éprouvera probablement pas le besoin de mettre en place un atelier de réparation bien équipé, comportant un miroir fixé au mur, tel que décrit dans les premiers chapitres.

En comparant cette deuxième édition à celle qui l'a précédée, on constate que l'ordre de présentation des chapitres a été remaniée: les 4 derniers chapitres de l'édition originale, qui portaient sur les composants électroniques (caractéristiques, contrôle, remplacement, codification et marquage) ont été fusionnés pour devenir le chapitre 3. Ça me semble une bonne idée, puisque ces connaissances préalables sont nécessaires pour espérer s'attaquer à la réparation d'un appareil complexe. Cette partie du livre a également été condensée, passant de 78 à 47 pages: je crois qu'on a laissé tomber certains éléments plus théoriques, qui n'étaient pas strictement nécessaires dans le contexte de la réparation d'un appareil défectueux.

Je remarque également l'ajout du chapitre 6, qui concerne la réparation des électroménagers, de l'outillage électroportatif, et des éclairages à LED.

Tout comme c'était le cas dans la 1ère édition, le téléviseur demeure l'appareil vedette du livre, puisque 30% des pages lui sont spécifiquement consacrées.

Chapitre 1: Sécurité et prévention (car ça peut parfois être très dangereux)
Chapitre 2: L'espace de travail du réparateur (les outils et instruments nécessaires)
Chapitre 3: Identifier, contrôler et substituer les composants
Chapitre 4: Les opérations de base (souder/dessouder, isoler un signal)
Chapitre 5: Réparer les petits appareils électroniques (télécommandes, horloges à quartz, batteries rechargeables)
Chapitre 6: Réparer l'électroménager, l'outillage électroportatif et les éclairage à LED
Chapitre 7: Réparer le matériel informatique (souris, écran, ordinateur de bureau, ordinateur portable, tablette)
Chapitre 8: Réparer les appareils multimédias (consoles de jeu, appareils photo, caméscopes, radio portatives, chaînes hi-fi. magnétoscope, vidéoprojecteurs, smartphones...)
Chapitre 9: Réparer les téléviseurs à écran LCD/LED
Chapitre 10: Réparer les téléviseurs à écran plasma
Chapitre 11: Réparer les circuits d'alimentation

Si vous désirez plus de détail, les Éditions Eyrolles mettent à votre disposition ces quelques pages du livre.

Voilà, je suis prêt! Il ne me reste plus qu'à attendre que ce fichu téléviseur tombe en panne...

Yves Pelletier   (Twitter, Facebook)

Mesure de la pression dans un liquide avec BMP180 et Arduino

J'ai déjà eu l'occasion de vous présenter le capteur de pression et de température BMP180 pour la mesure de la pression atmosphérique; je l'avais également utilisé lors de la fabrication d'une flûte à bec MIDI. Cette-fois, j'utilise le même capteur pour mesurer la pression dans un liquide, à différentes profondeurs.

Principe de fonctionnement

Évidemment, il n'est aucunement question de plonger un circuit électronique dans l'eau. C'est plutôt une extrémité d'un tube de plastique qui est plongée dans l'eau. L'autre extrémité du tube est reliée à une coquille de plastique hermétiquement fermée (sans fuite d'air) dans laquelle se trouve le capteur BMP180.

Au départ, lorsque le tube est hors de l'eau, la pression dans la coquille est égale à la pression atmosphérique ambiante. Si on plonge l'extrémité du tube dans l'eau, un peu d'eau monte dans le tube, poussée par la pression du liquide qui est plus grande que la pression atmosphérique. Cette montée de liquide dans le tube a pour effet de comprimer l'air enfermé dans la coquille, et d'augmenter sa pression, jusqu'à ce qu'un équilibre s'installe: la pression atmosphérique dans la coquille (mesurée par le BMP180) est alors égale à la pression dans le liquide (à la position de la surface du liquide dans le tube).

Circuit

Un module BMP180 (modèle GY-68) comporte quatre connecteurs: deux pour son alimentation électrique, et deux pour la communication I2C avec le microcontrôleur.

• Broche VIN du BMP180: 5 V de l'Arduino*
• Broche GND du BMP180: GND de l'Arduino
• Broche SCL du BMP180: broche A5 de l'Arduino
• Broche SDA du BMP180: broche A4 de l'Arduino

* car le module GY-68 comporte un régulateur de tension.

(ces connexions supposent l'utilisation d'un Arduino Uno).

Fabrication de la sonde

Le capteur de pression BMP180 est inséré dans une coquille rigide. J'ai utilisé une coquille en plastique de Kinder Surprise qui était inutilement grosse (ce qui a pour inconvénient de faire monter le liquide très haut dans le tube: il est donc impossible de mesurer la pression jusqu'au fond du récipient qui contient le liquide). Autant que possible, essayez de trouver un récipient rigide tout juste assez grand pour contenir le capteur.

Des trous permettent le passage du tube (à plonger dans le liquide) et des fils (pour la connexion à l'Arduino).

Il faut ensuite rendre la coquille parfaitement hermétique, pour éviter toute fuite d'air. Pour ce faire, j'ai utilisé une généreuse quantité de ruban gommé. Si le niveau de liquide dans le tube monte jusqu'au niveau de liquide dans le récipient, c'est qu'il y a une fuite d'air et il faut trouver une façon de l'éliminer­.

Sketch

Après avoir installé la bibliothèque SFE_BMP180 proposée par Sparkfun, j'ai modifié un des exemples fournis afin de n'afficher que la pression (en Pascal) dans le moniteur série.

Expérimentation et résultats

J'ai cherché à vérifier expérimentalement cette relation entre la pression dans un liquide et la profondeur:

        p = ρgh

où p est la pression relative (par rapport à la surface du liquide) en Pascal (Pa)

     ρ est la masse volumique du liquide en kg/m³ (1000 kg/m³ pour l'eau)

     g est l'accélération gravitationnelle à la surface de la terre (9,8 m/s²)

     h est la profondeur, mesurée par rapport à la surface du liquide (en mètres)

Compte tenu de notre façon de mesurer la pression, la profondeur "h" est la distance verticale entre la surface du liquide dans le récipient et la surface du liquide à l'intérieur du tube de la sonde.

Il faut également noter que le BMP180 mesure la pression absolue: la valeur mesurée est déjà d'environ 100 000 Pa à la surface du liquide (pression atmosphérique), alors que l'équation suppose une pression relative (nulle à la surface).

J'ai donc démarré le sketch présenté plus haut afin d'afficher dans le moniteur série la pression mesurée, et j'ai noté cette pression pour plusieurs profondeurs différentes, par bonds de 5 mm.

Après transcription des mesures dans un tableur (Excel ou LibreOffice Calc) et transformation de la pression absolue en pression relative (en soustrayant de chaque pression mesurée la pression atmosphérique normale), j'ai produit un graphique de la pression (en Pa) en fonction de la profondeur (en mètre).

J'ai obtenu une droite dont la pente est de 9690 Pa/m.  En divisant la pente par 9,8 m/s², on trouve une masse volumique expérimentale de 989 kg/m³ , ce qui n'est pas très loin des 1000 kg/m³ prévus.

À lire également

• Mesurer la pression atmosphérique avec BMP180 et Arduino
• Fabrication d'une flûte à bec MIDI (BMP180 et Arduino)
• Capteur de pression BMP180 et STM32 Nucleo (mbed)
• La liste des expériences scientifiques décrites dans ce blog

Yves Pelletier   (Twitter, Facebook)

Modulation par largeur d'impulsion (PWM) et STM32

N.B.: Ce billet a été mis à jour le 16 novembre 2019 afin de tenir compte des particularité du nouveau STM32 Core.

Les cartes STM32 comportent plusieurs sorties qui peuvent produire un signal modulé en largeur d'impulsion (aussi appelé PWM pour "pulse width modulation"). Ce type de signal est souvent utilisé pour contrôler la luminosité d'une LED ou la vitesse de rotation d'un moteur.

Voyons comment produire un tel signal en programmant la carte au moyen l'IDE Arduino (veuillez vous référer à cet article pour des informations de bases sur la programmation des cartes STM32 avec l'IDE Arduino).

Les broches PWM de la Blue Pill

Les 15 broches de la carte STM32F103 Blue Pill qui peuvent produire un signal PWM sont A0, A1, A2, A3, A6, A7, A8, A9, A10, B0, B1, B6, B7, B8, B9.

Les broches PWM de la carte Nucleo

Ma carte Nucleo F030R8 comporte 10 broches PWM sur ses connecteurs femelles compatibles Arduino: PA4 (A2), PB0 (A3), PB8 (D15), PB9 (D14), PA6 (D12), PA7 (D11), PB6 (D10), PC7 (D9), PB4 (D5) et PB5 (D4).

Curieusement, les broches D3 et D6 sont identifiées "PWM" sur la carte, mais elles ne semblent pas en mesure d'émettre un tel signal.

(Si ça ne vous suffit pas, 7 sorties PWM supplémentaires ne sont accessibles que sur les connecteurs mâles "morpho").

Les broches PWM de la STM32F030 Demo Board

Officiellement, la STM32F030 Demo Board comporte 9 broches PWM: PA0, PA1, PA2, PA3, PA5, PA6, PA7 et PB1.

Toutefois, avec mon exemplaire de cette carte, je n'ai réussi à produire un signal PWM que sur les 4 broches suivantes: PA4, PA6, PA7 et PB1. J'ignore pour quelle raison.

analogWrite(),  analogWriteResolution() et analogWriteFrequency()

Dans notre programme, un signal PWM est produit grâce à la fonction analogWrite(). Cette fonction nécessite deux arguments: le numéro de la broche de sortie et un entier qui représente le rapport cyclique ("duty cycle") désiré.

Par défaut, le signal produit aura une fréquence de 1000 Hz et une résolution de 8 bits. Toutefois, il est possible de modifier la fréquence au moyen de la fonction analogWriteFrequency(), et de modifier la résolution au moyen de la fonction analogWriteResolution().

Par exemple, les 3 lignes de code ci-dessous produiront sur la broche PA6 un signal PWM de 1000 Hz, ayant un rapport cyclique de 50%:

    analogWriteResolution(8);   // résolution 8 bits
    analogWriteFrequency(1000);  // fréquence de 1000 Hz
    analogWrite(brochePWM, 128);  // rapport cyclique 50%

À une résolution de 8 bits, le rapport cyclique peut prendre n'importe quelle valeur entière entre 0 (0%) et 255 (100%).

Les 3 lignes ci-dessous produiront plutôt un signal PWM de 5000 Hz ayant un rapport cyclique de 25%:

    analogWriteResolution(16);   // résolution 16 bits
    analogWriteFrequency(5000);  // fréquence de 5000 Hz
    analogWrite(brochePWM, 16384);  // rapport cyclique 25%

Cette fois, puisque la résolution est de 16 bits, le rapport cyclique peut prendre n'importe quelle valeur entière située entre 0 (0%) et 65535.

Voici un signal PWM dont le rapport cyclique est de 25% (le signal est au niveau logique HAUT pendant 25% du temps, et au niveau logique BAS pendant 75% du temps):

Rapport cyclique de 50%:

Rapport cyclique de 75%:

Pour terminer, voici le sketch (minimaliste) que j'ai utilisé pour mes tests. L'oscilloscope était branché à la broche PA6 de la carte STM32.


Yves Pelletier   (Twitter, Facebook)

Mesure d'une tension analogique avec une carte STM32

N.B.: Ce billet a été mis à jour le 10 novembre 2019 afin de tenir compte des particularité du nouveau STM32 Core.

Les cartes STM32 comportent plusieurs entrées analogiques qui peuvent mesurer une tension située entre 0 et 3,3 V avec une résolution de 12 bits (la valeur mesurée varie donc entre 0 et 4095, ce qui permet en principe de distinguer entre elles deux tensions séparées d'aussi peu que 1 mV).

(Par comparaison, l'Arduino Uno comporte 6 entrées analogiques qui peuvent mesurer une tension située entre 0 et 5 V avec une résolution de 10 bits (0 à 1023) ou 5 mV.)

Dans ce court tutoriel, nous lirons une entrée analogique en programmant une carte STM32 avec l'IDE Arduino; vous devez donc avoir préalablement installé le STM32 Core au moyen du gestionnaire de cartes (instructions détaillées ici).


Entrées analogiques de la Blue Pill STM32F103

Les 10 broches de la Blue Pill qui peuvent être utilisées comme entrées analogiques sont: A0, A1, A2, A3, A4, A5, A6, A7, B0 et B1.

Attention: contrairement à plusieurs autres broches de la Blue Pill (qui tolèrent officiellement des tensions de 5 V), la tension à chacune de ces 10 broches pouvant servir d'entrée analogique ne doit en aucun cas dépasser 3,3 V.

Entrées analogiques du Nucleo F030R8

Sur ma carte Nucleo F030R8, j'ai pu utiliser avec succès les broches PA0, PA1, PA4, PA6, PB0, PC1, PC2, PC3, PC4 et PC5. Les broches PA5, PA7 et PB1 sont en principes reliées à un ADC, mais je n'ai pas réussi à leur faire lire une tension analogique.

Entrées analogiques de la STM32F030 Demo Board

Sur ma STM32F030 Demo Board, les entrées analogiques sont PA0, PA1, PA2, PA3, PA4, PA5, PA6, PA7 et PB1.

Circuit

Pour expérimenter la mesure d'une tension, j'ai branché un potentiomètre de 10 k à une des entrées analogiques de la carte. Les autres de broches du potentiomètre, bien entendu, sont reliées à GND et 3,3 V.

Pour que les valeurs mesurées soient acheminées vers le moniteur série de l'IDE Arduino, la Blue Pill et la Demo Board doivent être branchés à l'ordinateur au moyen d'un convertisseur USB-série: dans le cas de la Blue Pill, la transmission série s'effectue par la broche A9, alors qu'il s'agit de la broche PA2 pour la Demo Board. En ce qui concerne la carte Nucleo, il s'agit qu'elle soit branchée à un port USB de l'ordinateur.



Sketch

Sans trop de surprise, c'est l'instruction "analogRead()" qui permet de prendre la mesure de la tension.  Mais attention: pour profiter de la pleine résolution du convertisseur analogique-numérique du STM32, il faut ajouter l'instruction "analogReadResolution(12)" dans la partie setup (sinon, par défaut, la résolution sera limitée à 10 bits, comme pour les cartes Arduino conventionnelles).

En tournant le potentiomètre, vous pouvez faire varier la valeur mesurée entre 0 et 4095.

-
-

Yves Pelletier   (Twitter, Facebook)

Écran OLED SH1106 I2C et Raspberry Pi

Cet article a été mis à jour le 30 décembre 2020 (compatibilité Python 3).

Dans ce billet, nous allons brancher à un Raspberry Pi un petit écran OLED monochrome de 128 X 64 pixels, puis y afficher du texte et des formes géométriques grâce à un script en Python.

Technologie OLED

OLED signifie "organic light emitting diode", donc "diode électroluminescente organique".

Les écrans OLED offrent des caractéristiques similaires aux écrans LCD (à cristaux liquides), sauf qu'ils ne nécessitent pas de rétroéclairage et produisent des images plus contrastés.

Mon écran OLED

J'ai utilisé un écran OLED de 128 X 64 pixels, dont les dimensions sont approximativement 3,5 cm X 1,8 cm. Il est basé sur le contrôleur SH1106 et utilise le protocole de communication I2C. Il y a quelques semaines, j'ai décrit la façon de le contrôler au moyen d'un Arduino.

Connexion de l'écran au Raspberry Pi

Puisque j'ai la version I2C de l'écran, je l'ai branché au Raspberry Pi de la façon suivante:

Écran OLED  ----  Raspberry Pi

Broche GND  ---- Broche 1 (3,3 V)

Broche VCC  ---- Broche 6 (GND)

Broche SCL   ---- Broche 5 (GPIO 3)

Broche SDA  ----  Broche 3 (GPIO 2)

Activation de l'I2C sur le Rasbperry Pi

Si vous n'avez encore jamais branché de périphérique I2C à votre Raspberry Pi, il est important d'activer le protocole I2C, en ouvrant "Configuration du Raspberry Pi" dans le menu Préférences.

Assurez-vous que l'option I2C est activée dans l'onglet "Interfaces" (un redémarrage du Raspberry Pi est nécessaire pour que les modifications prennent effet).

Si votre écran est correctement branché et que l'I2C est activé, la commande "i2cdetect -y 1" tapée dans le terminal vous permettra de détecter l'écran à l'adresse 3c.

Installation de la bibliothèque luma.oled

La bibliothèque luma.oled est conçue pour le contrôle de nombreux écrans OLED (contrôleurs SSD1306, SSD1309, SSD1322, SSD1325, SSD1327, SSD1331, SSD1351 et SH1106). Vous pouvez consulter en ligne son manuel d'utilisation détaillé.

Pour installer ce module Python dans mon Raspberry Pi, il s'agit d'écrire cette commande dans le terminal:

sudo -H pip3 install --upgrade luma.oled

Exemple de script

À titre d'exemple, voici un script qui affiche sur l'écran la date et l'heure, l'adresse IP utilisée par le Rasbperry Pi et quelques formes géométriques (rectangle, ovale, polygone, lignes droites). Comme d'habitude pour ce genre d'écrans, chaque position sur l'écran est définie au moyen d'une abscisse et d'une ordonnée, le premier pixel en haut à gauche ayant les coordonnées x = 0 et y = 0.


Les concepteurs de luma.oled mettent également à notre disposition une grande quantité d'exemples (affichage d'images sauvegardées en fichier, animations, etc.).

À lire également

J'ai aussi eu l'occasion de contrôler cet écran OLED avec un Arduino Uno, avec une carte STM32 (Nucleo et Blue Pill), avec un ESP8266 et avec un ESP32.

D'autres afficheurs peuvent être contrôlés grâce à un script en python sur le Raspberry Pi: écran couleur SPI ST7735, écran Nokia 5110, afficheur LCD 16 X 2 ...

Yves Pelletier   (Twitter, Facebook)

Et pendant ce temps, dans un blog près de chez vous...(2)

Tout comme la dernière fois, je vous présente quelques publications récentes qui ont attiré mon attention.

Le Micro:bit est le sujet de l'heure sur Ardublog.  On n'y a récemment parlé de MakeCode pour Micro:bit, des meilleures façon de connecter quelque chose au Micro:bit, et d'une version du jeu roche-papier-ciseau sur Micro:bit qui comporte une fonction secrète vous permettant de tricher!

RitonDuino continue de présenter des analyses complètes et détaillées. Les plus récentes livraisons concernent l'alimentation d'un Arduino sur pile ou batterie, l'alimentation de l'ESP8266 et de l'ESP32 par batterie et la fabrication d'une minuterie pour insoleuse de PCB.

Sur Makoto Workshop, vous pouvez lire deux nouveaux billets concernant la construction d'une éolienne à axe vertical (#13 et #14) (une série d'article débutée 10 ans plus tôt!).

En plus de 4 billets concernant l'imprimante 3D Geeetech A10 (#1, #2, #3, #4) , iTechnoFrance a aussi présenté un projet consistant à équiper un bar d'un bandeau de LED, la transformation d'une lampe de bureau au moyen d'un bandeau de LED, et un article sur l'utilisation de la librairie NeoPixel en MicroPython.

Sur Framboise 314: présentation du lecteur réseau RaspDAC Mini, et présentation du site "Carte Magique"  (il s'agit d'un guide qui offre une comparaison des différentes cartes disponibles sur le marché).

Yves Pelletier   (Twitter, Facebook)

ESP8266 et carte SD

Dans cet article, je vous propose la mise au point d'un "data logger" à base d'ESP8266 qui répétera une mesure à une fréquence choisie par l'utilisateur et enregistrera les informations à l'intérieur  d'un fichier sur une carte SD. De plus, il sera possible de consulter les 10 mesures les plus récentes dans une page web.

Connexion et test du lecteur de carte SD

Mon lecteur de carte SD est un module qui communique au moyen du protocole SPI à un niveau logique de 3,3 V qui convient parfaitement à l'ESP8266.

En ce qui concerne l'ESP8266, j'ai utilisé une carte Wemos D1, mais bien entendu n'importe quel ESP8266 comportant un nombre suffisant de broches GPIO fera l'affaire.

Le module lecteur de cartes SD est connecté à l'ESP8266 de la façon suivante:

      Carte SD    ---    ESP8266

GǸD      ---     GND

 +3,3     ---     3,3V

+5       ---     ----

      CS        ---    GPIO 15

    MOSI      ---    GPIO 13

      SCK      ---    GPIO 14

      MISO    ---    GPIO 12

Bonne nouvelle: la bibliothèque "SD" fournie avec l'IDE Arduino est parfaitement compatible avec l'ESP8266, ce qui simplifie évidemment les choses.

Pour vérifier le fonctionnement correct de la carte SD, c'est toujours une bonne idée de faire l'essai de l'exemple "CardInfo". Il faudra toutefois utiliser "15" comme valeur de la constante "chipSelect".

Sketch

Voici le sketch qui prend une mesure à chaque minute et consigne le résultat à l'intérieur d'un fichier intitulé "Mesures.txt" sur la carte SD.  Pour faire mes tests, j'ai simplement utilisé un potentiomètre branché à l'ADC de l'ESP8266. La date et l'heure de chaque mesure est également enregistrée, après interrogation d'un serveur NTP (il n'est donc pas nécessaire de brancher une horloge temps réel (RTC) à l'ESP8266.

Afin de profiter au maximum des possibilités de l'ESP8266, j'ai également programmé un serveur web qui présente les 10 mesures les plus récentes ayant été enregistrées sur la carte SD.

Lors du démarrage, le moniteur série indique la réussite (ou l'échec) de la connexion au réseau WiFi, de la mise en place du serveur web, de la connexion au serveur NTP et de l'initialisation de la carte SD. L'enregistrement de chaque mesure dans la carte SD est également signalée.

Au moyen d'un fureteur, on accède à l'adresse IP indiquée dans le moniteur série, ce qui nous permet de consulter les 10 dernières mesures ayant été consignées sur la carte SD.

À lire également: 

• Vous pouvez également lire et enregistrer des fichiers dans la mémoire flash de l'ESP8266
• Autres projets impliquant l'ESP8266

Yves Pelletier   (Twitter, Facebook)