Procédure Beta de boot USB sur disque SSD Raspberry PI 4 (sans garantie car actuellement expérimental).

Cet article s’inspire de plusieurs autres pas forcément bien clairs, j’ai essayé de corriger quelques petites erreurs et de le traduire.

Il y deux choses à changer :

  • Le contenu de l’eeprom du Raspberry PI4
  • Quelques fichiers dans le répertoire de boot du disque SSD

Comme d’habitude il faudra créer une Micro SD avec l’OS Raspberry, faire la même chose avec le SSD, pour info la dénomination Raspbian a vécu, il faudra maintenant dire « Raspberry OS » disponible ici : https://www.raspberrypi.org/downloads/raspbian/

A présent insérer la carte micro SD fraîchement réalisée dans le Raspberry et faire les mises à jour habituelles + celle du rpi-update.

  • sudo apt update
  • sudo apt upgrade
  • sudo rpi-update

Reboot et installation de l’utilitaire rpi-eeprom pour changer le contenu de l’eeprom.

  • sudo reboot
  • sudo apt install rpi-eeprom

Maintenant, nous devons changer l’endroit où se trouve le nouveau contenu de l’eeprom. Nous faisons cela avec l’édition de ce fichier et remplaçons «critique» par «beta».

  • sudo nano /etc/default/rpi-eeprom-update
  • remplacer « critical » par « beta »
  • CTRL X et Y
  • Save it.

Maintenant on peux reprogrammer l’eeprom avec cette commande :

  • sudo rpi-eeprom-update -d -f /lib/firmware/raspberrypi/bootloader/beta/pieeprom-2020-05-15.bin
  • sudo reboot

On peux vérifier la version du boot loader:

  • vcgencmd bootloader_version

Il s’agit bien de la version du 15 mai (en tout cas à la date de ce post …)

Et

  • vcgencmd bootloader_config

Vérifier que BOOTORDER=0xF41 (4 est pour booter d’abord sur le SSD et 1 sur la micro SD si vous l’avez laissé insérée).

Maintenant on peut passer au disque USB SSD après l’avoir inséré dans un port USB .

On doit maintenant copier tous les fichiers *.elf et *.dat depuis la carte micro SD dans le répertoire « boot » du disque SSD :

Donc d’abord il faut monter le disque SSD après l’avoir déclaré, soit :

  • sudo mkdir /mnt/mydisk
  • sudo mount /dev/sda1 /mnt/mydisk

