F6FCO

Inspiré du projet de F1ATB
Se donner la peine de réaliser une installation photovoltaïque entièrement DIY et redonner gratos le surplus produit à EDF, c'est ballot non ?
La solution: fabriquer un système capable de détecter si on consomme ou produit et utiliser le surplus pour notre usage personnel, un radiateur, une clim, chauffage de piscine, chauffe-eau, etc.
Le projet de F1ATB est ambitieux, découpage pour triac, liaison wi-fi, domotique, visu, etc. Un tel projet est complexe et passionnant à mener pour peu qu'on s'y tienne, pour ma part passionné multi-lièvriste je saute de projet en projet et comme je ne suis pas une IA j'ai une mémoire assez volatile pour ce qui concerne mes anciennes réalisations. J'ai donc voulu un concept le plus simple possible et bien commenté pour pouvoir remettre le nez dedans dans quelques années en cas de maintenance sans m'arracher les cheveux. Mon truc à moi c'est l'assembleur des PIC et j'ai une sainte horreur des langages évolués verbeux et leurs librairies obscures, j'ai donc réécris le code le plus simple possible en C. Pas de wi-fi, pas de visu a part deux leds et juste un relais SSR qui commandera un radiateur l'hiver et une clim l'été.

------------------------------------------------------------------------------ PRINCIPE ------------------------------------------------------------------------------

on prends une image de la tension secteur, du courant, on calcule la puissance, on détermine le sens du courant et on ouvre ou ferme un relais SSR. C'est tout.
L'idée est de mesurer la tension secteur et le courant secteur en entrée de domicile, on calcule le déphasage entre les deux. Si courant et tension sont en phase on sait qu'on est en demande a EDF, si courant et tension sont en opposition de phase on sait qu'on produit trop et qu'on en rejette sur le réseau, et çà c'est ce qu'on veut éviter.
- Pour mesurer la tension on utilise un petit transformateur qui transforme le secteur en basse tension AC genre 6v ou autre (qui délivre en réalité 7.8v), çà dépend de ce qu'on trouve comme transfo abaisseur. Juste par qu'on ne veut pas mettre directement du 230v sur une pin de microcontroleur, l'ADC a ses limites.
- Pour mesurer le courant on utilise une sonde de couplage sur la phase du secteur( une simple pince ampèremetrique), on en extrait le courant divisé par une certaine valeur (100A/50mA dans notre cas), on le mesure aux bornes d'une résistance (burden) pour en extraire la tension résultante. Pareil que pour V ici, le but est d'être dans les clous pour les pins ADC du microcontroleur qui n'accepte entrée que 3.3v maxi.
- ces deux tensions sont envoyées aux bornes ADC du microcontroleur et on calcule la puissance résultante. Pour calculer une puissance on fait P=UI (Puissance=Tension x Intensité), ce qui nous donne une valeur positive. Ici on veut avoir une puissance positive ou négative suivant ce qui entre ou sort, pour connaître le sens du courant. Pour cela on va utiliser une tension de ref qui se situe au centre de la tension admise par le microcontroleur, par exemple 2.5v pour des pins fonctionnant en 5v. L'ESP32 travaillant en 3.3v la ref sera donc de 1.65V.
De P=UI le calcul deviendra P=(I-ref) x (U-ref), ce qui nous calculera une valeur positive ou négative, ce que l'on souhaite.
Par exemple si le courant est en phase avec la tension ils seront tous les deux ensembles en alternance positive ou négative, on aura P positif, ce signifie qu'on tire sur le réseau. Par contre si le courant est en déphasage par rapport a la tension, par exemple quand la tension est en alternance positive le courant sera en alternance négative et vice versa, et cela nous calculera une valeur de puissance négative, ce qui signifie qu'on est en production et qu'on ré-injecte sur le réseau.
Voilà pour le principe.

------------------------------------------------------------------------------ REALISATION ------------------------------------------------------------------------------

