Gestion WIFI d’un régulateur de charge solaire Epever

Le but de cet article n’est pas de détailler l’installation elle même mais de décrire un petit script Python sur Raspberry qui permet à distance de rapatrier en temps réel l’état de l’installation solaire.

La société chinoise Epever fournit une gamme de régulateurs solaires MPPT (Maximum Power Point Tracking), cette classe de régulateur à ne pas confondre avec l’ancienne génération PWM (Pulse Width Modulation) fournit à la batterie du système solaire le maximum possible d’énergie, en fournissant jusqu’à 30 % de rendement supplémentaire par rapport à un régulateur PWM. Ma petite installation solaire se situe dans une cabane de jardin contiguë à la maison et de ce fait accessible par le réseau WIFI, elle se compose d’un panneau solaire photovoltaïque de 100 W suivi du présent régulateur de charge (disponible un peu partout sur les plateformes de vente Internet) ainsi que d’une batterie au plomb de 22 Ah.

Un Raspberry zero W (avec WIFI) est alimenté par l’installation et est connecté au régulateur.

Le régulateur solaire Epever que l’on trouve facilement sur toutes les plateformes ayant trait à la génération photovoltaïque, prix de l’ordre de 60 € pour un courant max de 10 A.
Le détail des raccordements

La connexion au Raspberry s’effectue en RS-485 via un convertisseur RS-485 USB par le port de communication situé en bas à droite du régulateur, cette connexion utilise une prise RJ-45.

Adaptateur USB / RS-485 disponible également sur Amazon, prix de l’ordre de 10 €

Je passe sur les raccordements entre le régulateur et le convertisseur, il s sont suffisamment explicites et se réalisent avec du fil de câblage basique, le bus RS-485 étant un bus industriel de terrain qui ne craint ni la longueur ni les milieux parasités.

Le script Python s’appuie sur la bibliothèque pymodbus

https://pypi.org/project/pymodbus/

Ainsi que sur la lecture des registres pertinents du régulateur Epever

# Tableau.py
import os

from pymodbus.client.sync import ModbusSerialClient as ModbusClient
from time import sleep

client = ModbusClient(method = 'rtu', port = '/dev/ttyUSB0', baudrate = 115200)
client.connect()

while True:

	Tension_panneau = float(client.read_input_registers(0x3100,1,unit=1).registers[0] / 100.0)
	Courant_panneau = float(client.read_input_registers(0x3101,1,unit=1).registers[0] / 100.0)
	chargeCurrent = float(client.read_input_registers(0x3100,6,unit=1).registers[5] / 100.0)
	Tension_sortie = float(client.read_input_registers(0x310c,1,unit=1).registers[0] / 100.0)
	Courant_sortie  = float(client.read_input_registers(0x310d,1,unit=1).registers[0] / 100.0)
	Temperature_batterie = float(client.read_input_registers(0x3110,1,unit=1).registers[0] / 100.0)
	Temperature_regulateur = float(client.read_input_registers(0x3111,1,unit=1).registers[0] / 100.0)
	Charge_batterie = float(client.read_input_registers(0x311a,1,unit=1).registers[0] / 100.0)
	
	os.system('clear')
    
	print "Tension panneau", Tension_panneau, "V"
	print "Courant panneau", Courant_panneau,"A"
	print "Courant de charge batterie", chargeCurrent, "A"
	print "Tension de sortie", Tension_sortie, "V"
	print "Courant sortie", Courant_sortie, "A"   
	print "Puissance consommee", Tension_sortie * Courant_sortie, "W"
	print "Charge batterie", Charge_batterie * 100, "%"       
	print "Temperature batterie", Temperature_batterie, "Degres"
	print "Temperature regulateur", Temperature_regulateur, "Degres"
	
	sleep(1)

client.close()

Le Raspberry PI Zero WIFI est alimenté en 5 volts via un Buck Down Converter qui permet d’ajuster de façon précise la tension de 5 V destinée au Raspberry avec un rendement proche de 90 % (fondamental dans une installation solaire)

Un Buck Step Down Converter, prix de l’ordre de 5 €

La lecture des paramètres s’effectue en SSH en lançant le script Python depuis une console Linux en mode SSH « Python Tableau.py », la mise à jour se fait toutes les secondes et donne le résultat suivant :

Tension panneau 43.62 V
Courant panneau 0.04 A
Courant de charge batterie 0.13 A
Tension de sortie 14.04 V
Courant sortie 0.09 A
Puissance consommee 1.2636 W
Charge batterie 100.0 %
Temperature batterie 14.49 Degres
Temperature regulateur 19.39 Degres

Bien entendu il est possible de (beaucoup) développer ce script pour en obtenir de plus riches enseignements (valeurs moyennes, courbes de charge / décharge, enregistrements, commandes, etc…)

Adaptation microphone XLR bon marché sur socle pour équaliseur UR6QW branché sur transceiver ICOM.

Petite description sans prétention de montage sur pied d’un microphone XLR avec commandes traditionnelles UP / DOWN, PTT / PTT Lock.

Cette idée m’est venue après avoir fait l’acquisition d’un équaliseur UR6QW.

Site du constructeur ukrainien : https://ur6qw.jimdofree.com/

Les essais avec un microphone typiquement radioamateur (essais faits avec un SM-20) n’ont pas donné de bon résultats, en revanche un microphone Behringer Electrovoice XM8500 ont donné d’excellents résultats. D’où l’idée de l’utiliser sur un socle équipé des traditionnels boutons poussoir. Au passage, d’autres essais ont été faits avec d’autres microphones à bas prix et ont donnés les mêmes résultats. Pour indication le microphone utilisé se trouve aux environs de 12 € sur la plateforme américaine bien connue.

Aucune difficulté particulière de réalisation.

Cet appareil n’est pas indispensable mais permet beaucoup plus facilement que l’utilisation des menus et sous-menus des transceivers actuels d’obtenir le type de modulation souhaitée, que ce soit en BLU ou en FM. Il existe de nombreux modèles sur le site du constructeur.

Le schéma

Le condensateur de 10 micro Farads est nécessaire pour annuler la composante continue de quelques Volts qui est délivrée par la broche 1 du connecteur 8 broches des transceivers ICOM. Cette tension continue est nécessaire pour alimenter les microphones électret fournis par Icom, elle ne sert à rien dans le cas de l’utilisation d’un microphone dynamique si ce n’est à détériorer le microphone.

Quelques détails intérieurs

En résumé et au vu des rapports d’écoute on peut se poser légitimement la question de se procurer un microphone de marque seul (qui peut couter for cher) ou bien d’utiliser ce type d’équipement qui offre bien plus de souplesse et de possibilités pour un prix identique voire inférieur au total. Bien sûr pour ceux qui attachent beaucoup d’importance au look il est clair que le design esthétique du support de microphone est discutable mais on doit pouvoir faire mieux.

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