Et copier les fichiers en question :

  • sudo cp /boot/*.elf /mnt/mydisk
  • sudo cp /boot/*.dat /mnt/mydisk

Finalement relancer le Raspberry PI 4 sans sa carte micro SD

Conclusions et constatations : ne fonctionne pas avec tous les SSD, problème d’USB 3 avec une interface USB / SSD « Sabrent », n’as fonctionné que depuis un port USB2, pas essayé avec des clefs USB non plus.

Toutefois le lien suivant donne une liste d’interfaces USB / SATA qui fonctionnent (ou pas) : https://jamesachambers.com/raspberry-pi-4-usb-boot-config-guide-for-ssd-flash-drives/

Reste à attendre la mise à jour « non beta » de la fondation.

Baromètre analogique et digital avec un ESP32 & un capteur BMP180.

Il existe 1000 et une descriptions de baromètres digitaux basés sur le capteur BMP180 servi par un Arduino, un ESP8266 ou un ESP32. Alors pourquoi celle-ci ?

Elle diffère des autres par l’ajout d’un galvanomètre à cadre mobile des années 60 qui (outre le côté vintage) permet de voir la tendance d’un seul coup d’oeuil à la façon de l’aiguille mobile des baromètres anéroïdes d’antan.

Vous savez : l’aiguille que l’on met en correspondance avec l’aiguille d’affichage de la pression atmosphérique après avoir tapoté le baromètre…

Le montage s’appuie sur un capteur de pression atmosphérique géré par un microcontrôleur qui doit aussi être capable de générer une tension continue représentative de la pression pour alimenter le galvanomètre de tendance de la pression atmosphérique. Ce capteur inclut aussi une mesure de température qui ne sera pas utilisée ici.

Pour cela il faut nécessairement un microcontrôleur doté d’un DAC (Digital to Analog Converter).

L’Arduino Due dispose bien de 2 canaux DAC, mais il est relativement onéreux (même en version clone). Comme l’ESP8266 ne dispose pas de DAC, mon choix s’est porté sur l’ESP32 qui est la version évoluée de l’ESP8266. Ce microcontrôleur se trouve à moins de 10 Euros sur une plateforme Américaine bien connue et à deux fois moins cher sur d’autres plateformes asiatiques toutes aussi connues.

De plus ce microcontrôleur dispose de fonctions WIFI bien utiles pour pouvoir par la suite enrichir le programme à l’envi.

Aspect matériel : l’ensemble se décline autour des composants suivants :

  • Un ESP32 & son support (ou pas),
  • Un BME 180 & son support (ou pas),
  • Un afficheur LCD I2C,
  • Un galvanomètre à cadre mobile (100 µA, mais toute autre valeur jusqu’à 1 mA fera aussi bien l’affaire),
  • Une résistance de 22 K Ohms (à ajuster en fonction d’un galvanomètre différent),
  • Un potentiomètre de 47 K Ohms (à ajuster en fonction d’un galvanomètre différent),
  • Une plaquette à trous,
  • Un peu de fil de câblage,
  • Le boitier qui vous plaira : c’est plus à ce niveau que la difficulté arrive quand il faut loger tout ce petit monde et faire des découpes rondes et rectangulaires, mais ça c’est une autre histoire. Il est toujours possible de réaliser ce montage avec une plaquette de type « breadboard » mais ce ne sera qu’expérimental,
  • Une alimentation de type chargeur de téléphone portable (la consommation du microcontrôleur et de l’afficheur sont minimes).

Aspect logiciel : Ayant bien cherché je me suis rabattu sur la plateforme Arduino, car à ma connaissance c’est la seule qui permette nativement de pouvoir utiliser les DAC de l’ESP32. Je suis preneur d’informations si quelqu’un a réussi a traiter le sujet en micro-Python par exemple.

Les composants

Le microcontrôleur
Le capteur
L’afficheur I2C
Un galvanomètre

Le schéma de câblage (zoomer pour voir les détails)

L’afficheur et le capteur sont connectés en I2C au microcontrôleur, le voltmètre constitué du microampèremètre de la résistance de 22 K Ohms et du potentiomètre est relié au port 25 de l’ESP32.
Le microcontrôleur est alimenté directement par une alimentation de téléphone portable en micro USB, son modèle n’est pas critique vu la faible consommation du montage (moins de 100 mA).

La partie logicielle

L’IDE Arduino

J’ai considéré que le lecteur connaissait l’environnement de développement Arduino.

Si ce n’est pas encore le cas je conseille vivement la page suivante qui sans nul doute va vous permettre de vous familiariser avec cet environnement :

https://www.arduino-france.com/tutoriels/ide-arduino-installation-et-utilisation/

Mais il existe une pléthore de forums Arduino dans le monde et dans toutes les langues.

Sans rentrer dans trop de détails sachez qu’outre les platines Arduino bien connues (Arduino Uno, Arduino Nano, Arduino Due, etc..) cet environnement permet aussi de développer (dans le langage Arduino qui est proche du C++) de nombreux autres microcontrôleurs comme l’ESP8266 et l’ESP32 objet du présent montage.

Il vous faudra installer :

Dans les préférences (« Fichier », « Préférences ») : le lien vers les produits espressif

https://raw.githubusercontent.com/espressif/arduino-esp32/gh-pages/package_esp32_index.json

Dans le gestionnaire de cartes (« Outil », « Type de carte ») : « ESP32 »

Sans oublier de (bien) configurer le port série émulé par la connexion USB de l’ESP32, il suffit pour cela d’aller voir dans le gestionnaire de périphériques de Windows au niveau « Ports (COM & LPT). Le numéro de port varie d’un ordinateur à l’autre.

Dans le gestionnaire de bibliothèques : la bibliothèque BMP085 qui est compatible avec le capteur BMP180 : (« outil », »gérer les bibliothèques »)

Et avant de lancer la compilation, dans le gestionnaire de cartes : choisir le microcontrôleur ESP32 (« outil », « type de carte », « gestionnaire de carte ») : « ESP 32 DEV Module »

Le code en langage Arduino

/*
 * CopyLeft Christian Thomas 
 * 05/05/2020
 * Version 5
 * Correction écriture DAC
*/
#include <Wire.h>
#include <Adafruit_BMP085.h>
Adafruit_BMP085 bmp;
#include <LiquidCrystal_I2C.h>

