Messung der Sonneneinstrahlung mit Arduino

Komponenten und Verbrauchsmaterialien

Arduino UNO

Arduino Ethernet Shield 2

Solarzelle

Widerstand 10k Ohm

Notwendige Werkzeuge und Maschinen

Digitalmultimeter

Über dieses Projekt

Über

Es gibt viele Sensoren, um alle möglichen Wetterbedingungen wie Temperatur, Feuchtigkeit, Lichtintensität usw. zu messen, aber es gibt keine leicht erhältlichen Sensoren zur Messung der Sonnenstrahlung. Denn die Sonnenstrahlung kann schwer zu messen sein, obwohl wir sie täglich auf unserer Haut spüren.

Die Sonneneinstrahlung ist die Leistung pro Flächeneinheit, die von der Sonne in Form von elektromagnetischer Strahlung im Wellenlängenbereich des Messgeräts empfangen wird. Der große Wellenlängenbereich der Sonne ist ein weiterer Faktor, der die Messung erschwert.

Das Instrument zur Messung der Sonnenstrahlung wird Pyranometer genannt. Pyranometer können zwischen 200 und 800 US-Dollar kosten, sogar von chinesischen Anbietern, was sie für den durchschnittlichen Bastler unzugänglich macht. Sie können hier mehr darüber lesen:https://en.wikipedia.org/wiki/Pyranometer

Ich war vor kurzem auf der Suche nach einem Solarmodul für mein Zuhause und wollte wissen, ob es sich lohnt und wollte daher die verfügbare Solarenergiemenge in meinem Wohnort abschätzen.

Ich war nicht daran interessiert, ein Pyranometer zu kaufen, also dachte ich, ich könnte etwas Geld sparen und gleichzeitig Spaß haben, indem ich mein eigenes mache.

Auf diese Weise habe ich mein eigenes cooles Gerät entwickelt, das viel billiger ist und dabei helfen kann, die Menge der Sonneneinstrahlung abzuschätzen. Es verwendet einige leicht zugängliche Komponenten und das Arduino für die Berechnungen. Ich habe den größten Teil meiner Komponenten von Chinavasion, aber es gibt viele andere Orte, an denen Sie die Werkzeuge und Geräte beziehen können, da alle allgemein erhältlich sind.

Einrichtung

1. Ihre Solarzelle sollte 2 Drähte haben, eine Masse (schwarz) und die andere stromführend (rot). Wenn Sie unterschiedliche Farbcodes haben oder diese nicht unterscheiden können, überprüfen Sie mit Ihrem Multimeter. Verbinden Sie die Sonden Ihres Multimeters mit beiden Drähten, wenn die angezeigte Spannung positiv ist, dann ist der Draht, an den Ihre schwarze Multimeter-Sonde angeschlossen ist, die Masse, während der rote unter Spannung steht, wenn die Spannung negativ ist, ist es umgekehrt herum.

2. Verbinden Sie das Erdungskabel Ihrer Solarzelle mit der Arduino-Masse und das VCC-Kabel über den von uns gewählten Widerstand mit einem beliebigen analogen Pin. Für dieses Projekt verwenden wir den analogen Pin A0. Der Widerstand ist für unsere Berechnungen sehr wichtig, da wir erwarten, dass er um ein Vielfaches größer ist als der Innenwiderstand der Zelle.

Das ist alles, was wir jetzt brauchen. Gehen Sie zum Codierungsteil über. Solarzellen erzeugen Energie, indem sie Sonnenenergie von der Sonne in elektrische Energie umwandeln, je höher die Energie (Strahlung und Lichtenergie) von der Sonne ist. Je höher die erzeugte Spannung sein wird. Wir werden diese direkt proportionale Beziehung verwenden, um die Sonneneinstrahlung abzuschätzen.

Die folgenden Parameter werden benötigt:

Arduino-Analog-Referenzspannung =5V (Vielleicht anders auf Ihrem Board)