Le matos: j'aurai pu utiliser un PIC mais je code en asm, pas envie de me lancer dans une galère en nombres signés. Pour le programmer en C il faudrait installer l'usine a gaz MPLABX que je ne connais pas (et pas envie de connaître). Sur mon PC j'ai déjà VSCode d'installé, à partir de là j'ai hésité entre un arduino dont j'ai un plein tiroir ou un ESP32. Il y avait un ESP32 l'établi ce jour-là, comme quoi çà ne tient pas à grand chose. J'aurai pu utiliser un rapberry PI pico mais il était dans un tiroir, çà m'aurait fait travailler mon python. L'ESP32 fonctionnant en 3.3v j'ai fait un PCB équipé de ponts diviseurs adaptés pour descendre les tensions issues du transfo 7.8v, celle issue de la R courant en 3.3v et la Vref. L'ESP32 commandera un relais SSR sur lequel sera branchée la prise radiateur ou clim.
Pour la partie hard je me suis inspiré du travail de F1ATB mais pas plus suivi ses traces car le cahier des charges est différent. partie soft: son code est très abouti et gère un système domotique, le wi-fi, etc. J'ai tout recodé a ma sauce pour faire plus simple et plus adapté à mes besoins. On mesure 100 échantillons pendant chaque alternance (50Hz=20ms), on calcule la puissance et on fait la moyenne, négative on ouvre le relais, positive on ferme. Deux leds sur le boitier estampillées "EDF" et "PV" indiquent si on est en demande ou en production. J'ai également mis en place un hystérésis pour que le SSR ne se mette pas à danser les jours nuageux et ou on serait sur le fil du rasoir niveau tensions.

------------------------------------------------------------------------------ CODE ------------------------------------------------------------------------------

J'ai intégré dans le code une liaison UART qui renvoie les valeurs V, I, ref 1.65v, état SSR et P, bien pratique pour une maintenance ultérieure. Ces données sont issues de l'ADC sur 12bits, fournies en niveaux 0 à 4096. Après coup j'ai pensé rajouter une visu sur un écran NOKIA 5110 mais le PCB était déjà gravé. Idée à garder pour une éventuelle version V.2. Pour la calibration j'ai utilisé ce que j'avais sous la main, en l'occurence un radiateur électrique de 1500W.

// --- F6FCO Routeur PV juil26 ---
/* =========================================================================
   BLOC 0 : CONSTANTES, BROCHES & VARIABLES GLOBALES
   ========================================================================= */
#include <Arduino.h>

// --- AFFECTATION DES BROCHES ---
#define ADC_REF          35      
#define ADC_V            32      
#define ADC_I            33      
#define RELAY_PIN        4       
#define LED_RED          18      
#define LED_GREEN        19

// --- PARAMETRES D'ECHANTILLONNAGE (Onde 50Hz = 20ms) ---
#define NB_SAMPLES       50      
#define SAMPLE_INTERVAL  400

// --- PARAMETRES DE LISSAGE ET HYSTERESIS ---
#define MACRO_CYCLES     25      // Moyenne sur 25 cycles (500ms)
#define SEUIL_SURPLUS   -200     // Seuil d'activation SSR (Surplus > 200 Watts réels)
#define SEUIL_CONSO       50     // Seuil de coupure SSR (Soutirage > 50 Watts réels)

// --- ETALONNAGE EN WATTS REELS ---
// Ratio calculé avec un radiateur de 1500W (PW_brute 104000 / 1500W)
#define CALIBRATION      69.33

// --- VARIABLES SYSTEME ---
long sum = 0;                    
int compteur_echantillon = 0;    
unsigned long micro_sample = 0;

long macro_sum_pw = 0;           
int macro_compteur = 0;          
long PW_final = 0;               // Puissance finale en WATTS REELS
bool valid_relais = false;

// Variables tampons pour affichage / debug
int last_V = 0, last_I = 0, last_ref = 0;

/* =========================================================================
   BLOC 1 : INITIALISATION HARDWARE (SETUP)
   ========================================================================= */
