Home Assistant-Gestion piscine-4_Mesure Ph

Dans la série « gestion piscine », faisant suite aux articles sur la filtration, la mesure de puissance électrique et la mise à niveau automatique, je vous propose de découvrir mon dispositif de mesure du pH.

Les possesseurs de piscine le savent, le pH est une composante importante dans le traitement des eaux de piscine. Un mauvais pH rendra très difficile voir impossible le traitement de l’eau. Personnellement, je cible une valeur de Ph à 7.2 +-0.2.

Dans le commerce vous trouvez beaucoup de régulateurs de pH, malheureusement à des prix trop élevés à mon gout.

J’ai découvert les modules EZO fabriqués par AtlasScientific au hasard du net, mais la toute récente intégration du module EZO dans EspHome m’a conforté dans ce choix.

Je commande les modules EZO chez https://www.whiteboxes.ch/ , c’est rapide et j’ai pas trouvé mieux ailleurs en Europe. leur boutique est bien organisée, vous y retrouvez bon nombre de produits ainsi que la documentation très fournie associée.

Vous y trouvez notamment des modules et sondes de mesure de conductivité, ORP, oxygène dissoute, température, mesure de gaz O² et CO², de couleur, humidité, pression, ainsi que divers accessoires.

Nota: dans un premier temps, je ne traite dans cet article que la mesure de pH, la régulation avec des pompes péristaltiques fera l’objet d’une mise à jour.

La partie matérielle

La liste des courses se résume à:

  • Un module mesure de ph EZO
  • Une sonde pH EZO. J’utilise celle ci mais il existe des modèles compatibles industriels beaucoup plus chers et des modèles chinois beaucoup moins chers, c’est selon l’importance et le budget que vous accorderez à la fiabilité et la pérennité de la mesure.
  • Un connecteur SMA pour la sonde.
  • Un module d’isolation galvanique EZO. Je ne l’ai utilisé qu’apres avoir essayé sans, mais je rencontrai des problèmes de stabilité de mesure, résolus grâce à ce module.
  • Un afficheur local 2 lignes de 16 caractères . Vous en trouvez à foison sur le net, c’est pratique de le choisir avec une puce compatible ESPHome.
  • Un ESP32. J’ai choisi ce modèle car je pense lui confier à terme d’autres fonctionnalités dédiées à la piscine, cependant un esp8266 D1 ferait très bien l’affaire.
  • Une alimentation 220VCA-5VCC courant continu.
  • Quelques connecteurs et cordons JST précablés.
  • Divers composants et accessoires

Pour des raison pratiques j’ai dissocié la partie ESP de la partie mesure du pH, donc deux circuits imprimés.

Je préfère intégrer mes composants sur un circuit imprimé, c’est plus propre et donc plus fiable. Je conçois mes schémas et mes circuit imprimés avec le logiciel Eagle et je les grave avec une CNC de ma fabrication.

Schéma électronique de mesure du pH

Vous y retrouvez:

  • Le module d’isolation galvanique
  • Le module de mesure de pH
  • le connecteur SMA (SV1)

Circuit imprimé réalisé avec Eagle

Fichiers Eagle à télécharger

Schéma électronique de l’ESP

Quelques explications sur le schéma:

  • Bus I²C (pin 21,22) a quatre connecteurs: 1 pour l’afficheur, 1 pour le module EZO, 2 pour de futures pompes péristaltiques (injection pH+ et pH-).
  • Bus UART (pin 18,19): Réserve si besoin de brancher un UART
  • Entrées digitales (pin 16,17): Si besoin d’une action rapide en local (Bouton poussoir Marche arrêt pompe par exemple)
  • Entrée analogique (pin 3): Mesure de pression du filtre à sable
  • Entrée analogique (pin 4): Mesure de pression refoulement (A venir)
  • BP RAZ (Pin 2): Accès au « reboot » de l’ESP en local.

Vous constaterez l’anticipation de quelques fonctionnalités complémentaires qui feront l’objet d’articles spécifiques.

Le Circuit imprimé réalisé avec Eagle

J’évite si possible la fabrication de circuit double face, d’où l’utilisation de quelques straps (en rouge) me permettant de m’en sortir avec un CI simple face.

Fichiers Eagle à télécharger

La partie logicielle

Module EZO

Le module de mesure EZO peux communiquer selon deux protocoles: I²C ou UART. Seul le protocole I²C est disponible dans ESPHome . Par défaut le module est configuré d’usine en UART, il faut donc le basculer en I²C. C’est très simple et bien expliqué dans la documentation du module.

Deux solutions pour le changement de protocole, par logiciel ou par câblage, c’est celle que je préfère, car plus rapide à mettre en œuvre:

  • Connecter TX et PGND
  • Veiller à ce que RX soit déconnecté
  • Alimenter en 0-5v via GND et VCC
  • La led passe en bleue, c’est OK, vous êtes en I²C. A noter que la manipulation est identique pour le re basculer en UART.

Pour information, La led du module est verte en UART et bleue en I²C.

La solution logiciel nécessite un montage sur le port série avec par exemple un Arduino et l’utilisation du code fourni par EZO.

L’isolateur galvanique ne nécessite pas d’intervention.

ESP Home

Rien de particulier, vous y retrouvez les déclarations standards ESPHome, la déclaration EZO ainsi que celle de l’afficheur. A noter la déclaration du bus I²C sur les GPIO spécifiques à l’esp32, celle de l’esp8266 sont différentes (GPIO5->scl, GPIO4->sda). L’option « scan: true » autorise l’ESP à scanner les esclaves i²C, pratique pour vérifier dans le log si l’ESP reconnait le module EZO et l’afficheur. L’adresse I²C de l’EZO et de l’afficheur sont différentes donc pas de souci de compatibilité.

Si besoin de précisions sur le flashage de l’ESP, se reporter à mon article « Home Assistant-ESP HOME ».

esphome:
  name: esp125_piscine
  platform: ESP32
  board: lolin_d32

wifi:
  ssid: "xxx"
  password: "xxxxxxxxxxx"

  # Enable fallback hotspot (captive portal) in case wifi connection fails
  ap:
    ssid: "Esp125 Piscine Fallback Hotspot"
    password: "xxxxxxxxxxx"
    
  manual_ip:
    static_ip: 192.168.0.xxx
    gateway: 192.168.0.1
    subnet: 255.255.255.0

captive_portal:

# Enable logging
logger:

# Enable Home Assistant API
api:

ota:

web_server:
  port: 80

# Configuration pour ESP32
i2c:
  sda: 21
  scl: 22
  scan: True
  id: bus_a
  

sensor:
# Mesure du pH
  - platform: ezo
    id: esp125_ph_ezo
    address: 99
    unit_of_measurement: "pH"
    update_interval: 10s

#  Pas indispensable
  - platform: uptime
    name: "ESP125 Uptime Sensor"
    id: esp125_uptime
    update_interval: 10s

  - platform: wifi_signal
    name: "ESP125 WiFi Signal Sensor"
    update_interval: 60s

# Gestion afficheur
display:
  - platform: lcd_pcf8574
    dimensions: 16x2
    address: 0x27
    lambda: |-
      it.printf(0,0,"Ph= %.2f",id(esp125_ph_ezo).state);
      
switch:    
  - platform: restart
    name: "ESP125_Restart"

Une fois l’ESP flashé, alimenté et connecte, vous retrouvez dans HA la mesure de ph et l’affichage en local.

Vous pouvez aussi vérifier son fonctionnement dans la page WEB de l’ESP.

Calibration du module EZO

La calibration est à faire au moins une fois dans l’année. J’utilise de temps en temps les bonnes veilles languettes de réactifs afin de vérifier si la mesure de pH est fiable.

Pour la calibration, nous devons arrêter l’ESP, récupérer le circuit imprimé des modules EZO ainsi que la sonde et raccorder provisoirement le CI sur un Arduino ou un autre ESP.

Préparer 3 solutions de pH étalon dans 250 ml d’eau distillée: (j’utilise des solutions étalon commandées en quantité chez aliexpress)

  • Midle: 6.86
  • Low: 4.00
  • High:9.18

Telecharger le programme arduino_UNO_pH_sample_code dans un arduino (ou un ESP en adaptant le code) https://www.whiteboxes.ch/shop/ezo-ph-circuit/

1-Basculer le module EZO en mode UART si pas déjà fait. la led s’affiche en vert. Voir ci dessus la manipulation à effectuer.

  1. Brancher le module ph EZO en mode UART
  2. Téléverser le programme dans l’arduino
  3. Lancer le monitoring de l’arduino à 9600 bauds
  4. Plonger la sonde dans la préparation « midle »
  5. Attendre la stabilisation environ 2 minutes
  6. Envoyer la commande via la fenêtre de monitoring: Cal,mid,6.86
  7. Le module répond OK
  8. Recommencer avec la préparation avec: Cal,low,4.00
  9. Puis avec la préparation: Cal,high,9.18

Le pHmetre est calibré. Dans leur doc, AtlasScientific utilise du 7.00, 4.00, 10.00, peu importe si les dissolutions utilisées sont calibrées.

Command syntax 
Issuing the cal,mid command after 
the 
EZO"•• pH circuit has been calibrated, will 
clear the other calibration points 
. Full 
calibration will have to be redone. 
Cal,mid,n 
Cal,low,n 
Cal,high,n 
Cal,clear 
Example 
single point calibration at midpoint 
two point calibration at Iowpoint 
three point calibration at highpoint 
delete calibration data 
device calibrated? 
Response 
*OK 
*OK 
*OK

Mise en oeuvre

Pour la mise en oeuvre, J’utilise une chambre de mesure qui permet de positionner deux sondes et deux injecteurs dans le circuit hydraulique, plus un débitmètre. Ne pas oublier les vannes de séparation avant et après ce qui évite d’avoir à vidanger pour intervenir sur les sondes. Dans mon cas j’ai positionner la sonde pt100 de mesure de température sur le deuxième emplacement. L’injecteur et en attente de la pompe de régulation de pH.

Conclusion

Pour quelques dizaines d’euro, un peu de bricolage, vous pouvez vous fabriquer un pH-mètre, de bonne qualité, évolutif et parfaitement intégré dans HA.

Home Assistant-Gestion piscine-3_Mise à Niveau Automatique.

Dans la série « gestion piscine », faisant suite aux articles sur la filtration et la mesure de puissance électrique, je vous propose de découvrir mon dispositif de mise à niveau automatique du niveau d’eau du bassin.

La piscine est équipée d’une rideau flottant immergé, c’est très pratique mais cela exige que le niveau d’eau du bassin soit parfaitement maitrisé dans une fourchette de quelques centimètres. Trop bas ou trop haut, le rideau risque de frotter sur l’infrastructure, d’où la nécessité de réguler précisément le niveau d’eau, bien évidemment, je ne pouvais que confier cette mission à HA.

Les fonctionnalités à créer sont simples:

  • Sur détection du niveau bas pendant quelques secondes, ouverture de l’électrovanne
  • Sur détection du niveau haut pendant quelques secondes, fermeture de l’électrovanne
  • Maitriser le temps d’ouverture de l’électrovanne
  • Piloter, monitorer, notifier avec HA.

L’ensemble nécessite deux entrées digitales et une sortie relais, personnellement j’utilise un automate WAGO série 750 communiquant en Modbus, équipé d’une carte d’entrées pt100, d’une carte d’entrées digitales et d’une carte de sortie relais.

Bien entendu, cet automate peut être remplacé par n’importe quel dispositif compatible HA, remplissant les mêmes fonctionnalités. Un ESP32 équipé de deux entrées digitales et d’un module de sortie relais sous ESPHOME peut très bien convenir.

La partie matérielle

Détection de niveau

Lors de la construction, j’ai intégré un régulateur de niveau Hayard , qui fonctionne sur le principe de la chasse d’eau avec flotteur d’un WC, simple mais d’un réglage délicat, avec le risque d’alimenter en eau d’un coté et de voir celle-ci s’écouler dans le trop-plein, je n’étais pas serein lorsque je le mettait en service surtout pendant mon absence.

J’ai conservé l’enveloppe du régulateur de niveau, supprimé le flotteur, intégré un double détecteur de 100mm, le choix de l’entraxe (control range) dépend de vos besoins, le cas échéant, il en existe avec un seul flotteur. le produit est en acier inoxydable.

Le marnage d’un flotteur est de 6 mm ce qui correspond à dans mon cas à 275 litres d’eau.

Les deux fils rouges correspondent au flotteur supérieur, les deux noirs au flotteur inferieur.

Chaque flotteur actionne un contact:

  • ouvert si recouvert
  • fermé si découvert.

Montage du détecteur avant suppression du flotteur. L’équerre support est imprimée avec une 3D. Prévoir une fenêtre de réglage sur le support.

Régler la hauteur après avoir mis le bassin au niveau d’eau idéal. La programmation du capteur opérationnelle et un visuel sur HA ou tout simplement avec un contrôleur universel sur ohmmètre vont permettre d’affiner le réglage (faire un repère sur le support une fois OK)

Je régule le niveau d’eau avec le flotteur supérieur. Le flotteur inférieur me sert d’indicateur de niveau bas: sécurité manque d’eau.

Alimentation en eau

Cette fonction est assurée par une électrovanne, raccordée en série sur l’alimentation d’eau du régulateur de niveau.

J’ai choisi ce modèle, simple et peu onéreux.

Prévoir une vanne d’arrêt, des cosses AMP isolées et un fil de mise à la terre.

Je la pilote par une sortie relais de mon module WAGO

Important

L’ installation électrique de votre piscine est soumise à la norme C15-100, ce qui exige des précautions particulières de mise en œuvre dans les volumes 1,2 ,3.
Je vous invite à consulter cet extrait de la C15-100 section 702.

La partie logicielle

1-Automation « Piscine Appoint Eau ON »

Ouvre l’électrovanne si le niveau d’eau commute de « OFF » à « ON » pendant 10s (filtrage des vagues), si la piscine est en mode « automatique » et l’électrovanne est en mode « automatique ».

- id: '1612536587598'
  alias: Piscine Appoint Eau On
  description: ''
  trigger:
  - platform: state
    entity_id: binary_sensor.tp_plein_lsh
    from: 'off'
    to: 'on'
    for: 00:00:10
  condition:
  - condition: state
    entity_id: input_select.pool_pump_mode
    state: Auto
  - condition: state
    entity_id: input_boolean.ev_eau_piscine
    state: 'on'
  action:
  - service: switch.turn_on
    data: {}
    entity_id: switch.cde_ev_eau
  mode: single

2-Automation « Piscine Appoint Eau OFF »

Ferme l’électrovanne si le niveau d’eau commute de « ON » à « OFF » pendant 10s (filtrage des vagues).

- id: '1612536671701'
  alias: Piscine Appoint Eau Off
  description: ''
  trigger:
  - platform: state
    entity_id: binary_sensor.tp_plein_lsh
    from: 'on'
    to: 'off'
    for: 00:00:10
  condition: []
  action:
  - service: switch.turn_off
    data: {}
    entity_id: switch.cde_ev_eau
  mode: single

3-Automation « Notification Alarme appoint d’eau »

Sensor: Comptage journalier du temps de fonctionnement d’ouverture de l’électrovanne.

# Affichage du temps de fonctionnement de l'électrovanne appoint d'eau ce jour
  - platform: history_stats
    name: Ev Eau tps ouverture jour
    entity_id: switch.cde_ev_eau
    state: 'on'
    type: time
    start: '{{ now().replace(hour=0).replace(minute=0).replace(second=0) }}'
    end: '{{ now() }}'

Automation: Notification « pushbullet » et fermeture de l’électrovanne si le temps de fonctionnement du jour est supérieur à 1h. Cette durée sera optimisée en analysant plus finement la durée moyenne d’ouverture sur plusieurs mois.

- id: '1617185147880'
  alias: Piscine Notification Alarme appoint d'eau
  description: ''
  trigger:
  - platform: numeric_state
    entity_id: sensor.ev_eau_tps_ouverture_jour
    above: '1.00'
  condition: []
  action:
  - service: notify.pushbullet
    data:
      message: Temps ouverture supérieur {{states('sensor.ev_eau_tps_ouverture_jour')}}
        h
      title: Alarme EV Appoint d'eau Piscine
  - service: switch.turn_off
    target:
      entity_id: switch.cde_ev_eau
  mode: single
Affichage de la carte, j’utilise « multiple-entity-row ».

4-Automation « Notification Alarme niveau bas »

Si le capteur inferieur passe de « OFF » à « ON » (de recouvert à découvert) pendant 10s alors envoi d’une notification « pushbullet » et arrêt de la pompe de filtration par sécurité en forçant le mode de fonctionnement de la piscine « input_select.pool_pump_mode » sur Off

- id: '1617199790692'
  alias: Piscine Notification alarme niveau bas
  description: ''
  trigger:
  - platform: state
    entity_id: binary_sensor.tp_plein_lsl
    from: 'off'
    to: 'on'
    for: 00:00:10
  condition: []
  action:
  - service: notify.pushbullet
    data:
      message: La piscine est au niveau BAS
      title: Alarme Niveau Bas Piscine
  - service: input_select.select_option
    data:
      option: 'Off'
    target:
      entity_id: input_select.pool_pump_mode
  mode: single

Conclusion

Simple et facile à mettre en œuvre si la piscine est déjà équipée d’un régulateur de niveau d’eau, à noter que celui-ci peut se raccorder sur un skimmer, reste quand même à faire un peu d’électricité, de plomberie et de la programmation sur HA.

Home Assistant-ESP HOME

J’ai pas mal galéré dans le flashage des ESP avec ESPHOME et je souhaite partager une solution qui me satisfait pleinement.

Je vous invite à découvrir ESPHOME, c’est un Add-on indispensable à la création de petit système basé sur de l’ESP8266 ou 32. Ses possibilités sont nombreuses et simples à mettre en œuvre au moins sur la partie logicielle car il s’intègre parfaitement dans HA.

Installation ESPHOME

C’est un Add-on de « Home Assistant Community Add-ons » donc rien de compliqué. Aucune configuration particulière.
Cocher « Afficher dans la barre latérale »

Une fois installé et en run

Création

Depuis la barre latérale lancer ESPHome.
Dans la fenêtre, cliquez sur + en bas à droite.

Un wizard d’assistance vous invite à:

  • saisir le nom du module (j’y fait toujours apparaitre une référence à l’adresse IP)
  • le type de module « wemos d1 mini » dans cet exemple, c’est modifiable par la suite
  • la connexion WiFi, vous pourrez en ajouter une deuxième par la suite.
  • laissez l’OTA vide
  • next
  • submit

Voila vous avez créé votre ESP, reste à le configurer:

« Edit » ouvre un fichier .yaml dans lequel vous y retrouvez les informations saisies dans le wizard de configuration.
Je le complète dans un premier temps avec:

  • une adresse IP fixe « manual_ip »
  • un « web_server »

Ci-après le code modifié:

esphome:
  name: esp140_test
  platform: ESP8266
  board: d1_mini

