COMPTEUR D'ÉNERGIE ARDUINO : 10 étapes (avec photos)

2024 Auteur: John Day | [email protected]. Dernière modifié: 2024-01-30 09:08

[Lire la vidéo]

J'appartiens à un village d'Odisha, en Inde, où les coupures de courant fréquentes sont très courantes. Il entrave la vie de chacun. Pendant mon enfance, continuer mes études après la tombée de la nuit était un vrai défi. En raison de ce problème, j'ai conçu un système solaire pour ma maison à titre expérimental. J'ai utilisé un panneau solaire de 10 Watt, 6V pour allumer quelques LED lumineuses. Après avoir affronté de nombreuses difficultés, le projet a été couronné de succès. Ensuite, j'ai décidé de surveiller la tension, le courant, la puissance et l'énergie impliqués dans le système. Cela a amené l'idée de concevoir un ENERGY METER. J'ai utilisé ARDUINO comme cœur de ce projet car il est très facile d'écrire du code dans son IDE et il existe un grand nombre de bibliothèques open source disponibles sur Internet qui peuvent être utilisées selon le exigence. J'ai expérimenté le projet pour un système solaire de très petite taille (10 watts), mais cela peut être facilement modifié pour être utilisé pour un système de notation plus élevé.

Vous pouvez retrouver tous mes projets sur:

Caractéristique: Surveillance de l'énergie par écran 1. LCD 2. via Internet (téléchargement Xivement) 3. Enregistrement des données sur une carte SD

Vous pouvez voir mon nouveau contrôleur de charge solaire ARDUINO MPPT instructable (Version-3.0)

Vous pouvez également voir mes autres instructables sur

CONTRLEUR DE CHARGE SOLAIRE ARDUINO (Version 2.0)

CONTRLEUR DE CHARGE SOLAIRE ARDUINO (Version-1)

Étape 1: Pièces requises:

1. ARDUINO UNO (Amazon)2. BOUCLIER ETHERNET ARDUINO (Amazon)

3. Écran LCD 16x2 CARACTÈRES (Amazon)

4. CAPTEUR DE COURANT ACS 712 (Amazon)4. RESISTANCES (10k, 330ohm) (Amazon)5. POTENTIOMÈTRE 10K (Amazon)6. FILS DE CAVALIER (Amazon)7. CÂBLE ETHERNET (Amazon)8. PLANCHE À PAIN (Amazon)

Étape 2: Puissance et énergie

Puissance: La puissance est le produit de la tension (volt) et du courant (Amp) P=VxI L'unité de puissance est le watt ou l'énergie KW: l'énergie est le produit de la puissance (watt) et du temps (heure) E= Pxt L'unité d'énergie est le watt-heure ou le kilowatt Heure (kWh) D'après la formule ci-dessus, il est clair que pour mesurer l'énergie, nous avons besoin de trois paramètres 1. Tension 2. Courant 3. Temps

Étape 3: mesure de la tension

La tension est mesurée à l'aide d'un circuit diviseur de tension. Comme la tension d'entrée de la broche analogique ARDUINO est limitée à 5V, j'ai conçu le diviseur de tension de manière à ce que la tension de sortie soit inférieure à 5V. Ma batterie est utilisée pour stocker le la puissance du panneau solaire est évaluée à 6v, 5,5Ah. Je dois donc réduire ce 6,5v à une tension inférieure à 5V. J'ai utilisé R1=10K et R2 =10K. La valeur de R1 et R2 peut être inférieure, mais le problème est que lorsque la résistance est faible, le courant est plus élevé, ce qui entraîne une grande quantité d'énergie (P = I^2R) dissipée sous forme de chaleur. Une valeur de résistance différente peut donc être choisie, mais il faut veiller à minimiser la perte de puissance à travers la résistance. Vout=R2/(R1+R2)*Vbat Vbat=6.5 lorsqu'il est complètement chargé R1=10k et R2=10k Vout=10/(10+10)*6.5=3.25v qui est inférieur à 5v et adapté à la broche analogique ARDUINONOTE I ont montré que la batterie de 9 volts dans le circuit de la carte dénudée est juste par exemple pour connecter les fils. Mais la batterie réelle que j'ai utilisée est une batterie au plomb-acide de 6 volts, 5,5 Ah. a Vout=3.25v et valeur inférieure pour une autre tension de batterie inférieure. AEDUINO ADC convertit le signal analogique en approximation numérique correspondante. Lorsque la tension de la batterie est de 6,5 v, j'ai obtenu 3,25 v du diviseur de tension et sample1 = 696 dans le moniteur série, où sample1 est la valeur ADC correspondant à 3,25vPour une meilleure compréhension, j'ai joint la simulation en temps réel par 123D.circuit pour la mesure de la tension. 3.25v équivalent à 696 1 équivaut à 3.25/696=4.669mv Vout = (4.669*sample1)/1000 volt Tension réelle de la batterie = (2*Vout) voltARDUINO CODE: // prélèvement de 150 échantillons du diviseur de tension avec un intervalle de 2sec puis faire la moyenne des données d'échantillons collectées pour (int i=0;i<150;i++) { sample1=sample1+analogRead(A2); //lire la tension du retard du circuit diviseur (2); } échantillon1=échantillon1/150; tension=4.669*2*échantillon1/1000;

Étape 4: mesure du courant

Pour la mesure du courant, j'ai utilisé un capteur de courant à effet Hall ACS 712 (20 A). Il existe différentes gammes de capteurs ACS712 disponibles sur le marché, alors choisissez en fonction de vos besoins. Dans le diagramme de la planche à pain, j'ai montré la LED comme une charge mais la charge réelle est différente. PRINCIPE DE FONCTIONNEMENT: L'effet Hall est la production d'une différence de tension (la tension Hall) à travers un conducteur électrique, transversale à un courant électrique dans le conducteur et un champ magnétique perpendiculaire au courant. Pour en savoir plus sur le capteur à effet Hall, cliquez ici. VCC / 2 =5v/2=2.5VCalibration: La lecture analogique produit une valeur de 0-1023, ce qui équivaut à 0v à 5v Donc lecture analogique 1 = (5/1024) V =4.89mv Valeur = (4.89*valeur de lecture analogique)/ 1000 V Mais selon les fiches techniques, l'offset est de 2,5 V (lorsque le courant est nul, vous obtiendrez 2,5 V de la sortie du capteur) Valeur réelle = (valeur-2,5) V Courant en amp = valeur réelle * 10 CODE ARDUINO: // prenant 150 échantillons de capteurs avec un intervalle de 2 secondes, puis faire la moyenne des données d'échantillons collectées pour (int i=0;i<150;i++) { sample2+=analogRead(A3); //lire le courant du capteur delay(2); } échantillon2=échantillon2/150; val =(5,0*échantillon2)/1024,0; valeur réelle =val-2,5; // la tension de décalage est de 2,5 V ampères = valeur réelle * 10;

Étape 5: Mesure du temps

Pour la mesure du temps, aucun matériel externe n'est nécessaire, car ARDUINO lui-même a une minuterie intégrée. La fonction millis () renvoie le nombre de millisecondes depuis que la carte Arduino a commencé à exécuter le programme en cours. CODE ARDUINO: long milisec = millis (); // calcule le temps en millisecondes long time=milisec/1000; // convertir les millisecondes en secondes

Étape 6: Comment ARDUINO calcule la puissance et l'énergie

totamps=totamps+ampères; // calcule les ampères totaux avgamps=totamps/time; // ampères moyen amhr=(avgamps*time)/3600; // amp-heure watt =voltage*amps; // puissance=tension*énergie actuelle=(watt*temps)/3600; Watt-sec est à nouveau converti en Watt-Hr en divisant 1hr(3600sec) // energy=(watt*time)/(1000*3600); pour lire en kWh

Étape 7: sortie visuelle

Tous les résultats peuvent être visualisés sur le moniteur série ou à l'aide d'un écran LCD. J'ai utilisé un écran LCD de 16x2 caractères pour afficher tous les résultats obtenus dans les étapes précédentes. > Arduino +5v 3. VO -> Arduino GND broche + Résistance ou potentiomètre 4. RS -> Arduino broche 8 5. RW -> Arduino broche 7 6. E -> Arduino broche 6 7. D0 -> Arduino - Non connecté 8 D1 -> Arduino - Non connecté 9. D2 -> Arduino - Non connecté 10. D3 -> Arduino - Non connecté 11. D4 -> Arduino broche 5 12. D5 -> Arduino broche 4 13. D6 -> Arduino broche 3 14. D7 -> Arduino pin 2 15. A -> Arduino Pin 13 + Résistance (Puissance du rétroéclairage) 16. K -> Arduino GND (Masse du rétroéclairage) CODE ARDUINO: Pour le moniteur série:

Serial.print("TENSION: "); Serial.print(tension); Serial.println("Volt"); Serial.print("CURRENT:"); Serial.print(ampères); Serial.println("Amps"); Serial.print("POWER:"); Serial.print(watt); Serial.println("Watt"); Serial.print("ENERGIE CONSOMMEE:"); Serial.print(énergie); Serial.println("Watt-Heure"); Serial.println(""); // affiche les prochains jeux de paramètres après un délai de ligne vide (2000); Pour LCD: Pour l'affichage LCD, vous devez d'abord importer la bibliothèque "LiquidCrystal" dans le code. Pour en savoir plus sur la librairie LequidCrystal cliquez ici Pour le tutoriel LCD cliquez ici Le code suivant est un format pour afficher en LCD tous les calculs de puissance et d'énergie #include lcd(8, 7, 6, 5, 4, 3, 2); int backLight = 9; void setup() { pinMode(backLight, OUTPUT); //définir la broche 9 comme sortie analogWrite(backLight, 150); //contrôle l'intensité du rétroéclairage 0-254 lcd.begin (16, 2); // colonnes, lignes. taille de l'affichage lcd.clear(); // efface l'écran } void loop() { lcd.setCursor(16, 1); // place le curseur en dehors du nombre d'affichage lcd.print(" "); // affiche le caractère vide delay(600); /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////) //////////////////////////////////////////// lcd.setCursor (dix); // place le curseur sur la 1ère colonne et la 1ère ligne lcd.print(watt); lcd.print("W "); lcd.print(tension); lcd.print("V"); lcd.setCursor(1, 1); // place le curseur sur la 1ère colonne et la 2ème ligne lcd.print(energy); lcd.print("WH "); lcd.print(ampères); lcd.print("A"); }

Étape 8: Téléchargement de données sur Xively.com

Reportez-vous aux captures d'écran ci-dessus pour une meilleure compréhension. Pour le téléchargement de données sur xively.com, la bibliothèque suivante doit être téléchargée en premier HttpClient: cliquez iciXively: cliquez iciSPI: Importer depuis arduino IDE (esquisse -> Importer la bibliothèque…..)Ethernet: Importer depuis arduino IDE ((sketch -> Import library…..) Ouvrez un compte avec https://xively.com (anciennement pachube.com et cosm.com) Inscrivez-vous pour un compte développeur gratuit sur

Choisissez un nom d'utilisateur, un mot de passe, définissez votre adresse, votre fuseau horaire, etc. Vous recevrez un e-mail de confirmation;

puis cliquez sur le lien d'activation pour activer votre compte. Après avoir ouvert le compte avec succès, vous serez redirigé vers la page Appareils de développement

• Cliquez sur la case +Ajouter un appareil
• Donnez un nom à votre appareil et une description (par exemple, SURVEILLANCE DE L'ÉNERGIE) ·
• Choisissez des données privées ou publiques (je choisis privé)·
• Cliquez sur Ajouter un appareil

Après avoir ajouté l'appareil, vous êtes redirigé vers une nouvelle page où se trouvent de nombreuses informations importantes

• ID de produit, secret de produit, numéro de série, code d'activation·
• ID de flux, FeedURL, API End Point (L'ID de flux est utilisé dans le code ARDUINO)
• Ajouter des canaux (IChoisissez ENERGY et POWER, mais vous pouvez choisir selon votre choix)Donnez l'unité et le symbole pour le paramètre·
• Ajoutez votre emplacement ·
• Clés API (utilisées dans le code ARDUINO, évitez de partager ce numéro) ·
• Déclencheurs (ping sur une page Web lorsqu'un événement s'est produit, comme lorsque la consommation d'énergie dépasse une certaine limite)

Étape 9: Code Xively et ARDUINO

Ici, j'ai joint le code complet (version bêta) du compteur d'énergie, à l'exception de l'enregistrement des données de la carte SD, qui est joint séparément à l'étape suivante. /** Téléchargement des données de surveillance énergétique vers xively **/ #include #include #include #include #define API_KEY "xxxxxxxx" // Saisissez votre clé API Xively #define FEED_ID xxxxxxxxx // Saisissez votre identifiant de flux Xively // Adresse MAC de votre Octet de blindage Ethernet mac = {0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED}; // Broche analogique que nous surveillons (0 et 1 sont utilisées par le blindage Ethernet) int sensorPin = 2; non signé long lastConnectionTime = 0; // la dernière fois que nous nous sommes connectés à Cosm const unsigned long connectionInterval = 15000; // délai entre les connexions à Cosm en millisecondes // Initialisation de la bibliothèque Cosm // Définition de la chaîne pour notre ID de flux de données char sensorId = "POWER"; char sensorId2 = "ÉNERGIE"; XivelyDatastream datastreams = { XivelyDatastream(sensorId, strlen(sensorId), DATASTREAM_FLOAT), XivelyDatastream(sensorId2, strlen(sensorId2), DATASTREAM_FLOAT), DATASTREAM_FLOAT), }; // Enveloppe le flux de données dans un flux XivelyFeed feed(FEED_ID, datastreams, 2 /* nombre de flux de données */); Client Ethernet; XivelyClient xivelyclient(client); void setup() { Serial.begin(9600); Serial.println("Initialisation du réseau"); while (Ethernet.begin(mac) != 1) { Serial.println("Erreur lors de l'obtention de l'adresse IP via DHCP, en essayant à nouveau…"); retard (15000); } Serial.println("Réseau initialisé"); Serial.println(); } void loop() { if (millis() - lastConnectionTime > connectionInterval) { sendData(); // envoie des données à xively getData(); // relire le flux de données à partir de xively lastConnectionTime = millis(); // met à jour le temps de connexion afin que nous attendions avant de nous reconnecter } } void sendData() { int sensor1 = watt; int sensor2 = énergie; datastreams[0].setFloat(sensor1); // valeur de puissance datastreams[1].setFloat(sensor2); // valeur énergétique Serial.print("Read power "); Serial.println(datastreams[0].getFloat()); Serial.print("Lire l'énergie "); Serial.println(datastreams[1].getFloat()); Serial.println("Téléchargement vers Xively"); int ret = xivelyclient.put(flux, API_KEY); Serial.print("PUT return code: "); Serial.println(ret); Serial.println(); } // récupère la valeur du flux de données de xively, en affichant la valeur que nous avons reçue void getData() { Serial.println("Lecture des données de Xively"); int ret = xivelyclient.get(flux, API_KEY); Serial.print("GET code retour: "); Serial.println(ret); if (ret > 0) { Serial.print("Datastream is: "); Serial.println(feed[0]); Serial.print("La valeur de puissance est: "); Serial.println(feed[0].getFloat()); Serial.print("Le flux de données est: "); Serial.println(feed[1]); Serial.print("La valeur énergétique est: "); Serial.println(feed[1].getFloat()); } Serial.println();

Étape 10: Enregistrement des données sur une carte SD

Pour le stockage des données sur une carte SD, vous devez importer la bibliothèque SDPour le tutoriel cliquez iciPour en savoir plus sur la bibliothèque SD cliquez iciLe code pour stocker les données sur une carte SD est écrit séparément car je n'ai pas suffisamment de mémoire dans mon ARDUINO UNO après écriture de code pour écran LCD et téléchargement de données xively.com. Mais j'essaie d'améliorer le code de la version bêta afin qu'un seul code puisse contenir toutes les fonctionnalités (écran LCD, téléchargement de données Xively et stockage de données sur une carte SD). Le code pour l'enregistrement des données est joint ci-dessous. Si quelqu'un écrit un meilleur code en modifiant mon code s'il vous plaît partager avec moi. Ceci est mon premier instructable technique, si quelqu'un y trouve une erreur, n'hésitez pas à commenter.. afin que je puisse m'améliorer. Si vous trouvez des domaines d'amélioration dans ce projet s'il vous plaît commentaires ou envoyez-moi un message, le projet sera donc plus puissant. Je pense qu'il sera utile pour les autres ainsi que pour moi.

Troisième Prix du Concours 123D Circuits