// Sélection de l'afficheur LCD, nombre de colonnes et de lignes
int lcdColumns = 16;
int lcdRows = 2;
// initilisation de la valeur à envoyer au DAC (sur 8 bit)
int(ValDAC)=0;

// Définition adresse de l'afficheur LCD, nombre de colonnes et de lignes
LiquidCrystal_I2C lcd(0x27, lcdColumns, lcdRows);  
 
void setup() {
  // Initialisation liaison série de débugging
  Serial.begin(115200);
  // Initialisation LCD
  lcd.init();
  // Allumage éclairage LCD                  
  lcd.backlight();
  // Vérification présence du capteur BMP180
  if (!bmp.begin()) {
  Serial.println("Capteur BMP180 non trouvé, vérifier le cablage");
  while (1) {}
  }
}

void loop()
// Boucle principale
{
  
/*
   on considère la pression max à 1100 Pascals pour définir la déviation pleine 
   échelle du galvanomètre
   soit 3,3 V pour 255 points sur les 8 bit du DAC de l'ESP32
   en réalité le maximum atteint a été pour une station à plus de 750 mètres 
   d'altitude : 1 086,8 hPa, à Tosontsengel (Mongolie) le 19 décembre 2001 
   pour la petite histoire ...
   Si l'on travaille sur toute l'échelle (de 900 000 Pa à 110 000 Pa on aura un 
   écart
   de 0.6 V entre le min et le max. Il est préférable de dilater l'échelle pour 
   partir de O V en décalant 
   L'origine à 900 000 Pa et en utilisant la plage entre 900 Pa & 1100 Pa
*/
  // Sortie analogiques sur galvanomètre
  // conversion digitale analogique sur 8 bits sur port DAC N° 1 (D25)
  
  // calcul du poids sur 8 bit à envoyer au DAC
  ValDAC=((bmp.readPressure()-(90000))*255/20000);
  // ecriture DAC  
  dacWrite(25,ValDAC);
  // Le deuxième port digital analogique reste disponible pour une autre convertion analogique si nécessaire
  // La température par exemple, ce qui n'as pas d'intérêt dans notre cas 
  // car le capteur étant à l'intérieur du coffret, il est influencé par l'échauffement des composants
  // Affichage LCD 2 lignes (position du curseur / numéro de ligne)
  lcd.setCursor(0,0);
  lcd.print("Pr Atmospherique");
  lcd.setCursor(0,1);
  lcd.print(bmp.readPressure());
  lcd.setCursor(10,1);
  lcd.print("Pascal");
  // affichage sur port série
  // Serial.println("");
  Serial.print("Pression lue          : ");
  Serial.print(bmp.readPressure());
  Serial.print(" Pascal");
  Serial.println("");
  Serial.print("Valeur envoyée au DAC : ");
  Serial.print(ValDAC);
  Serial.print("/255 * 3.2 Volts");
  Serial.println("");
  // Fréquence de mise à jour en millisecondes  
  delay(500);
}

Le produit fini

Intérieur et raccordements
A droite le potentiomètre qui permet de centrer l’aiguille du galvanomètre pour observer les variations comme on le faisait avec l’aiguille centrale d’un baromètre anéroïde.

A l’usage les variations de pression atmosphérique même de faible ampleur sont très visible sur le galvanomètre, déplacer le montage de deux niveaux dans une maison donne une variation d’une graduation sur mon galvanomètre.

Compte tenu de la richesse de l’ESP32 il sera possible de rajouter de multiples fonctions, notamment en utilisant le WIFI (création d’un mini serveur WEB, envoi de notifications, etc…).