wifi:
  ssid: "xxxxx"
  password: "xxxxxxx"

  # Enable fallback hotspot (captive portal) in case wifi connection fails
  ap:
    ssid: "Esp140 Test Fallback Hotspot"
    password: "r9UaK4KhGcIW"

  manual_ip:
    static_ip: 192.168.0.140
    gateway: 192.168.0.1
    subnet: 255.255.255.0

captive_portal:

# Enable logging
logger:

# Enable Home Assistant API
api:

ota:

web_server:
  port: 80

sensor:

  - platform: uptime
    name: "ESP123 Uptime Sensor"
    id: esp123_uptime
    update_interval: 10s

J’ai ajouté un sensor uptime pour exemple.

Vous vérifiez la configuration avec « validate »

Premier téléchargement

Il permet d’initialiser l’ESP avec un fichier « .bin ».

Cliquer les 3 points en haut à droite puis compile

La compilation, normalement terminée sans erreur, vous invite, en bas à droite, au téléchargement d’un fichier « .bin » .

Une fois le fichier « .bin » généré et téléchargé, il reste à le flasher dans l’ESP.

Flashage du fichier

Pour ce faire, j’utilise le logiciel gratuit «  esphome-flasher« . J’utilise la version Windows mais il existe aussi sur d’autres OS. C’est suite à un commentaire de « Dckiller » que j’ai découvert cet utilitaire, merci à lui.

Vous choisissez le « COM » sur lequel vous avez branché votre ESP, le firmware .bin, vous lancez par « Flash ESP ».

Une fois terminé, la connexion est établie avec l’ESP, le log défile dans la console.

Saisir l’adresse Ip dans un explorateur, si tout va bien, vous accédez à une petite page web (celle que vous avez déclaré par « web_server port:80 »).

.

Modification on line.

Une fois l’ESP initialisé, vous pouvez modifier votre configuration et la télécharger en ligne grâce à l' »OTA Over-The-Air ».

Vérifier que vous avez sélectionné OTA en haut à droite du menu principal:

L’attribut alt de cette image est vide, son nom de fichier est image-2.png.
  • Modifier avec EDIT
  • Valider avec VALIDATE
  • Charger avec UPLOAD
  • LOGS affiche des informations de suivi.
  • Le carré avec une flèche bleu est un raccourci vers la page Web.

Conclusion

ESPHome est très puissant et possède de nombreuses fonctionnalités qui traitées par l’ESP soulage HA. Il peut souvent amener une solution au montage DIY qui sortent de l’ordinaire.

Liens utiles

https://docs.platformio.org/en/latest/platforms/espressif8266.html

https://easydomoticz.com/forum/viewtopic.php?t=5366

Home Assistant-Gestion piscine-2_Mesure de puissance électrique

Dans la série « gestion piscine », faisant suite au premier article sur la filtration, je vous propose de découvrir le dispositif de mesure de puissance électrique du coffret piscine.

Mon choix, pour des raisons de coût et de facilité d’intégration dans HA, s’est arrêté sur le module PZEM-004T 100A associé à un ESP8266, l’ensemble intégré via ESPHOME.

Il permet de surveiller la consommation électrique de la piscine (W), de comptabiliser l’énergie (kWh) et accessoirement de visualiser la tension du réseau (V), la fréquence (hz) et le facteur de puissance.

Rien de révolutionnaire dans cet article, si ce n’est de vous faire découvrir le module PZEM-004T qui permet de monitorer à moindre cout une installation électrique. Il existe en 10A (mesure directe) et 100A (avec TOR de Mesure). Ses principales caractéristiques sont:

Tension

  • Plage de mesure: 80 ~ 260 V
  • Résolution: 0,1 V
  • Précision de mesure: 0,5%

Facteur de puissance

  • Plage de mesure: 0,00 ~ 1,00
  • Résolution: 0,01
  • Précision de mesure: 1%

La fréquence

  • Plage de mesure: 45Hz ~ 65Hz
  • Résolution: 0,1 Hz
  • Précision de mesure: 0,5%

Intensité

  • Plage de mesure: 0 ~ 10A (PZEM-004T-10A); 0 à 100A (PZEM-004T-100A)
  • Courant de mesure de départ: 0,01A (PZEM-004T-10A); 0,02 A (PZEM-004T-100A)
  • Résolution: 0.001A
  • Précision de mesure: 0,5%

Puissance active

  • Plage de mesure:
    • 0 ~ 2,3 kW (PZEM-004T-10A);
    • 0 à 23 kW (PZEM-004T-100A)
  • Puissance de mesure de départ: 0,4 W
  • Résolution: 0,1 W
  • Format d’affichage: 
    • < 1000W, il affiche une décimale, telle que: 999.9W
    • ≥1000W, il n’affiche que des entiers, tels que: 1000W
  • Précision de mesure: 0,5%

Énergie active

  • Plage de mesure: 0 ~ 9999.99kWh
  • Résolution: 1Wh
  • Précision de mesure: 0,5%
  • Format d’affichage: 
    • > 10kWh, l’unité d’affichage est Wh (1kWh = 1000Wh), par exemple: 9999Wh
    • ≥10kWh, l’unité d’affichage est le kWh, par exemple: 9999.99kWh

La partie matériel

Le matériel nécessaire à la réalisation est réduit au minimum:

  • un module PZEM-004T 100A permettant de mesurer des courants de 0-100A sous une tension alternative de 80-260V.
  • un module esp8266 d1 ou équivalent.
  • une alimentation 220VCA-5VCC courant continu.
  • divers composants et accessoires

Je préfère intégrer mes composants sur un circuit imprimé, c’est plus propre et donc plus fiable. Je conçois mes schémas et mes circuit imprimés avec le logiciel Eagle et je les grave avec une CNC de ma fabrication.

Schéma électrique

La partie logicielle

La programmation de l’ESP est réalisée avec ESPHOME. Un composant PZEM-004 V1 est inclus dans la bibliothèque mais la nouvelle version des PZEM-004 V3 nécessite la version pzemac.

Je vous invite à parcourir mon article la programmation des ESP avec ESPHOME.

Vous trouverez ci-dessous le code de l’ESP, le Wifi est à adapter à votre configuration

esphome:
  name: esp123_pzem
  platform: ESP8266
  board: d1_mini