void Init_Hardware(void) {
    Serial.begin(115200); 
    Serial.println("\n--- ROUTEUR PV V.7 (ETALONNÉ EN WATTS) ---");
    
    pinMode(RELAY_PIN, OUTPUT);
    pinMode(LED_RED, OUTPUT);
    pinMode(LED_GREEN, OUTPUT);
    
    analogSetAttenuation(ADC_11db); 
    analogSetClockDiv(1); 
    
    digitalWrite(LED_RED, HIGH); delay(500); digitalWrite(LED_RED, LOW);
    digitalWrite(LED_GREEN, HIGH); delay(500); digitalWrite(LED_GREEN, LOW);
}

/* =========================================================================
   BLOC 2 : MOTEUR D'ACQUISITION ET CALCUL DE PUISSANCE
   ========================================================================= */
void MesurePuissance(void) {
    unsigned long current_micros = micros();
    
    if (current_micros - micro_sample >= SAMPLE_INTERVAL) {
        micro_sample = current_micros; 
        
        last_V = analogRead(ADC_V);
        last_I = analogRead(ADC_I);
        last_ref = analogRead(ADC_REF);
        
        sum += (long)(last_V - last_ref) * (last_I - last_ref);
        compteur_echantillon++;
        
        if (compteur_echantillon >= NB_SAMPLES) {
            long PW_cycle = sum / NB_SAMPLES;
            
            macro_sum_pw += PW_cycle;
            macro_compteur++;
            
            sum = 0; 
            compteur_echantillon = 0;
            
            if (macro_compteur >= MACRO_CYCLES) {
                // Conversion de la valeur brute en Watts réels
                long PW_brute = macro_sum_pw / MACRO_CYCLES;
                PW_final = PW_brute / CALIBRATION; 
                
                macro_sum_pw = 0;
                macro_compteur = 0;
                valid_relais = true; 
            }
        }
    }
}

/* =========================================================================
   BLOC 3 : LOGIQUE DE COMMANDE (HYSTERESIS SSR ET LEDS)
   ========================================================================= */
void ControleRelais(void) {
    if (PW_final < SEUIL_SURPLUS) {
        digitalWrite(RELAY_PIN, HIGH);   
        digitalWrite(LED_GREEN, HIGH);   
        digitalWrite(LED_RED, LOW);
    } 
    else if (PW_final > SEUIL_CONSO) {
        digitalWrite(RELAY_PIN, LOW);    
        digitalWrite(LED_GREEN, LOW);
        digitalWrite(LED_RED, HIGH);     
    }
}

/* =========================================================================
   BLOC 4 : BOUCLE PRINCIPALE (MAIN)
   ========================================================================= */
void setup() {
    Init_Hardware();
    micro_sample = micros(); 
}

void loop() {
    MesurePuissance();
    
    if (valid_relais) {
        ControleRelais();
        
        Serial.print("V(32):"); Serial.print(last_V);
        Serial.print(" | I(33):"); Serial.print(last_I);
        Serial.print(" | Ref(35):"); Serial.print(last_ref);
        Serial.print(" | SSR:"); Serial.print(digitalRead(RELAY_PIN));
        Serial.print(" | WATTS:"); Serial.println(PW_final);           
        
        valid_relais = false; 
    }
}

------------------------------------------------------------------------------ Premiers tests sur table ------------------------------------------------------------------------------

Concluants, on voit bien les fluctuations de V quand le programme prélève un échantillon sur la sinusoïde du secteur (à travers le transfo 7.8v), P indique bien la conso ici testée avec juste un radiateur électrique estampillé 1500W.
Pour valider la consommation secteur ou la réinjection j'ai juste changé le sens de pinçage du capteur sur le fil d'alim du radiateur. Résultats receuillis sur la liaison UART:

Ici on consomme du réseau, puissance positive, relais SSR fermé

Ici on est en production avec les PV, puissance négative, relais SSR ouvert:

Routeur photovoltaïque