In diesem Tutorial lernst du, wie du mit einem VEML6070 UV-Lichtsensor, einem OLED und einem Arduino Uno einen UV-Index-Messer baust.
Der UV Index ist ein Maß für die Stärke der ultravioletten (UV) Strahlung der Sonne. Der Zweck des UV-Index ist es, Menschen dabei zu helfen, sich vor UV-Strahlung zu schützen, die Sonnenbrand, Hautalterung, DNA-Schäden, Hautkrebs, Immunsuppression und Augenschäden verursachen kann.
Unser UV-Index-Messer liest die UV-Lichtintensität von einem VEML6070 UV-Sensor aus und zeigt sie zusammen mit einem Risikoniveau auf einem OLED-Display an, um dich über das aktuelle UV-Risiko zu informieren. Zum Kontext: Die Empfehlungen des Cancer Council sind, den UV-Index zu überprüfen, wenn du:
- eine Outdoor-Aktivität oder Veranstaltung planst oder daran teilnimmst
- Freizeitaktivitäten wie Laufen, Schwimmen, Radfahren oder Mannschaftssport betreibst
- einen Zuschauersport wie Tennis oder Cricket ansiehst
- draußen arbeitest, Verantwortung für Außendienstmitarbeiter hast oder
- für kleine Kinder und deren Aktivitäten im Freien verantwortlich bist.
Lass uns mit diesem Projekt starten und uns zuerst die Liste der benötigten Teile ansehen.
Benötigte Teile
Ich habe für dieses Projekt einen Arduino Uno verwendet, aber jeder andere Arduino oder ein ESP32/ESP8266 Board funktioniert ebenfalls. Beachte, dass VEML6070 Sensoren recht teuer sein können. Ich habe den günstigsten auf Amazon gefunden, empfehle aber, die Preise zu vergleichen und etwas zu recherchieren.
VEML6070 UV-Lichtsensor
Arduino Uno
USB-Kabel für Arduino UNO
Dupont-Kabelset
Breadboard
OLED-Display
Makerguides is a participant in affiliate advertising programs designed to provide a means for sites to earn advertising fees by linking to Amazon, AliExpress, Elecrow, and other sites. As an Affiliate we may earn from qualifying purchases.
Der VEML6070 UV-Lichtsensor
Der VEML6070 UV-Lichtsensor ist ein digitaler Sensor, der die Intensität von ultraviolettem (UV) Licht misst. Er verwendet eine Photodiode, um UV-Licht in ein elektrisches Signal umzuwandeln, das dann von einer internen Schaltung verarbeitet wird, um eine digitale Ausgabe zu liefern. Er hat eine Spitzenempfindlichkeit für UVA-Licht bei einer Wellenlänge von 355 nm. Die folgende Grafik zeigt die spektrale Empfindlichkeit des VEML6070:
Der VEML6070 Sensor ist aufgrund seiner kleinen Größe und seines niedrigen Stromverbrauchs leicht in verschiedene elektronische Geräte und Projekte integrierbar. Er verfügt über einen Energiesparmodus, der den Stromverbrauch auf unter 1 μA reduziert.
Blockdiagramm
Der Sensor kommuniziert mit Mikrocontrollern über eine I2C-Schnittstelle, was ihn kompatibel mit beliebten Entwicklungsboards wie Arduino und ESP32 macht. Das Bild unten zeigt das Blockdiagramm der internen Komponenten und der IO-Pins:
SDA und SCL sind die Pins für die I2C-Schnittstelle. Vdd und GND sind für die Stromversorgung, der Sensor arbeitet mit 2,7 V bis 5,5 V. Der VEML6070 verfügt über eine Temperaturkompensation, die eine lineare Empfindlichkeit gegenüber Sonnen-UV-Licht sicherstellt. Die Empfindlichkeit kann über einen externen Widerstand an RSET eingestellt werden. Der aktive Acknowledge (ACK) Pin ermöglicht es dem Sensor, ein UV-Index-Warnsignal auszugeben, wenn ein Schwellenwert überschritten wird. Für weitere Details siehe das Datenblatt:
Dieser Sensor wird häufig in Anwendungen eingesetzt, bei denen die Überwachung der UV-Licht-Exposition wichtig ist, wie in Wearables, UV-Index-Messgeräten und UV-Sterilisationssystemen. Seine hohe Empfindlichkeit und Genauigkeit machen ihn zu einem wertvollen Werkzeug zur Messung von UV-Lichtwerten in Innen- und Außenbereichen.
Breakout-Board
Wenn du den rohen Sensor mit einem Mikrocontroller verwenden möchtest, benötigst du einige zusätzliche Bauteile (Widerstände, Kondensatoren). Siehe die typische Anwendungsschaltung des VEML6070 im Datenblatt.
Um den Aufwand zu vermeiden, kannst du Breakout-Boards kaufen, die diese Bauteile bereits integriert haben. Das Bild unten zeigt ein typisches Breakout-Board für den VEML6070 mit der I2C-Schnittstelle (SCL, SDA), Stromversorgung (VCC, GND) und dem Acknowledge (ACK) Ausgang.
Im Folgenden verwenden wir ein solches Breakout-Board, um den VEML6070 Sensor mit einem Arduino zu verbinden.
Anschluss des VEML6070 an Arduino
Dank der I2C-Schnittstelle ist der Anschluss des VEML6070 Sensors an einen Arduino Uno sehr einfach. Verbinde einfach die SCL- und SDA-Pins des VEML6070 Breakout-Boards mit den entsprechenden Pins am Arduino-Board, wie unten gezeigt.
Als nächstes verbinde Ground und VCC. Du kannst 5V oder 3,3V für VCC verwenden; ich habe 3,3V gewählt.
Und das ist alles, was du tun musst, um den Sensor anzuschließen.
Code zum Auslesen des UV-Index vom VEML6070
In diesem Abschnitt schreiben wir ein kleines Programm, um den Sensor zu testen. Zuerst müssen wir eine passende Bibliothek installieren.
Es gibt drei Bibliotheken, um VEML6070 Sensordaten auszulesen. Es gibt die Adafruit_VEML6070 Bibliothek, die Seeed_VEML6070 Bibliothek und die arduino-VEML6070 Bibliothek. Ich habe die letzte verwendet, da sie einfach zu bedienen ist und Risikoindex und -level berechnet. Du kannst sie wie gewohnt über den Library Manager installieren, und nach der Installation sollte es so aussehen:
Jetzt können wir etwas Code schreiben. Das folgende sehr einfache Beispiel liest die gemessene UV-Intensität vom VEML6070 Sensor aus und gibt sie im Serial Monitor aus:
#include "VEML6070.h"
void setup() {
Serial.begin(9600);
VEML.begin();
}
void loop() {
uint16_t uvs = VEML.read_uvs_step();
Serial.print("UVS:");
Serial.println(uvs);
delay(1000);
}
Wenn du diesen Code hochlädst und den Serial Plotter öffnest, solltest du eine Kurve für UVS sehen. Und wenn du den Sensor einer Lichtquelle (z.B. Taschenlampe) aussetzt, solltest du einen Ausschlag sehen:
Wie du siehst, ist das Auslesen der Daten vom VEML6070 Sensor sehr einfach. Um es etwas interessanter zu machen, fügen wir im nächsten Abschnitt ein OLED hinzu.
Ein OLED hinzufügen
Anstatt die UV-Intensitätsdaten im Serial Monitor anzuzeigen, wäre es schöner, sie auf einem separaten Display darzustellen. So können wir einen tragbaren UV-Index-Messer bauen. In diesem Abschnitt fügen wir daher ein OLED zum Schaltkreis hinzu und zeigen die UV-Daten darauf an.
Anschluss des OLED an Arduino
Da das OLED ebenfalls ein I2C-Gerät ist, ist der Anschluss unkompliziert. Wir verbinden einfach SDA und SCL mit denselben Pins, an denen der VEML6070 Sensor angeschlossen ist. Da das OLED mit 3,3V läuft, können wir auch die Stromversorgungsleitungen teilen. Das Bild unten zeigt die komplette Verdrahtung.
Wenn du Probleme mit dem OLED hast, schau dir das Tutorial How to Interface the SSD1306 I2C OLED Graphic Display With Arduino an.
Und so sieht der laufende Schaltkreis in der Realität aus 😉
Code zur Anzeige des UV-Index auf OLED
In diesem Abschnitt schreiben wir den Code, um die UV-Daten auf dem OLED anzuzeigen. Zur Steuerung des OLED verwenden wir die Adafruit_SSD1306 Bibliothek. Du musst sie über den Library Manager installieren, und nach der Installation sollte es so aussehen:
Und hier ist der komplette Code. Schau ihn dir zuerst an, dann besprechen wir die Details.
#include "VEML6070.h"
#include "Adafruit_SSD1306.h"
Adafruit_SSD1306 oled(128, 64, &Wire, -1);
void oled_init() {
oled.begin(SSD1306_SWITCHCAPVCC, 0x3C);
oled.clearDisplay();
oled.setTextSize(2);
oled.setTextColor(WHITE);
}
void centered(const char* text, int y) {
int16_t x1, y1;
uint16_t w, h;
oled.getTextBounds(text, 0, 0, &x1, &y1, &w, &h);
oled.setCursor(64 - w / 2, y);
oled.print(text);
}
void display_uvs() {
static char text[30];
uint16_t uvs = VEML.read_uvs_step();
int risk_level = VEML.convert_to_risk_level(uvs);
char* risk = VEML.convert_to_risk_char(risk_level);
oled.clearDisplay();
centered(risk, 15);
sprintf(text, "%d", uvs);
centered(text, 45);
oled.display();
}
void setup() {
oled_init();
VEML.begin();
}
void loop() {
display_uvs();
delay(1000);
}
Der obige Code liest die UV-Lichtintensität vom Sensor aus und zeigt sie zusammen mit einem Risikoniveau auf dem OLED-Display an, wobei die UV-Strahlungslevel wie folgt eingeteilt sind:
- niedrig (1-2)
- mäßig (3-5)
- hoch (6-7)
- sehr hoch (8-10)
- extrem (11 und höher).
Bibliotheken und Display-Initialisierung
Wir beginnen mit dem Einbinden der notwendigen Bibliotheken für den VEML6070 Sensor und das Adafruit SSD1306 OLED-Display. Dann initialisieren wir das OLED-Display in der oled_init() Funktion. Diese Funktion richtet das Display ein, löscht es, setzt die Textgröße und die Textfarbe.
#include "VEML6070.h"
#include "Adafruit_SSD1306.h"
Adafruit_SSD1306 oled(128, 64, &Wire, -1);
void oled_init() {
oled.begin(SSD1306_SWITCHCAPVCC, 0x3C);
oled.clearDisplay();
oled.setTextSize(2);
oled.setTextColor(WHITE);
}
Beachte, dass die I2C-Adresse für das OLED-Display auf 0x3C in oled.begin() gesetzt ist. Die meisten dieser kleinen OLEDs verwenden diese Adresse, aber deine könnte anders sein. Wenn du nichts auf dem OLED siehst, hat es wahrscheinlich eine andere I2C-Adresse, und du musst die Adresse, die an oled.begin() übergeben wird, ändern. Wenn du die I2C-Adresse nicht kennst, schau dir das How to Interface the SSD1306 I2C OLED Graphic Display With Arduino Tutorial an.
Display-Funktionen
Die centered() Funktion wird verwendet, um Text zentriert auf dem OLED-Display an einer bestimmten y-Koordinate auszugeben. Die display_uvs() Funktion liest die UV-Lichtintensität vom Sensor, berechnet das Risikoniveau und zeigt es zusammen mit der UV-Intensität auf dem OLED-Display an.
void centered(const char* text, int y) {
// Function to center text on OLED display
}
void display_uvs() {
// Function to display UV index and risk level on OLED display
}
Setup-Funktion
In der setup() Funktion initialisieren wir die serielle Kommunikation für Debugging-Zwecke, initialisieren das OLED-Display und starten die Kommunikation mit dem VEML6070 Sensor.
void setup() {
oled_init();
VEML.begin();
}
Loop-Funktion
Die loop() Funktion ruft kontinuierlich die display_uvs() Funktion auf, um den UV-Index und das Risikoniveau auf dem OLED-Display zu aktualisieren und anzuzeigen. Danach folgt eine Verzögerung von 1 Sekunde bis zum nächsten Update.
void loop() {
display_uvs();
delay(1000);
}
Ausgabe auf OLED
Wenn du den Code hochlädst, solltest du die folgende Ausgabe auf dem OLED sehen. Die obere Zeile zeigt das Risikoniveau, und die darunter stehende Zahl ist die UV-Intensität.
Fazit
Dieses Tutorial hat dir gezeigt, wie du einen UV-Index-Messer mit einem VEML6070 UV-Lichtsensor baust. Wir haben einen Arduino Uno und ein OLED-Display verwendet. Du könntest aber auch leicht einen batteriebetriebenen ESP32 und ein e-Paper-Display verwenden, um einen tragbaren, energiesparenden UV-Index-Messer zu bauen.
Alternativ wäre ein UV-Index-Messer auch eine schöne Ergänzung für eine Wetterstation, um vor hoher UV-Licht-Exposition zu warnen. Für technische Details zur Umsetzung schau dir die Simple ESP32 Internet Weather Station und die Weather Station on e-Paper Display Tutorials an.
Wenn du nur Licht messen möchtest (und nicht speziell UV-Licht), kannst du den BH1750 Sensor verwenden. Wie man ihn benutzt, wird im Tutorial Ambient Light Sensor BH1750 with Arduino beschrieben.
Wenn du weitere Fragen hast, frag gerne.
Viel Spaß beim Tüfteln ; )