wifi:
  ssid: "xxxx"
  password: "xxxxxxxxx"

  # Enable fallback hotspot (captive portal) in case wifi connection fails
  ap:
    ssid: "Esp123-Pzem Fallback Hotspot"
    password: "xxxxxxxxxxxxxx"
  manual_ip:
    static_ip: 192.168.0.123
    gateway: 192.168.0.1
    subnet: 255.255.255.0
captive_portal:

# Enable logging
logger:

# Enable Home Assistant API
api:

ota:
  
web_server:
  port: 80

# Configuration UART
uart:
  rx_pin: GPIO3
  tx_pin: GPIO1
  baud_rate: 9600

sensor:
  - platform: pzemac
    current:
      name: "PZEM-pisci Intensité"
    voltage:
      name: "PZEM-pisci Tension"
    energy:
      name: "PZEM-pisci Energie"
      unit_of_measurement: "kWh"
      filters:
        - multiply: 0.001
    power:
      name: "PZEM-pisci Puissance"
    frequency:
      name: "PZEM-pisci Frequence"
    power_factor:
      name: "PZEM-pisci FactPuiss"
    update_interval: 30s
    
  - platform: uptime
    name: "ESP123 Uptime Sensor"
    id: esp123_uptime
    update_interval: 60s


switch:    
  - platform: restart
    name: "ESP123_Restart"

Une fois l’ESP programmé vous pourrez les afficher dans une carte.

Comme décrit dans l’article sur la filtration, je compare la valeur de la puissance instantanée pour déterminer si la pompe de filtration est en marche et comptabiliser les temps de marche.

Conclusion

Simple, peu onéreux, précis, facilement intégrable à HA, le module PZEM-004T remplit correctement son rôle.

Article associé

Home Assistant-Gestion piscine-1_Filtration

Heureux possesseur d’une piscine depuis de nombreuses années, je constate au quotidien que le poste dépense consommation électrique prend une part importante dans le budget de fonctionnement. L’optimisation du temps de filtration est donc primordial, et cela bien évidemment tout en respectant la qualité de l’eau de baignade.

Dans ce premier article, je partage mon expérience sur la gestion du temps de pompage. Ultérieurement, je vous ferai découvrir d’autres solutions techniques que j’ai mis en oeuvre comme:

  • le calcul du hors gel
  • le monitoring électrique du coffret piscine
  • la mesure de pH à base d’arduino
  • la mise à niveau automatique du niveau d’eau
  • la mesure de pression du filtre à sable

J’ai également en prévision de réalisation:

  • la régulation du ph
  • l’automatisation de la couverture flottante

La mise en oeuvre nécessite un minimum de connaissances sur les fondamentaux de HA. 

Avant la migration de mon système domotique de Jeedom vers HA, je pilotais la pompe de filtration avec Jeedom et le plugin « Pool » de scadinot.controle

Une fois sur HA, j’ai cherché le moyen de remplacer le plugin par des fonctions similaires sur HA. Apres plusieurs tests de plugin et autres programmations sans succès, je me suis arrêté sur le HACS « Pool pump Manager » développé par « oncleben31« .

Ce composant a été développé sur la base de celui de « exxamalte » avec quelques améliorations dont la principale est la prise en compte de la température de l’eau dans le calcul de la durée de filtration.

La durée de filtration est régit par la courbe bleue de AbacusFilteringDuration() également utilisée par le plugin Jeedom, c’est une des fonctionnalités du module Python « PyPoolPump » développé par oncleben31.

Voici le détail de la courbe de filtration, nous utilisons la courbe bleue représente la valeur 100%. La courbe verte 140% et la courbe rouge 60% ne sont pas utilisées dans notre cas, il n’y a pas dans cette version la possibilité de pondérer l’action de la température sur la durée.

L’intégration du module dans HA, simplifiée par l’utilisation de HACS, est très bien décrite dans la documentation, elle se décompose ainsi:

1-Intégration dans HACS,

Choisir la branche « Dev » du module.

2-Déclaration du module « pool_pump »

et des trois variables indispensables au fonctionnement du module dans configuration.yaml:

pool_pump:
  switch_entity_id: switch.pool_pump_switch
  pool_pump_mode_entity_id: input_select.pool_pump_mode
  pool_temperature_entity_id: sensor.pool_water_temperature
  • avec:
    • switch_entity_id: nom de l’entité de pilotage de la pompe
    • pool_pump_mode_entity_id: nom de l’entité permettant de selectionner le mode de fonctionnement de la pompe
    • pool_temperature_entity_id: nom de l’entité de la mesure de temperature de l’eau

Le module nécessite la mesure de la température de l’eau et le pilotage de la pompe de filtration, personnellement j’utilise un automate WAGO série 750 communiquant en Modbus, équipé d’une carte d’entrées pt100, d’une carte d’entrées digitales et d’une carte de sortie relais.

Bien entendu, cet automate peut être remplacé par n’importe quel dispositif compatible HA, remplissant les mêmes fonctionnalités. Un ESP32 équipé d’une sonde ds18b20  et d’un module de sortie relais sous ESPHOME peut très bien convenir.

3-la déclaration d’entités

J’ai regroupé l’ensemble des entités associées à la piscine dans un fichier pool.yaml, voir ci-dessous:

input_number:
# utilisé pour simuler la température de l'eau pendant les tests  
  temp_piscine:
    name: Temp Eau Simul
    min: -2
    max: 35
    unit_of_measurement: °C

# selection du mode de fonctionnement de la filtration
input_select:
  pool_pump_mode:
    name: Pool Pump mode
    options:
      - 'Auto'
      - 'On'
      - 'Off'
    initial: 'Auto'
    icon: mdi:pool

binary_sensor:
# Si la puissance électrique est supérieure à 500w, on considère que la pompe est en fonctionnement
  - platform: template
    sensors:
      pool_pump_running:
        value_template: "{{ states.sensor.pzem_pisc_puissance.state | float > 500 }}"
        friendly_name: "Pompe Filtration en Ma"

sensor:
# Affichage du temps de fonctionnement de la pompe ce jour
  - platform: history_stats
    name: Pool Pump running today
    entity_id: binary_sensor.pool_pump_running
    state: 'on'
    type: time
    start: '{{ now().replace(hour=0).replace(minute=0).replace(second=0) }}'
    end: '{{ now() }}'

# mesure de la température de l'eau, permet de basculer facilement en mode simulation
# en commentant ou de-commentant les value_template ci-dessous
  - platform: template
    sensors:
      pool_water_temperature:
        friendly_name: 'sensor.pool_water_temperature'
        value_template: "{{ states('sensor.temp_piscine')|float|round(1) }}"  # mesure de la temperature de l'eau
