Bien amélioré mon algo de mesure de la puissance produite, cela marche bien et c'est assez stable :-)

Mesures/solar_pv_energy/0_get_energy.lua

@@ -1,51 +1,56 @@
 -- Lit le convertisseur ADC pour mesurer le courant électrique de l'installation PV
-print("\n 0_get_energy.lua zf190909.0021 \n")
+print("\n 0_get_energy.lua zf190910.0108 \n")
 
--- Astuce de mesure, on lit l'adc toutes les 21ms, soit 47.6x par seconde
--- comme l'alternance fait 20ms, on balaye (déphasage) statistiquement l'aleternance
--- ce qui nous permet d'estimer une valeur moyenne du courant
+-- Astuce de mesure:
+-- on lit l'adc toutes les 11ms, soit 91x par seconde
+-- comme l'alternance fait 20ms, on balaye (déphasage) statistiquement l'alternance
+-- on redresse l'alternance par rapport à la masse fictive (env 0.5)
+-- ce qui nous permet d'estimer une valeur RMS du courant
 -- quelque soit sa forme !
--- toutes les 2 secondes on remet à zéro les minima et maxima
-
-zadc_min=1024   zadc_max=0
+-- on le fait sur 2.1 secondes avec une moyenne glissante sur 3 valeurs
 
+zadc_min=1024   zadc_max=0   zadc_sum=0   znb_adc=0
 
 if adc.force_init_mode(adc.INIT_ADC)
 then
-  node.restart()
-  return -- don't bother continuing, the restart is scheduled
+    node.restart()
+    return
 end
 
-tmr_clr_rms=tmr.create()
-tmr_clr_rms:alarm(2*1000,  tmr.ALARM_AUTO, function()
-    clr_rms()
+tmr_read_adc=tmr.create()
+tmr_read_adc:alarm(11, tmr.ALARM_AUTO, function()
+    read_adc()
 end)
 
-tmr_mes_adc=tmr.create()
-tmr_mes_adc:alarm(21,  tmr.ALARM_AUTO, function()
-    get_adc()
+tmr_calc_rms=tmr.create()
+tmr_calc_rms:alarm(2.1*1000, tmr.ALARM_AUTO, function()
+    calc_rms()
 end)
 
-function get_adc()
-    zadc=0   znb=3
-    for i=1,znb do zadc=zadc+adc.read(0) end
-    zadc=math.floor(zadc/znb)
+function read_adc()
+    zadc=adc.read(0)
     if zadc<=zadc_min then zadc_min=zadc end
     if zadc>=zadc_max then zadc_max=zadc end
+    zadc=zadc-zadc_offset
+    if zadc<=0 then zadc=zadc*-1 end
+    zadc_sum=zadc_sum+zadc   znb_adc=znb_adc+1
 end
 
-zrms_offset=12
-zpow_cal=411
-zadc_cal=336
+zadc_offset=548
+zpow_cal=409
+zadc_cal=192
+zadc_err=-4
 
-function clr_rms()
-    zadc_rms0=zadc_max-zadc_min
-    zadc_rms=zadc_rms0-zrms_offset
+za1=0   za2=0   za3=0
+
+function calc_rms()
+    zadc_rms=math.floor(zadc_sum/znb_adc)+zadc_err
+
+    za1=za2   za2=za3   za3=zadc_rms  zadc_rms=math.floor((za1+za2+za3)/3)
+    
     if zadc_rms<=0 then zadc_rms=0 end
-    zpower=math.floor(zadc_rms*zpow_cal/zadc_cal)
-    print(zadc,zadc_min,zadc_max,zadc_rms0,zadc_rms,zpower.."W")
-    zadc_min=1024   zadc_max=0
+    zadc_offset=math.floor((zadc_min+zadc_max)/2)
+    zpower=math.floor(zadc_rms*zpow_cal/zadc_cal)    
+    print(zadc_min,zadc_max,zadc_offset,zadc_rms,zpower.."W")
+    zadc_min=1024   zadc_max=0   zadc_sum=0   znb_adc=0
 end
-
-
-

Mesures/solar_pv_energy/README.md

@@ -37,8 +37,11 @@ Toutes les fonctions sont bien séparées dans des scripts, ce qui facilite la p
 
 ## Astuces de mesures
 
-Dans ce projet il y a 1x NodeMCU qui mesure la production électrique de mon installation solaire PV. En en mesurant le courant (avec le petit transformateur de courant 1/800 connecté sur un fil) injecté dans le réseau électrique de ma maison. Grâce aux deux minis onduleurs qui convertissent la basse tension (36V) des panneaux PV en 220V du réseau électrique.
-Le calcul de conversion tension/courant mesurée est très simpliste, un simple ```P=U*I*cos(phy)```. On ne tient pas du tout compte ici du ```cos(phy)`` qui pourrait varier en fonction des charges inductives dans la maison !
+Dans ce projet il y a 1x NodeMCU qui mesure la production électrique de mon installation solaire PV. On mesure le courant injecté dans le réseau électrique de la maison avec un petit transformateur de courant 1/800 *clipsé* sur la phase de l'onduleur.
+Comme le convertisseur ADC du NodeMCU ne peut mesurer que des valeurs positives comprises entre 0V et 1V, on ajoute une masse fictive au signal du transformateur de courant de 0.5V afin de *remonter* l'alternance négative.
+De plus, on lit l'ADC toutes les 11ms, soit 91x par seconde. Comme l'alternance fait 20ms, on balaye (déphasage) statistiquement l'alternance. On redresse l'alternance négative par rapport à la masse fictive, ce qui nous permet de mesurer une valeur RMS du courant quelque soit sa forme !
+On le fait toutes les 2.1 secondes avec une moyenne glissante sur 3 valeurs.
+Le calcul de la puissance mesurée est très simpliste, un simple ```P=U*I```. On ne tient pas compte ici du ```cos(phy)`` qui pourrait varier en fonction des charges inductives dans la maison !
 
 
 
@@ -130,7 +133,7 @@ Seulement la corrélation entre les trois température
 https://thingspeak.com/apps/plugins/300559
 
 
-zf190908.2245
+zf190909.0119
 
 
 pense bête: