UltraV: Tragbares UV-Index-Messgerät für sicheren Sonnenschutz

Komponenten

Arduino Nano R3	1
ML8511 UV-Sensor (Texas Instruments / Lapis Semiconductor)	1
128×64 OLED-Display (SSD1306, I²C)	1
MT3608 DC-DC Step-Up-Wandler (3 V → 9 V)	1
CR2-Batterie (3 V, 800 mAh) + Batteriehalter	1
Schalter, Gehäuse (3D-Druck/Standard)	1

Projektbeschreibung

Aufgrund einer dermatologischen Erkrankung darf ich mich nicht der Sonne aussetzen. Statt am Strand zu liegen, baute ich ein tragbares UV-Messgerät – den UltraV. Basis ist ein Arduino Nano Rev3 mit UV-Sensor, Step-Up-Wandler für die 3-V-Batterie und kleinem OLED-Display. Ziel: Überall und jederzeit den UV-Index ablesen können.

Schritt 1: Bauteile

• Arduino Nano Rev.3
• ML8511 UV-Sensor
• 128×64 OLED (SSD1306)
• MT3608 Step-Up
• CR2-Batterie + Halter
• Schalter, Gehäuse

Schritt 2: Der ML8511 UV-Sensor

Der ML8511 misst UV-A und UV-B, hat einen eingebauten Operationsverstärker (Photostrom → Spannung), analogen Ausgang, sehr niedrigen Stromverbrauch (300 µA typ., 0,1 µA Standby) und ein winziges 12-Pin-QFN-Gehäuse (4×3,7×0,73 mm).

Wichtig: Kein transparentes Material (Glas, Kunststoff) vor den Sensor – alle getesteten Materialien dämpfen UV-Strahlung. Quarzglas wäre ideal, war aber zu teuer. Daher sitzt der Sensor ungeschützt außen am Gehäuse.

Schritt 3: Bedienung

Gerät einschalten, mehrere Sekunden zur Sonne ausrichten (parallel zu Sonnenstrahlen). Display zeigt links den Instant-Wert (alle 200 ms aktualisiert), rechts den Maximalwert der Sitzung – das ist der relevante Wert. Unten links: WHO-Kategorie (LOW, MODERATE, HIGH, VERY HIGH, EXTREME).

Schritt 4: Batterie & Spannungsmessung

CR2 gewählt wegen Größe und Kapazität (800 mAh). Nach einem Sommer noch 2,8 V – sehr zufriedenstellend. Betrieb: ca. 100 mA, Messung dauert nur Sekunden. Da CR2 nur 3 V liefert, hebt der MT3608 auf 9 V für Vin an.

Batteriespannungsanzeige über Analog-Eingang A2. Kalibrierung nötig: Mit Multimeter die tatsächliche 5-V-Referenz am Arduino-5V-Pin messen (z. B. 5,023 V) und in den Sketch eintragen:

voltage = ((long)sum / (long)NUM_SAMPLES * 5023) / 1024.0;

Im Sketch: Mittelwert über 10 Samples.

Schritt 5: Schaltplan & Verbindungen

Schritt 6: Software

Display: U8g2lib (flexibel, viele Fonts, gute Positionierung).

UV-Messung: Nutzung der präzisen 3,3-V-Referenz des Arduino (Genauigkeit ±1 %) als ADC-Referenz. A1 an 3,3 V gelegt, A0 am Sensor. Vergleich der beiden ADC-Werte liefert vin-unabhängige Messung (solange Vin > 3,4 V):

int uvLevel = averageAnalogRead(UVOUT);
int refLevel = averageAnalogRead(REF_3V3);
float outputVoltage = 3.3 / refLevel * uvLevel;

Vollständiger Code als Download: UltraV_OLED.ino.zip

Schritt 7: Gehäuse (3D-Druck)

Nach gescheiterten Versuchen, ein Standardgehäuse auszuschneiden, eigenes CAD-Design. CR2-Batteriehalter außen auf der Rückseite geklebt für minimalen Platzbedarf. STL-Datei: UltraV.stl.zip

Schritt 8: Mögliche Erweiterungen

• UV-Spektrometer für echte Referenzwerte (teuer)
• Gleichzeitige Aufzeichnung von ML8511 und Referenz
• Algorithmus zur Echtzeit-UVI-Berechnung unter verschiedenen atmosphärischen Bedingungen

Schritt 9: Bildergalerie