#        value_template: "{{ states('input_number.temp_piscine')|float|round(1) }}" # Simulation avec input_number
        icon_template: mdi:oil-temperature
        unit_of_measurement: 'ºC'
# Affichage de l'heure pivot, c'est l'heure autour de laquelle le temps de fonctionnement est réparti
  - platform: template
    sensors:
      heure_pivot_piscine:
        friendly_name: 'heure_pivot_piscine'
        value_template: '{{ as_timestamp(strptime(state_attr("sun.sun", "next_noon"), "")) | timestamp_custom("%H:%M") }}'
        icon_template: mdi:calendar-clock

# Sensors Modbus
# Mesure la température de l'eau (sonde pt100)
# A adapter à votre configuration
  - platform: modbus
    scan_interval: 60
    registers:
      - name: temp_piscine
        hub: wago_piscine
        unit_of_measurement: °C
        slave: 1
        register: 0
        register_type: input
        scale: 0.1
        precision: 1

# commande des sorties relais du module WAGO
# A adapter à votre configuration
switch:
# Switchs Modbus Piscine
  - platform: modbus
    scan_interval: 10
    coils:
      - name: pool_pump_switch
        hub: wago_piscine
        slave: 1
        coil: 12288
     

Fonctionnement:

Le choix du mode fonctionnement s’effectue avec le input select pool_pump_mode:
On: marche forcée de la pompe. Déclenche sur changement d’état l’automatisation « Pool Pump On » et le service:

service: homeassistant.turn_on
data: {}
entity_id: switch.pool_pump_switch


Off: arret forcé de la pompe. Déclenche sur changement d’état l’automatisation « Pool Pump Off » et le service

service: homeassistant.turn_off
data: {}
entity_id: switch.pool_pump_switch


Auto: fonctionnement basé sur la température de l’eau selon la courbe Abacus décrite ci-dessus. Toutes les 5 mn, l’automatisation « Piscine Check pool Pump » appelle le service « service: pool_pump.check », celui ci évalue l’heure de démarrage et l’heure d’arrêt de la pompe en fonction de:

  • l’heure actuelle
  • la température de l’eau
  • l’heure pivot:
    • Celle ci correspond à l’heure du midi solaire UTC (zenith) voir_doc . le temps de filtration est réparti 1/3 avant l’heure pivot et 2/3 après. J’ai déclaré le template « heure_pivot_piscine: » afin de le visualiser dans la carte Pool. Ce n’est pas indispensable mais c’est utile à la compréhension du fonctionnement .

NB: Vous pouvez constater qu’à l’heure de démarrage calculée, la pompe démarre puis s’arrête quelques instants plus tard pour redémarrer ensuite. C’est dû, dans mon cas, au fait que la sonde de T° de l’eau est située dans un local, et qu’il faut quelques minutes de pompage pour mesurer la T° de l’eau du bassin, surtout l’hiver où l’écart de T° entre l’intérieur et l’extérieur est important.

Le temps de fonctionnement est également recalculé sur:

  • Evolution de la température de l’eau
  • Changement du mode de fonctionnement

Affichage des périodes de filtration

l’entité « pool_pump.next_run_schedule » générée et calculée par le module permet d’afficher la période de filtration en cours, avant puis après l’heure pivot.

Temps de fonctionnement

La consommation électrique de mon coffret piscine est monitorée par un PZEM004 couplé à un ESP8266-12F sous ESPHOME.

La puissance me permet de déterminer si la pompe tourne ou pas. Si la puissance est supérieure à 500W alors pompe en marche.

binary_sensor:
# Si la puissance electrique est superieure à 500w, on considère que la pompe est en fonctionnement
  - platform: template
    sensors:
      pool_pump_running:
        value_template: "{{ states.sensor.pzem_pisc_puissance.state | float > 500 }}"
        friendly_name: "Pompe Filtration en Ma"

Cette variable permet de mesurer le temps de fonctionnement de la pompe (sur la journée dans mon cas)

sensor:
# Affichage du temps de fonctionnement de la pompe ce jour
  - platform: history_stats
    name: Pool Pump running today
    entity_id: binary_sensor.pool_pump_running
    state: 'on'
    type: time
    start: '{{ now().replace(hour=0).replace(minute=0).replace(second=0) }}'
    end: '{{ now() }}'

Automatisations

Il y a quatre automatisations à intégrer dans votre HA:

Bien entendu, les id sont à adapter à votre configuration.

  • Pool Pump On: force la marche pompe
- id: '1611514566689'
  alias: Pool Pump On
  description: ''
  trigger:
  - platform: state
    entity_id: input_select.pool_pump_mode
    to: 'On'
  condition: []
  action:
  - service: homeassistant.turn_on
    data: {}
    entity_id: switch.pool_pump_switch
  mode: single
  • Pool Pump Off: force l’arret pompe
- id: '1611514631258'
  alias: Pool Pump Off
  description: ''
  trigger:
  - platform: state
    entity_id: input_select.pool_pump_mode
    to: 'Off'
  condition: []
  action:
  - service: homeassistant.turn_off
    data: {}
    entity_id: switch.pool_pump_switch
  mode: single
  • Piscine Check pool Pump: appelle service « pool_check » toutes les 5 minutes (modifiable).
- id: '1611568349133'
  alias: Piscine Check pool Pump
  description: ''
  trigger:
  - platform: time_pattern
    minutes: /5
  condition: []
  action:
  - service: pool_pump.check
  mode: single
  • Piscine Check Pool Pump On event: appelle le service « pool_check » si:
    • changement de mode
    • changement de température de l’eau
    • changement d’état de « input_boolean.pool_water_level_critical »- (condition supplémentaire d’arrêt de la pompe que je n’utilise pas à ce jour).
- id: '1611515162753'
  alias: Piscine Check Pool Pump On event
  description: ''
  trigger:
  - platform: homeassistant
    event: start
  - platform: state
    entity_id: sensor.pool_water_temperature
  - platform: state
    entity_id: input_select.pool_pump_mode
  - platform: state
    entity_id: input_boolean.pool_water_level_critical
  condition: []
  action:
  - service: pool_pump.check
  mode: single

Panneau de commande

Je vous propose, pour information, une copie d’écran ainsi que le code associé, de mon panneau de contrôle, libre à vous de l’adapter. Certaines fonctionnalités seront décrites ultérieurement (pression, pH, Appoint eau, etc..).

