- Choisir les bons composants pour le moniteur d'énergie solaire compatible IoT
- Schéma de circuit pour la surveillance de l'énergie solaire basée sur l'IoT
- Configuration de ThingSpeak
- Code Arduino pour la surveillance de l'énergie solaire à l'aide d'ESP32
- Test et surveillance des données
Dans le domaine des énergies renouvelables, l'énergie solaire est à l'avant-garde, car produire de l'énergie en utilisant la puissance du soleil est le moyen le plus simple et commercialement viable d'énergie renouvelable. En parlant de panneaux solaires, la puissance de sortie d'un panneau solaire doit être surveillée afin d'obtenir une puissance de sortie optimale des panneaux. C'est pourquoi un système de surveillance en temps réel devient nécessaire. Dans une grande centrale solaire, il peut également être utilisé pour surveiller la puissance de sortie de chaque panneau, ce qui permet d'identifier l'accumulation de poussière. Il empêche également toute condition de défaut pendant le temps de fonctionnement. Dans certains de nos articles précédents, nous avons construit quelques projets liés à l'énergie solaire comme un chargeur de téléphone portable à énergie solaire et un circuit d'onduleur solaire, etc. Vous pouvez les consulter si vous recherchez plus de projets sur l'énergie solaire.
Dans ce projet, nous allons créer un système de surveillance de l'énergie solaire basé sur l'IoT en incorporant la technique de charge de la batterie basée sur MPPT (Maximum Power Point Tracker), qui aidera à réduire le temps de charge et à améliorer l'efficacité. En outre, nous mesurerons la température du panneau, la tension de sortie et le courant pour améliorer l'aspect sécurité du circuit. Enfin, pour couronner le tout, nous allons utiliser les services cloud ThingSpeak pour surveiller les données de sortie de n'importe où dans le monde. Notez que ce projet est une continuation du projet MPPT Solar Charge Controller que nous avons construit précédemment. Ici, nous surveillerons la tension de sortie, le courant et la puissance du panneau à l'aide de la carte de développement ESP32 IoT.
Choisir les bons composants pour le moniteur d'énergie solaire compatible IoT
Avec un moniteur solaire, il devient très facile de surveiller et de détecter les défauts dans n'importe quel système solaire. C'est pourquoi la sélection des composants devient un élément très important lors de la conception d'un tel système. Ci-dessous, la liste des pièces que nous avons utilisées.
- Carte de développement ESP32
- Circuit MPPT (peut être n'importe quel circuit solaire)
- Une résistance shunt (par exemple 1 Ohm 1 Watt - convient jusqu'à 1 A de courant)
- Une batterie au lithium (7,4 V de préférence).
- Connexion Wi-Fi active
- Capteur de température pour le panneau solaire
- Circuit diviseur de tension (voir la description)
Carte de développement Esp32:
Pour une application compatible IoT, il est essentiel de choisir le bon type de carte de développement qui sera capable de traiter les données de ses broches analogiques et d'envoyer les données via tout type de protocole de connexion tel que le Wi-Fi ou vers le cloud. serveur. Nous avons spécifiquement sélectionné ESP32 car il s'agit d'un microcontrôleur à faible coût avec des tonnes de fonctionnalités. En outre, il dispose d'une radio Wi-Fi intégrée grâce à laquelle nous pouvons nous connecter très facilement à Internet.
Circuit solaire:
Un circuit de charge solaire est un circuit qui obtient une tension plus élevée du panneau solaire et le convertit en une tension de charge afin qu'il puisse charger efficacement la batterie. Pour ce projet, nous utiliserons le circuit imprimé de contrôleur de charge MPPT basé sur LT3562 que nous avons déjà réalisé dans l'un de nos projets précédents. Mais si vous souhaitez intégrer cette surveillance d'activation IoT, vous pouvez utiliser n'importe quel type de circuit solaire. Nous avons choisi cette carte car le circuit est équipé du suivi du point de puissance maximale (MPPT), ce qui est bénéfique pour les projets de panneaux solaires à faible puissance. C'est un moyen efficace de charger une petite batterie au lithium à partir d'un panneau solaire.
Résistance shunt:
Toute résistance suit la loi de l'ohm, ce qui signifie que si une certaine quantité de courant traverse la résistance, une certaine quantité de chute de tension apparaîtra. Les résistances shunt ne font pas exception à cette règle et sont spécifiquement utilisées pour mesurer le flux de courant. Cependant, en fonction du courant nominal circulant à travers le panneau solaire, choisissez une résistance shunt qui produira une quantité de tension adéquate qui peut être mesurée par l'unité de microcontrôleur. Mais, en même temps, la puissance de la résistance est également une chose importante. Le choix de la puissance de la résistance shunt est également important.
La chute de tension peut être calculée à l'aide de la formule ci-dessous. C'est ce qu'on appelle la loi d'Ohm-
V = I x R
V est la tension qui sera produite pendant «I», c'est-à-dire la quantité de courant circulant à travers la quantité de résistance «R». Par exemple, une résistance de 1 ohm produira 1 V de chute de tension lorsque 1 A de courant la traverse.
Pour la puissance de la résistance, la formule donnée ci-dessous peut être utilisée -
P = I 2 R
Où I est le flux de courant maximal et R est la valeur de la résistance. Pour 1 A de courant avec une résistance de 1 Ohms, 1 watt est suffisant pour la dissipation de puissance. Cependant, cela est utile pour les petits projets de panneaux solaires mais pas du tout adapté aux applications liées au réseau solaire. Dans un tel cas, la technique de mesure du courant non invasive est en fait ce qui doit être utilisé. Dans un tel cas, le flux de courant peut être mesuré avec précision là où une très faible quantité de courant, ainsi qu'une très grande quantité de courant, peuvent être mesurées.
Batterie au lithium:
Le choix de la batterie au lithium est une partie essentielle de tout projet impliquant des panneaux solaires. Parce que l'unité de microcontrôleur qui reste toujours allumée et vérifie et soumet constamment les données nécessite au moins cent milliampères de courant pour un fonctionnement stable.
La capacité de la batterie doit être quelque chose qui peut alimenter le microcontrôleur pendant au moins 4 à 5 jours lorsque le soleil ne brille pas à cause de la mousson. Il est également important que le courant de charge soit supérieur au courant de charge du point de vue de la batterie. Il est assez inhabituel si quelqu'un connecte 100 mA de charge avec une batterie et fournit un courant de charge inférieur à cela. Pour être plus sûr, nous devrions avoir au moins 5 fois plus de courant de charge que le courant de charge.
D'un autre côté, la tension de la batterie doit être supérieure à toute tension d'entrée habituelle du régulateur de tension requise pour le microcontrôleur. Par exemple, une batterie au lithium de 7,4 V peut être connectée à travers un régulateur de tension linéaire 3,3 V et 5,0 V (car le régulateur linéaire nécessite une tension de chute plus élevée que le LDO et la commutation.)
Dans notre projet, nous avons utilisé une batterie de 4000 mAH avec une cote de 7,4 V. Nous avons utilisé un régulateur 5.0V qui fournit une sortie de courant et de tension suffisante pour l'ESP32.
Diviseur de tension:
Un diviseur de tension est une partie essentielle de la mesure de la tension du panneau solaire. Il faut choisir un diviseur de tension qui divisera la tension selon l'entrée de tension d'E / S du microcontrôleur.
Choisissez les résistances ci-dessus de manière à ce que la tension de sortie du diviseur de tension ne dépasse pas la tension d'E / S maximale du microcontrôleur (3,3 V pour ESP32). Cependant, il est conseillé d'utiliser un potentiomètre car il offrira la flexibilité de choisir n'importe quel panneau solaire de tension nominale supérieure ou inférieure et peut facilement régler la tension à l'aide d'un multimètre.
Dans notre cas, nous avons un potentiomètre dans le circuit de la carte MPPT qui agit comme un diviseur de tension. Nous réglons le diviseur de tension avec un facteur de division de 6V. Nous avons connecté deux multimètres, un dans l'entrée et un autre dans la sortie du pot, et avons défini la valeur selon laquelle lorsque la tension d'entrée est de 18 V, la sortie sera de 3 V puisque la tension de sortie nominale du panneau solaire est de 18 V.
Capteur de température pour le panneau solaire:
La puissance de sortie du panneau solaire a un lien direct avec la température du panneau solaire. Pourquoi? Parce qu'à mesure que la température d'un panneau solaire commence à augmenter, le courant de sortie du panneau solaire augmente de manière exponentielle tandis que la tension de sortie commence à diminuer de manière linéaire.
Selon la formule de puissance, la puissance est égale à la tension multipliée par le courant (W = V x A), la diminution de la tension de sortie diminue également la puissance de sortie du panneau solaire même après l'augmentation du flux de courant. Maintenant, la question suivante qui nous vient à l'esprit est: comment mesurer la température solaire? Eh bien, c'est plutôt intéressant car les panneaux solaires sont généralement exposés à la chaleur car ils sont exposés à la lumière directe du soleil et pour des raisons évidentes. La meilleure façon de mesurer la température du panneau solaire est d'utiliser un capteur de température à surface plane. Il est également suggéré d'utiliser un thermocouple de type K placé directement dans le panneau solaire.
Pour notre application, nous avons utilisé un module de capteur de température basé sur une thermistance, illustré ci-dessous.
Schéma de circuit pour la surveillance de l'énergie solaire basée sur l'IoT
Le schéma de circuit complet du moniteur d'énergie solaire compatible IoT est illustré ci-dessous. Le schéma est simple. Le tableau de bord rouge est le tableau MPPT que nous avons utilisé pour ce projet.
Configuration de ThingSpeak
Créez un compte avec ThingSpeak et allez dans l' option «ma chaîne», puis cliquez sur Nouvelle chaîne.
Créez un nouveau canal avec les noms de champ.
Maintenant, après avoir défini le champ, accédez au champ Clés API où la clé API d'écriture est disponible. Cette clé doit être fournie dans le code ainsi que l'ID de canal.
L'adresse de ThingSpeak se trouve sur la même page.
Avec les étapes ci-dessus, vous pouvez configurer ThingSpeak très facilement. Si vous souhaitez en savoir plus sur ThingSpeak et son processus de configuration, vous pouvez consulter nos articles précédents sur le sujet.
Code Arduino pour la surveillance de l'énergie solaire à l'aide d'ESP32
Le code complet de surveillance de l'énergie solaire ESP32 se trouve au bas de cette page. Le code commence par définir votre SSID, votre mot de passe et quelques autres paramètres constants comme indiqué ci-dessous.
// définir le WiFi SSID et PWD pour la liaison montante. #define WLAN_SSID "xxxx" #define WLAN_PASS "xxxxxxxxxx"
// résistance à 25 degrés C #define THERMISTORNOMINAL 10000 // temp. pour la résistance nominale (presque toujours 25 C) #define TEMPERATURENOMINAL 25 // Le coefficient bêta de la thermistance (généralement 3000-4000) #define BCOEFFICIENT 3950 // la valeur de `` l'autre '' résistance #define SERIESRESISTOR 10000
Les ohms nominaux de la thermistance sont fournis à la température nominale. Réglez cette valeur en fonction de la fiche technique de la thermistance. Mettez le coefficient Bêta et la valeur de résistance série de la thermistance.
// définir Analogique pour le courant et la tension const int curr_an_pin = 35; const int volt_an_pin = 34; const int ntc_temp_an_pin = 33;
Les codes PIN sont définis ici.
#define thingSpeakAddress "xxxxxxxxx" #define channelID xxxxx #define writeFeedAPIKey "xxxxxxx" #define readFeedAPIKey "xxxxxxx" #define readFieldAPIKey "xxxxxxxx" #define readStatusAPIKey "xxxxxxx"
Mettez le thingSpeakAddress, channelID, Write Feed API Key. Le reste n'est pas obligatoire mais reste utile si des données doivent être reçues du Web.
void setup () { // mettez votre code de configuration ici, à exécuter une fois: // définissez le port série sur 115200 Serial.begin (115200); // Initialise le délai série (1000); WiFi.mode (WIFI_STA); ThingSpeak.begin (client); // Initialiser ThingSpeak // todo: créer une tâche pour lire une broche pour obtenir le courant et la tension et calculer le watt et la température du panneau solaire xTaskCreate ( wifi_task, / * Task function. * / "Wifi_task", / * Chaîne avec le nom de task. * / 1024 * 2, / * Taille de la pile en octets. * / NULL, / * Paramètre passé en entrée de la tâche * / 5, / * Priorité de la tâche. * / NULL); / * Poignée de tâche. * / Serial.print ("Lecture de données."); }
Dans le code ci-dessus, le serveur ThingSpeak est initialisé et une tâche est créée qui obtiendra les données liées au panneau solaire.
Dans la boucle principale, le courant et la tension solaires sont détectés via une broche analogique et la moyenne est effectuée.
float solar_curr_adc_val = 0; float solar_volt_adc_val = 0; pour (i = 0; i <NUMSAMPLES; i ++) { curr_samples = analogRead (curr_an_pin); volt_samples = analogRead (volt_an_pin); temp_samples = analogRead (ntc_temp_an_pin); retard (10); } // fait la moyenne de tous les échantillons sur float curr_avg = 0; float volt_avg = 0; float temp_avg = 0; pour (i = 0; i <NUMSAMPLES; i ++) { curr_avg + = curr_samples; volt_avg + = volt_samples; temp_avg + = échantillons_temp; } curr_avg / = NUMSAMPLES; volt_avg / = NUMSAMPLES; temp_avg / = NUMSAMPLES; //Serial.print("ADC VALUE = "); //Serial.println(ADC_VALUE); // convertit la valeur adc en tensions pour obtenir le courant et la tension réels. float solar_curr = (curr_avg * 3.3) / (4095); float solar_volt = (volt_avg * 3.3) / (4095); // en utilisant un diviseur de tension, nous abaissons la tension réelle. // pour cette raison, nous multiplions le 6 par la tension moyenne pour obtenir la tension réelle du panneau solaire. Solar_volt * = 6;
La tension solaire est soumise en multipliant par 6 lorsque nous avons créé le diviseur de tension qui divisera la tension d'entrée par 6 fois.
La température est générée à partir de la thermistance en utilisant une formation logarithmique.
// convertit la valeur en résistance temp_avg = 4095 / temp_avg - 1; temp_avg = SERIESRESISTOR / temp_avg; //Serial.print("Thermistor resistance "); //Serial.println(temp_avg); float steinhart; steinhart = temp_avg / THERMISTORNOMINAL; // (R / Ro) steinhart = log (steinhart); // ln (R / Ro) steinhart / = BCOEFFICIENT; // 1 / B * ln (R / Ro) steinhart + = 1,0 / (TEMPERATURENOMINAL + 273,15); // + (1 / À) steinhart = 1.0 / steinhart; // Inverser steinhart - = 273,15; // convertit la température absolue en C
Les données sont lues toutes les 15 secondes.
retard (1000); count ++; Serial.print ("."); si (nombre> = 15) { nombre = 0; Serial.println ("============================================= ============================= "); Serial.print ("Solar Voltage ="); Serial.println (solar_volt); Serial.print ("Courant solaire ="); Serial.println (solar_curr); float solar_watt = solar_volt * solar_curr; Serial.print ("Solar Watt ="); Serial.println (solar_watt); Serial.print ("Solar Temperature ="); Serial.println (steinhart); Serial.println ("============================================= ============================= ");
Les données des champs respectifs sont transmises à l'aide de la fonction Thing.Speak.setField (); lorsque le WiFi est connecté.
if (WiFi.status () == WL_CONNECTED) { ThingSpeak.setField (1, solar_volt); ThingSpeak.setField (2, solar_curr); ThingSpeak.setField (3, solaire_watt); ThingSpeak.setField (4, steinhart); // écrire dans le canal ThingSpeak int x = ThingSpeak.writeFields (channelID, writeFeedAPIKey); if (x == 200) { Serial.println ("Mise à jour des canaux réussie."); } else { Serial.println ("Problème de mise à jour du canal. Code d'erreur HTTP" + String (x)); } } else { Serial.println ("\ r \ n ################################### ###################### "); Serial.println ("Impossible de mettre à jour les données sur le serveur thingSpeak."); Serial.println ("WiFi non connecté…"); Serial.println ("########################################## ############### \ r \ n "); } Serial.print ("Lecture de données."); } }
La tâche Wi-Fi créée dans l'extrait de code ci-dessous-
void wifi_task (void * paramètre) { while (1) { if (WiFi.status ()! = WL_CONNECTED) { Serial.print ("Tentative de connexion au SSID:"); Serial.println (WLAN_SSID); while (WiFi.status ()! = WL_CONNECTED) { WiFi.begin (WLAN_SSID, WLAN_PASS); // Se connecter au réseau WPA / WPA2. Modifiez cette ligne si vous utilisez un réseau ouvert ou WEP Serial.print ("."); retard (5000); } Serial.println ("\ nConnecté."); Serial.println (); Serial.println ("WiFi connecté"); Serial.println ("Adresse IP:"); Serial.println (WiFi.localIP ()); } vTaskDelay (1000 / portTICK_PERIOD_MS); } vTaskDelete (NULL); }
Test et surveillance des données
Le panneau solaire est connecté au circuit et placé à la lumière du soleil pour les tests comme indiqué ci-dessous.
Le fonctionnement complet est démontré dans la vidéo ci-dessous. Notre circuit a pu lire la tension de sortie, le courant et la puissance du panneau et le mettre à jour en direct sur le canal Thingspeak comme indiqué ci-dessous.
Comme nous pouvons le voir, les données de 15 minutes sont affichées dans le graphique ci-dessus. Comme il s'agit d'un projet d'exploitation à l'extérieur, un PCB approprié avec une boîte fermée doit être utilisé. L'enceinte doit être réalisée de manière à ce que le circuit reste étanche à la pluie. Pour modifier ce circuit ou pour discuter d'autres aspects de ce projet, veuillez utiliser le forum actif de Circuit Digest. J'espère que vous avez apprécié le tutoriel et appris quelque chose d'utile.