Schritt 10: Credits

• Carlos Orts: Arduino Project Hub
• Arduino Forum: ADC-Kalibrierung
• Starting Electronics: Artikel
• U8g2lib: Referenz
• WHO UV-Index: WHO

Code (UltraV.ino)

/* Fabio Marzocca @ 2018
   ADC-Korrektur über 3,3V-Referenz für vin-unabhängige Messung
   v2.0.0: LCD → OLED, v2.0.1: Batterie-Funktion geändert */
#include <Arduino.h>
#include <U8g2lib.h>
#include <Wire.h>

U8G2_SSD1306_128X64_NONAME_F_SW_I2C u8g2(U8G2_R0, SCL, SDA, U8X8_PIN_NONE);

#define FIRST_ROW_Y 16
#define FIRST_ROW_X 16
#define BOX_H 38

const int UVOUT = A0;
const int REF_3V3 = A1;
const int VBATT = A2;
float maxUV = 0;

void setup() {
  pinMode(UVOUT, INPUT);
  pinMode(REF_3V3, INPUT);
  pinMode(VBATT, INPUT);
  u8g2.begin();
}

void loop() {
  u8g2.firstPage();
  do {
    int uvLevel = averageAnalogRead(UVOUT);
    int refLevel = averageAnalogRead(REF_3V3);
    float outputVoltage = 3.3 / refLevel * uvLevel;
    float uvIntensity = mapfloat(outputVoltage, 0.99, 2.6, 0.0, 15.0);
    readBattery();
    if (maxUV < uvIntensity) maxUV = uvIntensity;

    u8g2.drawFrame(0, FIRST_ROW_Y+1, 128, BOX_H);
    u8g2.setFont(u8g2_font_logisoso18_tf);
    u8g2.setCursor(10, 40); u8g2.print(uvIntensity);   // Instant
    u8g2.setCursor(70, 40); u8g2.print(maxUV);        // Maximum
    u8g2.setFont(u8g2_font_u8glib_4_tf);
    u8g2.setCursor(10, 52); u8g2.print(F("INSTANT"));
    u8g2.setCursor(75, 52); u8g2.print(F("MAXIMUM"));
    showUVCategory();
    u8g2.setCursor(88, 64); u8g2.print(F("F.Marzocca"));
  } while (u8g2.nextPage());
  delay(200);
}

void showUVCategory() {
  char strCat[12];
  byte categ = (byte)(maxUV + 0.5); // runden
  if (categ < 3) strcpy(strCat, "LOW");
  else if (categ < 6) strcpy(strCat, "MODERATE");
  else if (categ < 8) strcpy(strCat, "HIGH !");
  else if (categ < 10) strcpy(strCat, "VERY HIGH!");
  else strcpy(strCat, "EXTREME!");
  u8g2.setCursor(0, 64); u8g2.print(strCat);
}

int averageAnalogRead(int pin) {
  byte n = 16; unsigned int sum = 0;
  for (byte x = 0; x < n; x++) sum += analogRead(pin);
  return sum / n;
}

float mapfloat(float x, float in_min, float in_max, float out_min, float out_max) {
  return (x - in_min) * (out_max - out_min) / (in_max - in_min) + out_min;
}

void readBattery() {
  long battery = readBattVcc();
  long VccMin = 2300;
  byte batteryBar = (battery - VccMin) / 140;
  u8g2.setFont(u8g2_font_open_iconic_embedded_2x_t);
  u8g2.drawGlyph(1, FIRST_ROW_Y, 73); // Batterie-Icon
  u8g2.setFont(u8g2_font_open_iconic_play_1x_t);
  for (byte i = 1; i <= batteryBar; i++)
    u8g2.drawGlyph(128 - 9*i, FIRST_ROW_Y - 4, 75); // Balken
  u8g2.setFont(u8g2_font_freedoomr10_tu);
  u8g2.setCursor(25, FIRST_ROW_Y);
  u8g2.print(float(battery)/1000, 3); // Volt mit 3 Nachkommastellen
}

long readBattVcc() {
  int sum = 0, samples = 0;
  #define NUM_SAMPLES 10
  while (samples < NUM_SAMPLES) {
    sum += analogRead(VBATT);
    samples++; delay(2);
  }
  // Kalibrierte Referenz: 5020 mV (anpassen!)
  return ((long)sum / NUM_SAMPLES * 5020) / 1024.0;
}