entities:
  - entity: input_select.pool_pump_mode
    name: Mode de Fonctionnement
  - entities:
      - entity: sensor.pression_piscine_p
        name: Pression
      - entity: sensor.ph_piscine_ph
        name: pH
      - entity: sensor.pool_water_temperature
        name: Eau
      - entity: sensor.vp2_temp_out
        name: Ext
    entity: input_boolean.ouverture_volet_piscine
    icon: 'mdi:chart-bell-curve'
    name: Mesures
    show_state: false
    type: 'custom:multiple-entity-row'
  - entities:
      - entity: pool_pump.next_run_schedule
        name: 'A venir '
      - entity: sensor.heure_pivot_piscine
        name: Heure pivot
    entity: pool_pump.next_run_schedule
    icon: 'mdi:clock'
    name: Tranche horaire
    show_state: false
    type: 'custom:multiple-entity-row'
  - entities:
      - entity: sensor.pool_pump_running_today
        name: Fonct. Jour
      - entity: binary_sensor.pool_pump_running
        name: Etat
    entity: sensor.pool_pump_running_today
    icon: 'mdi:pump'
    name: Pompe Filtration
    show_state: false
    type: 'custom:multiple-entity-row'
  - entities:
      - entity: sensor.pzem_pisc_puissance
        name: Puissance
      - entity: sensor.pzem_pisc_courant
        name: Intensité
    entity: sensor.pzem_pisc_puissance
    icon: 'mdi:flash'
    name: Conso Elec
    show_state: false
    type: 'custom:multiple-entity-row'
  - entities:
      - entity: input_boolean.hors_gel
        name: Hors Gel si actif
    entity: input_boolean.hors_gel
    icon: 'mdi:snowflake-alert'
    name: Hors Gel
    show_state: false
    type: 'custom:multiple-entity-row'
  - entities:
      - entity: cover.volet_piscine
        name: Volet
    entity: cover.volet_piscine
    icon: 'mdi:window-shutter'
    name: Volet piscine
    show_state: false
    type: 'custom:multiple-entity-row'
  - entities:
      - entity: sensor.ev_eau_tps_ouverture_jour
        name: Fonct. jour
      - entity: switch.cde_ev_eau
        name: Cde EV
      - entity: binary_sensor.tp_plein_lsh
        name: Niv H
      - entity: binary_sensor.tp_plein_lsl
        name: Niv B
    entity: input_boolean.ouverture_volet_piscine
    icon: 'mdi:water'
    name: Appoint Eau
    show_state: false
    type: 'custom:multiple-entity-row'
  - entities:
      - label: Filtration
        type: section
      - entity: input_boolean.swimming_season
      - entity: input_number.run_pool_pump_hours_swimming_season
      - entity: input_number.run_pool_pump_hours_off_season
      - label: Commutateurs
        type: section
      - entity: input_boolean.ppe_piscine
        name: Pompe Filtration
      - entity: cover.volet_piscine
        name: Couverture flottante
      - entity: input_boolean.eclairage_piscine
        name: Eclairage
      - entity: switch.cde_traitement
        name: Cde Traitement
      - entity: input_boolean.hors_gel
        name: Hors Gel si Actif
      - entity: input_boolean.ev_eau_piscine
        name: EV Eau appoint en auto si actif
    show_state: false
    head:
      label: PARAMETRES & COMMUTATEURS
      type: section
    padding: 0
    type: 'custom:fold-entity-row'
  - entities:
      - entity: switch.pool_pump_switch
        name: Relais Pompe Filtre
      - entity: switch.cde_traitement
        name: Relais Traitement
      - entity: switch.cde_volet_ouverture
        name: Relais Ouverture Volet
      - entity: switch.cde_volet_fermeture
        name: Relais fermeture Volet
      - entity: switch.cde_eclairage
        name: Relais Eclairage
      - entity: switch.cde_ev_eau
        name: EV Eau
    show_state: false
    head:
      label: COMMANDES DIRECTES
      type: section
    padding: 0
    type: 'custom:fold-entity-row'
style: |
  ha-card {
    border: solid 2px var(--primary-color);
  }
show_header_toggle: false
title: Piscine
type: entities
type: vertical-stack
cards:
  - title: <- 3 jours
    entities:
      - entity: binary_sensor.pool_pump_running
        name: Ppe
      - entity: switch.cde_ev_eau
        name: Ev Eau
    type: history-graph
    hours_to_show: 72
    refresh_interval: 0
  - type: 'custom:mini-graph-card'
    color_thresholds:
      - color: '#039BE5'
        value: 0
      - color: '#0da035'
        value: 5
      - color: '#e0b400'
        value: 10
      - color: '#e45e65'
        value: 20
    show:
      extrema: true
      icon: true
      labels: true
      name: true
      state: true
    hour24: true
    line_width: 2
    points_per_hour: 60
    hours_to_show: 72
    entities:
      - entity: sensor.pool_water_temperature
    name: Temperature Eau 3 J
  - type: 'custom:mini-graph-card'
    color_thresholds:
      - color: '#039BE5'
        value: 0
      - color: '#0da035'
        value: 5
      - color: '#e0b400'
        value: 10
      - color: '#e45e65'
        value: 20
    show:
      extrema: true
      icon: true
      labels: true
      name: true
      state: true
    hour24: true
    line_width: 2
    points_per_hour: 60
    hours_to_show: 72
    entities:
      - entity: sensor.ph_piscine_ph
    name: pH Eau 3 J

Conclusion

J’espère que cet article vous sera utile. C’est le premier d’une série dédiée à la gestion automatisée d’une piscine, si il y a de la demande, je publierai la suite de mes réalisations comme décrit en introduction.

Home Assistant- Optimisation de la base de données

Home Assistant utilise SQLAlchemy , qui est un Object Relational Mapper (ORM). Cela signifie que vous pouvez utiliser n’importe quel backend SQL pour l’enregistreur pris en charge par SQLAlchemy, comme MySQL , MariaDB , PostgreSQL ou MS SQL Server .

Le moteur de base de données par défaut est SQLite qui ne nécessite aucune configuration. La base de données est stockée dans votre répertoire de configuration de Home Assistant (‘/ config /’) et est nommée home-assistant_v2.db.

Afin de simplifier la gestion de la BD et d’améliorer les performances , j’ai choisi d’utiliser MariaDB qui est un système de gestion de base de données édité sous licence GPL et phpmyadmin comme gestionnaire de cette BD.