Maximale Ausgangsspannung Ihrer Solarzelle (Dies hängt von dem von Ihnen verwendeten Solarmodul ab. Sie müssen dies überprüfen, um dies zu bestätigen, da dies für unsere Berechnung sehr wichtig ist. Für die durchschnittliche Solarzelle des Rechners beträgt sie etwa 5 V) .

Dimension der Solarzelle. Sie können dies mit einem Lineal messen (Länge und mit oder beliebigen Parametern, die Sie benötigen, um den Bereich zu finden).

Daher schätzen wir unsere Sonneneinstrahlung, indem wir die Leistung der Solarzelle berechnen und durch ihre Fläche dividieren.

Power =pow (analogRead(A0), 2) / Resistance

Fläche =Länge * Breite (vorausgesetzt wir haben ein Rechteck)

Sonnenstrahlung =Leistung / Fläche

Hier ist der Beispielcode unten:

/*------------------------------------------------------ -------------------------------------------------- ----------------------------------------*/#define ANALOG_PIN A0 // Analoger Pin#define WIDERSTAND 10 // Widerstand in Tausend Ohm# define PANEL_LENGTH 60 // Länge der Solarzelle in mm#define PANEL_WIDTH 20 // Breite der Solarzelle in mmvolatile float Area;volatile float Power;volatile float Strahlung;/** Main Setup Funktion*/void setup() {// Begin serielle KommunikationSerial.begin (9600); while(!Serial);delay(100);}/** Main Setup Funktion*/void loop() {Area =PANEL_LENGTH * PANEL_WIDTH / (100*100); // wir teilen durch 10000 erhalten die Fläche in QuadratmeternPower =pow(analogRead(ANALOG_PIN), 2) / RESISTANCE; // Berechnung von powerRadiation =Power / Area;char *msg; sprintf(msg, " Die Sonnenstrahlung ist %f W/M2 ", Strahlung); // Generieren der zu druckenden Nachricht Serial.println(msg);delay(1000);}/*---------------------------------------- -------------------------------------------------- ----------------------------------------------------------*/

Die durchschnittlichen Einstrahlungswerte für einen normalen Tag können von 150 bis 300 W/m2 reichen. Dies wird jedoch je nach Standort stark variieren. Er kann an einem sonnigen Tag oder in Gebieten rund um den Äquator bis zu 900 erreichen.

Um die Internetfunktionalität hinzuzufügen, können wir das Ethernet-Shield verwenden. Wir müssen keine weiteren neuen Verbindungen herstellen, montieren Sie einfach das Schild auf dem Arduino und platzieren Sie die Pins in ihren entsprechenden Positionen auf dem Schild (d.h. Pin 1 auf dem Arduino bleibt Pin 1 auf dem Schild)

Code

Beispielcode für Pyranometer
Ethernet-Funktionscode

Beispielcode für PyranometerArduino

#define ANALOG_PIN A0 // Analoger Pin
#define WIDERSTAND 10 // Widerstand in Tausend Ohm
#define PANEL_LENGTH 60 // Länge der Solarzelle in mm
#define PANEL_WIDTH 20 // Breite der Solarzelle in mm

flüchtiger Float-Bereich;
flüchtige Float-Power;
flüchtige Schwebestrahlung;

/*
* Haupt-Setup-Funktion
*/
Void-Setup () {
// Serielle Kommunikation beginnen
Serial.begin (9600);
while(!Seriell);

Verzögerung (100);
}

/*
* Haupt-Setup-Funktion
*/
Leere Schleife () {

Fläche =PANEL_LENGTH * PANEL_WIDTH / (100*100); // wir teilen durch 10000 und erhalten die Fläche in Quadratmetern

Leistung =pow(analogRead(ANALOG_PIN), 2) / WIDERSTAND; // Leistung berechnen

Strahlung =Leistung / Fläche;

Zeichen *Nachricht;

sprintf(msg, " Die Sonnenstrahlung ist %f W/M2 ", Strahlung); // Generieren der zu druckenden Nachricht

Serial.println (msg);

Verzögerung (1000);
}

Keine Vorschau (nur Download).

Ethernet-FunktionscodeArduino

#include
#include

#define ANALOG_PIN A0 // Analoger Pin
#define WIDERSTAND 10 // Widerstand in Tausend Ohm
#define PANEL_LENGTH 60 // Länge der Solarzelle in mm
#define PANEL_WIDTH 20 // Breite der Solarzelle in mm

flüchtiger Float-Bereich;
flüchtige Float-Power;
flüchtige Schwebestrahlung;

// Geben Sie unten eine MAC-Adresse und IP-Adresse für Ihren Controller ein.
// Die IP-Adresse hängt von Ihrem lokalen Netzwerk ab:
Byte-Mac[] ={
0xDE, 0x0D, 0x8E, 0xEF, 0xFE, 0xED
};
IP-Adresse ip(192, 168, 1, 177);

// Initialisieren Sie die Ethernet-Server-Bibliothek
// mit der IP-Adresse und dem Port, den Sie verwenden möchten
// (Port 80 ist Standard für HTTP):
EthernetServer-Server (80);

Void-Setup () {
// Öffnen Sie die serielle Kommunikation und warten Sie, bis der Port geöffnet ist:
Serial.begin (9600);
während (!Seriell) {
; // Warten Sie, bis der serielle Port eine Verbindung herstellt. Nur für nativen USB-Port erforderlich
}

// Starten Sie die Ethernet-Verbindung und den Server:
Ethernet.begin(mac, ip);
server.begin();
Serial.print("Server ist auf");
Serial.println (Ethernet.localIP());
}

Leere Schleife () {

Fläche =PANEL_LENGTH * PANEL_WIDTH / (100*100); // wir teilen durch 10000 und erhalten die Fläche in Quadratmetern
Leistung =pow(analogRead(ANALOG_PIN), 2) / WIDERSTAND; // Leistung berechnen
Strahlung =Leistung / Fläche;
Zeichen *Nachricht;
sprintf(msg, " Die Sonnenstrahlung ist %f W/M2 ", Strahlung); // Generieren der zu druckenden Nachricht

// auf eingehende Kunden achten
EthernetClient-Client =server.available();
wenn (Kunde) {
Serial.println("neuer Kunde");
// eine http-Anfrage endet mit einer Leerzeile
boolean currentLineIsBlank =true;
while (client.connected()) {
if (client.verfügbar()) {
char c =client.read();
Serial.write (c);
// wenn Sie das Ende der Zeile erreicht haben (einen Zeilenumbruch erhalten)
// Zeichen) und die Zeile ist leer, die http-Anfrage ist beendet,
// damit Sie eine Antwort senden können
if (c =='\n' &¤tLineIsBlank) {
// Sende einen Standard-HTTP-Antwortheader
client.println("HTTP/1.1 200 OK");
client.println("Inhaltstyp:text/html");
client.println("Verbindung:schließen"); // die Verbindung wird nach Abschluss der Antwort geschlossen
client.println("Aktualisieren:5"); // aktualisiere die Seite automatisch alle 5 Sek.
client.println();
client.println("");
client.println("");

/*
* Nachricht an den Kunden senden
*/
client.print(msg);
client.println("
");

client.println("");
brechen;
}
if (c =='\n') {
// du beginnst eine neue Zeile
currentLineIsBlank =true;
} else if (c !='\r') {
// du hast ein Zeichen in der aktuellen Zeile bekommen
currentLineIsBlank =false;
}
}
}
// dem Webbrowser Zeit geben, die Daten zu empfangen
Verzögerung (1);
// Verbindung schließen:
client.stop();
Serial.println ("Client getrennt");
}
}

Keine Vorschau (nur Download).

Schaltpläne

Schema von Solarpanel, Widerstand und Anschlüssen

Arduino TEA5767 FM-Radioempfänger Mini-Stereo-Radio mit RDA5807

Herstellungsprozess

3d Drucken

Automatisierungssteuerung System

Industrietechnik