Mariadb et phpmyadmin sont deux Add-on disponibles sur HA.

Les principaux avantages de cette configuration sont:

  • dans les sauvegardes ou la restitution de « snapshot », vous pouvez traiter séparément la BD diminuant ainsi la taille des sauvegardes
  • les manipulations de la BD sont facilitées par phpmyadmin
  • En profiter pour optimiser la taille de la BD

Avertissements:
Dans cet article je ne traite que de la création et non de la migration de la bd, cette méthode vous permet de relancer votre HA avec une BD vierge.

Comment procéder?

La procédure se décompose en trois étapes:

  • installer l’Add-on mariadb
  • installer l’Add-on phpmyadmin
  • Configurer HA pour qu’il pointe vers cette BD.

1-Installation de l’Add-on mariadb

Tres simple, depuis la boutique des modules supplémentaires (nouvelle appellation de l’Add-on store), choisissez mariadb, puis install.

Une fois installé, cliquez sur configuration et modifier comme-suit:

databases:
  - homeassistant
logins:
  - username: votreusername
    password: votremotdepasse
rights:
  - username: homeassistant
    database: homeassistant

choisissez un mot de passe fort mélangeant minuscules, majuscules, un ou deux chiffres et caractères spéciaux

Je vous conseille de conserver le nom de la db et les droits proposés par défaut.

Cliquer sur start, vérifier votre log, il ne doit pas y avoir d’erreur

Si tout se déroule correctement, vous devriez arriver à ce résultat.

2-Installation de l’Add-on phpmyadmin

Tres simple, depuis la boutique des modules supplémentaires (nouvelle appellation de l’Add-on store), choisissez phpmyadmin, puis install.

L’installation terminée, cocher « Afficher dans la barre latérale », puis cliquez sur Démarrer, aucune configuration requise.

Si tout se déroule correctement, vous devriez arriver à ce résultat.

Sur le panneau latéral, vous pouvez accéder au tableau de bord de phpmyadmin. Vous constaterez sur le panneau gauche, que la base homeassistant a été créé.

Il reste à attribuer les privilèges globaux à votre nom d’utilisateur:

  • sur l’interface phphmyadmin, cliquez sur « comptes utilisateurs », sur « editer les privilèges » de votre nom d’utilisateur, cocher « privileges globaux tout cocher »
Puis cliquer « exécuter » en bas à droite

3-Configuration de HA

Dans le fichier « configuration.yaml », ajouter les commandes suivantes:

recorder:
  db_url: !secret db_mysql
  auto_purge: true
  commit_interval: 15
  include:
    domains:
      - binary_sensor
      - input_boolean
      - input_datetime
      - input_number
      - input_select
      - sensor
      - switch
      - person
      - device_tracker
      - light
  exclude:
    domains:
      - camera
      - zone
      - automation
      - sun
      - weather
      - cover
      - group
      - script
      - pool_pump

Dans votre fichier secrets.yaml, définissez db_url

# Base de données mariadb
db_mysql: mysql://votreusername:votremotdepasse@core-mariadb/homeassistant?charset=utf8mb4

Avec le votreusername et votremotdepasse tel que défini dans la configuration de mariadb.

Les trois options suivantes sont de mon point de vue, elles permettent de limiter la taille de la BD. En effet si vous ne prenez pas de disposition, celle ci va s’accroître indéfiniment et altérer les performances du système.

  • auto_purge: Purge automatiquement la base tous les matins à 04h12 ( heure locale ).
  • purge_keep_days: Indication du nombre de jours d’historique à conserver dans la BD avant la purge ( par défaut 10 ).
  • EXCLUDE et INCLUDE permettent de sélectionner les domaines à exclure ou inclure dans la bd.

La liste des domaines étant propres à chaque installation, vous pouvez en copiant/collant les lignes de code ci-dessous dans « outils de développement/modèles » lister les domaines de votre système et faire votre choix.

{%- set unique_domains = states | map(attribute='domain') |list | unique | list -%}
{%- for domain in unique_domains -%}
- {{domain + "\n"}}
{%- endfor -%}
En exemple la liste de mes domaines

D’autres options sont disponibles, se reporter à la documentation HA.

Une fois ces modifications apportées, vérifier votre configuration et redémarrer HA.

Une notification vous informera d’un problème.

Connecter vous à PHMmyAdmin, visualiser votre BD « home_assistant », HA a automatiquement ajouter les tables et commencent à ajouter des enregistrements.

Conclusion

Cette modification qui est de mon point de vue, indispensable, vous apportera une souplesse d’utilisation dans la gestion de votre bd. Vous pouvez aussi vous intéresser à phpMyAdmin et ses nombreuses possibilités dans la manipulation des bases de données.

Platines de tests pour plaque de prototypage.

Dans le cadre de la mise au point de prototypes, j’utilise régulièrement une plaque de prototypage (breadboard) me permettant de valider le schéma avant de le lancer en fabrication. Cependant le câblage en fils volants peut vite devenir un gros b… source d’erreurs.

Nous sommes souvent amené à utiliser des boutons poussoirs, des led, des relais, des résistances, des fils etc.. avec le risque de créer un court circuit ou des erreurs de câblage, de perdre du temps et du matériel (l’inversion des polarités de l’alimentation est souvent destructrice).

Afin de minimiser ces risques mais aussi de me faciliter la vie j’ai développé deux platines de tests, simples mais efficaces et pratiques.

La platine et son module d’alimentation 12 Vcc -> 3,3/5V

Matériel nécessaire

Platine boutons poussoirs:

Cette platine est équipée de quatre boutons poussoirs, de deux led signalant la présence du 3.3 v et du 5v, des résistances de polarisations, d’un connecteur de sortie, d’un jeu de strap permettant de choisir la polarité utilisée pour le bouton poussoir (3.3 V ou 5V).

Schéma de la platine réalisé sous Eagle

La réalisation de circuit imprimé peut être sous traité, par exemple ou fabriqué soi-même, personnellement j’utilise une petite CNC dédiée à cet usage.

Platine à LEDS

Cette platine est équipée de quatre led raccordées au connecteur 4 pins, de deux led signalant la présence du 3.3 v et du 5v, des résistances de polarisations, d’un connecteur de sortie.

Schéma de la platine réalisé sous Eagle

En conclusion, j’espère que cet article sans prétention vous sera utile, n’hésitez pas à me contacter, je me ferai un plaisir de vous répondre.