Hochleistungs-Datenlogger für Arduino-Wetterballons

Komponenten und Materialien

Komponente	Anzahl
Maxim Integrated DS18B20 programmierbarer 1-Wire-Digitalthermometer	2
DHT22 Temperatursensor	1
SparkFun Triple Axis Accelerometer Breakout - ADXL335	1
Male-Header 36-polig 1 Reihe Lang (0,1")	2
Arduino Mega 2560	1
5050 SMD LED	1
Widerstand 4,75 kOhm	2
Widerstand 100 Ohm	3
Widerstand 10 kOhm	1
Flash-Speicherkarte, MicroSD-Karte	1
Micro-SD-Kartenmodul	1

Benötigte Werkzeuge und Maschinen

Lötkolben (Standard)
Lötzinn, bleifrei

Apps und Onlinedienste

Arduino IDE

Über dieses Projekt

Hey zusammen! Ihr fragt euch wahrscheinlich: Warte, man kann einen Arduino ins All schicken? Fast. Mit einem Wetterballon könnt ihr einen Arduino, eine Kamera, Knoblauchbrot oder alles andere, was ihr wollt, bis zu einem Drittel des Weges ins All befördern! Obwohl es nur ein Drittel des Weges ins All ist, ist fast 99 % der Atmosphäre nicht mehr vorhanden, weshalb wir es als „Rand des Weltraums“ bezeichnen. Diese Anleitung ist sehr lang, aber lest unbedingt alles bis zu Pfad 1, falls ihr nicht nur neugierig seid. Dann legen wir los!

Es gibt drei Pfade, je nachdem, was ihr wollt und welches Können ihr habt. Alle drei erfordern Lötkenntnisse wegen der extremen Winde in der Stratosphäre. Kein Pfad ist besser als der andere – es kommt nur auf eure Interessen an. Hier ein kurzer Überblick:

Pfad 1: Einfacher Datenlogger mit Lochrasterplatine, verschiedenen Sensoren, wenig Lötarbeit.
Pfad 2: Vorgefertigter PCB-Shield (Leiterplatte) für ein sauberes, professionelles Board, von uns entworfen und getestet.
Pfad 3: Eigener PCB-Entwurf. Diese Anleitung geht nicht tief in PCB-Design ein, gibt aber wichtige Richtlinien und verlinkt gute Tutorials.

Tipps zur Auswahl:

Pfad 1 ist am einfachsten und bietet Flexibilität bei Sensoren, Platine und Features. Lötkenntnisse sind nötig, damit alles dem Flug standhält.
Pfad 2 ist am restriktivsten: feste Sensoren, festes Arduino-Board, aber sauberer PCB, keine Löt- oder Programmierarbeit, guter Einstieg in PCBs. Wir stellen Gerber-Dateien, Exporteinstellungen und Code bereit. PCBs sind günstig (5 Stück für ca. 2 $, Preis variiert je nach Anbieter).
Pfad 3 ist am anspruchsvollsten: PCB-Design, Programmierung, Löten. Wer das alles kann, könnte das Projekt allein stemmen, aber es gibt wichtige Einschränkungen und Details, bei denen diese Anleitung hilft.

Ihr habt euch entschieden? Super! Aber bevor es losgeht, gibt es zwingende Regeln zu beachten. Das Starten von Wetterballons kann je nach Wohnort reglementiert sein. Diese Anleitung behandelt nicht die Auswahl des Ballons, den Bau der Nutzlastbox oder das Befüllen – dazu gibt es viele andere Guides, die ich verlinke. Ich gehe auf die Einschränkungen für euren Arduino-Datenlogger ein und verlinke die vollständigen FAA-Richtlinien (für USA). Beachtet Folgendes:

Die Nutzlast darf keine Handysignale aussenden. Falls ein Handy an Bord ist, muss es im Flugmodus sein.
Bei GPS-Ortung des Ballons ist eine HAM-Funklizenz (Amateurfunk) nötig (Prüfung + Gebühr).
Bei einem Gewichts-Flächen-Verhältnis > 3,0 oz/in² muss das Gesamtgewicht < 4 lbs (ca. 1,8 kg) betragen.
Jede einzelne Nutzlast/Paket < 6 lbs (ca. 2,7 kg).
Bei zwei Nutzlasten: Gesamtgewicht < 12 lbs (ca. 5,4 kg).

Link zu den vollständigen FAA-Richtlinien für US-Bürger

Pfad 1 – Lochrasterplatine!

Bevor ihr entwerft, bedenkt Folgendes: Was soll auf die Platine? Im Schaltplan sind ein Temperatur-/Feuchtesensor, ein Barometersensor, ein IMU und ein SD-Kartenmodul vorgesehen. Für die meisten Projekte reicht das. Wollt ihr die Nutzlast per Arduino orten, braucht ihr ein GPS-Modul. Es gibt mehrere Bergungsoptionen:

SPOT GPS-Modul: Einfach, unbegrenzte Reichweite (Satellit), lange Batterielaufzeit, leicht erhältlich. Nachteile: Teuer, funktioniert nicht kopfüber, Signal wird von dicken Objekten blockiert. Wir nutzten diese Methode und druckten einen 3D-Gimbal, um es aufrecht zu halten. Empfehlung: SPOT 3 Satellite Messenger (Amazon), aber recherchiert selbst.
APRS-Funk: Zuverlässig, ermöglicht Datentransfer und präzise Höhenmessung. Erfordert HAM-Lizenz (Prüfung + Gebühr). Nicht im Schaltplan enthalten – Selbstbau nötig.
Handy: Nicht empfohlen. Handy muss nach Flug aus Flugmodus geholt werden, teurer als SPOT, nur als Backup genutzt.

Hochleistungs-Datenlogger für Arduino-Wetterballons

Nachdem die Bergung geklärt ist, plant den Flugverlauf. Soll der Arduino den Fallschirm auslösen? Welche Sensoren? Temperatur sinkt auf -40 °C – darauf achten! Stromversorgung: Kälte schwächt Batterien, also große Kapazität und isolierte Box (Styropor) wählen, dabei Gewichtslimit beachten.

Erstellt eine Checkliste: gewünschte Daten, Kamera an Bord, geplante Komponenten. Baut ggf. erst die Nutzlastbox, dann den Logger passend dazu. Plant gründlich!

Hier der Schaltplan und Verdrahtungsplan für unsere Sensorwahl:

Der Mega ist für diese Sensoren überdimensioniert, aber unser Code setzt ihn voraus. Nutzt ihr einen Nano, ändert die MicroSD-Pinbelegung auf die SPI-Pins eures Boards.

Teileliste Pfad 1:

SparkFun ADXL337
Header-Pins
Micro-SD-Kartenmodul
DHT22 Feuchtesensor
DS18B20 Temperatursensor
Lochrasterplatine
Arduino Mega

Ihr könnt einen zweiten DS18B20 für Innentemperatur hinzufügen und weitere Sensoren, aber für unseren Code haltet euch an den Schaltplan.

Code für Pfad 1:

// DHT22 Setup
#include "DHT.h"
#define DHTPIN 2
#define DHTTYPE DHT22
DHT dht(DHTPIN, DHTTYPE);

// SD Card Setup
#include 
#include 
File sdcard_file;
int CS_pin = 10;

// DS18B20 Temperatursensor
#include 
#include 
#define ONE_WIRE_BUS 3
OneWire oneWire(ONE_WIRE_BUS);
DallasTemperature sensors(&oneWire);

int scale = 3; // 3 (±3g) für ADXL337, 200 (±200g) für ADXL377
boolean micro_is_5V = true; // true bei 5V-Mikrocontroller (Arduino Uno), false bei 3,3V

void setup() {
  Serial.begin(9600);
  sensors.begin();
  dht.begin();
  pinMode(CS_pin, OUTPUT);
  if (SD.begin()) {
    Serial.print("SD Card found!");
  } else {
    Serial.print("Error finding SD Card");
    return;
  }
  sdcard_file = SD.open("data.csv", FILE_WRITE);
  if (sdcard_file) {
    // Datei gefunden
  } else {
    Serial.print("error initializing SD card");
  }
  // CSV-Header schreiben
  sdcard_file.print("DS18B20");
  sdcard_file.print(",");
  sdcard_file.print("DHT22 Temp");
  sdcard_file.print(",");
  sdcard_file.print("Hum");
  sdcard_file.print(",");
  sdcard_file.print("H.InX");
  sdcard_file.print(",");
  sdcard_file.print("rawX");
  sdcard_file.print(",");
  sdcard_file.print("rawY");
  sdcard_file.print(",");
  sdcard_file.print("rawZ");
  sdcard_file.print(",");
  sdcard_file.print("scaledX");
  sdcard_file.print(",");
  sdcard_file.print("scaledY");
  sdcard_file.print(",");
  sdcard_file.print("scaledZ");
  sdcard_file.print(",");
  sdcard_file.println(" ");
}

void loop() {
  delay(222);
  // Beschleunigungsmesser
  int rawX = analogRead(A0);
  int rawY = analogRead(A1);
  int rawZ = analogRead(A2);
  float scaledX, scaledY, scaledZ;
  if (micro_is_5V) {
    scaledX = mapf(rawX, 0, 675, -scale, scale);
    scaledY = mapf(rawY, 0, 675, -scale, scale);
    scaledZ = mapf(rawZ, 0, 675, -scale, scale);
  } else {
    scaledX = mapf(rawX, 0, 1023, -scale, scale);
    scaledY = mapf(rawY, 0, 1023, -scale, scale);
    scaledZ = mapf(rawZ, 0, 1023, -scale, scale);
  }
  // DS18B20 Temp
  sensors.requestTemperatures();
  int etemp = sensors.getTempCByIndex(0);
  // DHT22
  float h = dht.readHumidity();
  float t = dht.readTemperature();
  float f = dht.readTemperature(true);
  if (isnan(h) || isnan(t) || isnan(f)) {
    return;
  }
  float hif = dht.computeHeatIndex(f, h);
  float hic = dht.computeHeatIndex(t, h, false);
  // Daten loggen
  sdcard_file.print(etemp);
  sdcard_file.print(",");
  sdcard_file.print(t);
  sdcard_file.print(",");
  sdcard_file.print(h);
  sdcard_file.print(",");
  sdcard_file.print(hic);
  sdcard_file.print(",");
  sdcard_file.print(rawX);
  sdcard_file.print(",");
  sdcard_file.print(rawY);
  sdcard_file.print(",");
  sdcard_file.print(rawZ);
  sdcard_file.print(",");
  sdcard_file.print(scaledX);
  sdcard_file.print(",");
  sdcard_file.print(scaledY);
  sdcard_file.print(",");
  sdcard_file.print(scaledZ);
  sdcard_file.print(",");
  sdcard_file.print(" ");
  sdcard_file.println(" ");
  sdcard_file.close();
  delay(223);
}

float mapf(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;
}

Bei Problemen: Verkabelung prüfen, jeden Sensor einzeln testen. Wichtig: SD-/MicroSD-Karte muss auf FAT16 oder FAT32 formatiert sein und ≤ 16 GB groß sein.

LEDs für Statusanzeigen sind sinnvoll – ihr wollt nicht, dass der Ballon startet, ohne dass der Logger läuft. Prüft alles dreifach!

Falls SD-Kartenmodul Probleme macht: Stromversorgung wechseln. Manche Module sind sehr spannungsempfindlich.

Fertig! Euer Logger zeichnet Temperatur, Feuchte und Beschleunigung auf SD-Karte auf. Für Höhenmessung braucht ihr GPS – 90 % der barometrischen Höhenmesser versagen über 30.000 ft (ca. 9.100 m), was euer Ballon wahrscheinlich überschreitet. Für den Rest des Projekts (Ballon, Fallschirm, Füllung) schaut in verlinkte Guides. Bei Fragen kontaktiert uns!

Pfad 2 – Vorgefertigter PCB

Ihr wollt einen vorgefertigten PCB-Shield nutzen. Er liefert Innen-/Außentemperatur, Feuchte und Beschleunigung. Benötigte Teile:

5050 SMD LED
SparkFun ADXL337
Viele Header-Pins
Micro-SD-Kartenmodul
DHT22 Feuchtesensor
2× DS18B20 Temperatursensor
Arduino Mega
Der „Eclipse“ PCB

Die Gerber-Datei liegt im GitHub-Repository. Wollt ihr PCB/Schema anpassen, nutzt das dortige Formular. Wir erklären: Funktionsweise, Bestellung beim PCB-Service (ab 2 $), Bestückung.

Wir haben diesen PCB auf unserem Flug getestet und danach verbessert. Los geht's!

Gerber-Datei herunterladen & PCB bestellen

GitHub-Repo besuchen, ZIP herunterladen, Gerber-Datei „Eclipse“ entnehmen (ZIP belassen, Services erwarten ZIPs).
PCB-Service suchen (z. B. JLCPCB für günstig, US-Anbieter für schneller). Qualität ist bei allen gut.
ZIP hochladen, folgende Einstellungen wählen:
- Layer & Maße unverändert
- Single PCB
- 1,6 mm Dicke
- Farbe nach Wahl (Grün geht am schnellsten)
- Oberflächenfinish: HASL (mit Blei) – bei bleifreiem Lötzinn anpassen
- 1 oz Kupfer
- Keine Goldfinger, Produktionsdatei bestätigen
- Flying Probe Test: Fully Test
- Keine Castellated Holes
- Menge nach Bedarf
Bestellen – Produktion startet. Parallel Sensoren bestellen.

PCB bestücken

Da wir Sensoren auf Breakout-Boards nutzen und der PCB als Shield dient, ist das Bestücken einfach. Unten ein Lötleitfaden:

Alle Header-Pins an den PCB-Seiten anlöten – sie passen direkt auf den Arduino Mega und übernehmen die komplette Verdrahtung.

Funktionsweise: Im PCB verlaufen 0,35 mm feine Leiterbahnen von jedem Sensor zu bestimmten Header-Pins, die dann mit dem Arduino verbunden sind. Das ergibt einen sauberen, robusten Aufbau – stabiler als Lochraster oder Steckbretter. Mehr zu PCB-Grundlagen in diesem Video.

PCB auf Mega stecken, an PC anschließen, Arduino IDE öffnen, Code „1.6“ aus GitHub-Repo laden.

MicroSD auf FAT16/FAT32 formatieren (≤ 16 GB, 2 GB reichen für 2-Stunden-Flug). Karte einstecken, Code hochladen. Im Serial Monitor sollte „SD Card found!“ erscheinen, Logging startet sofort.

10 Sek. warten, Karte entnehmen, am PC auslesen – es sollte eine .csv-Datei mit allen Daten liegen.

Code für Pfad 2 (falls GitHub nicht klappt):

// DHT22 Setup
#include "DHT.h"
#define DHTPIN 2
#define DHTTYPE DHT22
DHT dht(DHTPIN, DHTTYPE);

// SD Card Setup
#include 
#include 
File sdcard_file;
int CS_pin = 10;

// DS18B20 Temperatursensor
#include 
#include 
#define ONE_WIRE_BUS 3
OneWire oneWire(ONE_WIRE_BUS);
DallasTemperature sensors(&oneWire);

// MPL3115A2 Höhenmesser Setup
#include 
#include 
Adafruit_MPL3115A2 baro = Adafruit_MPL3115A2();

int scale = 3;
boolean micro_is_5V = true;

// LEDs
int Blue = 7;
int Red = 6;
int Green = 5;

void setup() {
  pinMode(23, INPUT); // Schalter zum Stoppen des SD-Schreibens
  sensors.begin();
  pinMode(Blue, OUTPUT);
  pinMode(Red, OUTPUT);
  pinMode(Green, OUTPUT);
  digitalWrite(Green, HIGH);
  dht.begin();
  pinMode(CS_pin, OUTPUT);
  if (SD.begin()) {
    // Grün blinken bei Erfolg
    digitalWrite(Green, LOW); digitalWrite(Green, HIGH);
    digitalWrite(Green, LOW); digitalWrite(Green, HIGH);
    digitalWrite(Green, LOW); digitalWrite(Green, HIGH);
  } else {
    digitalWrite(Green, LOW); digitalWrite(Red, HIGH); delay(5000); return;
  }
  sdcard_file = SD.open("data.csv", FILE_WRITE);
  if (sdcard_file) {
    digitalWrite(Red, LOW); digitalWrite(Blue, LOW); digitalWrite(Green, HIGH);
  } else {
    // Fehlerblinksequenz
    digitalWrite(Green, LOW); digitalWrite(Red, HIGH); delay(1000);
    digitalWrite(Red, LOW); digitalWrite(Blue, HIGH); delay(1000);
    digitalWrite(Green, LOW); digitalWrite(Red, HIGH); delay(1000);
    digitalWrite(Red, LOW); digitalWrite(Blue, HIGH); delay(1000);
    digitalWrite(Red, HIGH); digitalWrite(Blue, LOW);
  }
  // CSV-Header
  sdcard_file.print(",");
  sdcard_file.print("DS18B20");
  sdcard_file.print(",");
  sdcard_file.print("DHT22 Temp");
  sdcard_file.print(",");
  sdcard_file.print("Hum");
  sdcard_file.print(",");
  sdcard_file.print("H.InX");
  sdcard_file.print(",");
  sdcard_file.print("Int. Temp");
  sdcard_file.print(",");
  sdcard_file.print("Pres. Pasc.");
  sdcard_file.print(",");
  sdcard_file.print("alt.");
  sdcard_file.print(",");
  sdcard_file.print("rawX");
  sdcard_file.print(",");
  sdcard_file.print("rawY");
  sdcard_file.print(",");
  sdcard_file.print("rawZ");
  sdcard_file.print(",");
  sdcard_file.print("scaledX");
  sdcard_file.print(",");
  sdcard_file.print("scaledY");
  sdcard_file.print(",");
  sdcard_file.print("scaledZ");
}

void loop() {
  delay(222);
  digitalWrite(Green, LOW); digitalWrite(Blue, HIGH);
  if(! baro.begin()) { }
  float pascals = baro.getPressure();
  float altm = baro.getAltitude();
  float tempC = baro.getTemperature();

  // Beschleunigungsmesser
  int rawX = analogRead(A0);
  int rawY = analogRead(A1);
  int rawZ = analogRead(A2);
  float scaledX, scaledY, scaledZ;
  if (micro_is_5V) {
    scaledX = mapf(rawX, 0, 675, -scale, scale);
    scaledY = mapf(rawY, 0, 675, -scale, scale);
    scaledZ = mapf(rawZ, 0, 675, -scale, scale);
  } else {
    scaledX = mapf(rawX, 0, 1023, -scale, scale);
    scaledY = mapf(rawY, 0, 1023, -scale, scale);
    scaledZ = mapf(rawZ, 0, 1023, -scale, scale);
  }

  // DS18B20 Temp
  sensors.requestTemperatures();
  // DHT22
  float h = dht.readHumidity();
  float t = dht.readTemperature();
  float f = dht.readTemperature(true);
  if (isnan(h) || isnan(t) || isnan(f)) { return; }
  float hif = dht.computeHeatIndex(f, h);
  float hic = dht.computeHeatIndex(t, h, false);

  // Daten loggen
  sdcard_file.println(sensors.getTempCByIndex(0));
  sdcard_file.print(",");
  sdcard_file.print(t);
  sdcard_file.print(",");
  sdcard_file.print(h);
  sdcard_file.print(",");
  sdcard_file.print(hic);
  sdcard_file.print(",");
  sdcard_file.print(tempC);
  sdcard_file.print(",");
  sdcard_file.print(pascals);
  sdcard_file.print(",");
  sdcard_file.print(altm);
  sdcard_file.print(",");
  sdcard_file.print(rawX);
  sdcard_file.print(",");
  sdcard_file.print(rawY);
  sdcard_file.print(",");
  sdcard_file.print(rawZ);
  sdcard_file.print(",");
  sdcard_file.print(scaledX);
  sdcard_file.print(",");
  sdcard_file.print(scaledY);
  sdcard_file.print(",");
  sdcard_file.print(scaledZ);
  sdcard_file.print(",");
  delay(223);
  sdcard_file.close();
}

float mapf(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;
}

Fertig! Logger liest Temp, Feuchte, Beschleunigung, loggt auf SD. Für Höhe: GPS nötig (Barometer versagt > 30.000 ft). Für den Rest: verlinkte Guides nutzen. Fragen? Kontaktiert uns!

Pfad 3 – Eigenen PCB entwerfen

Diese Anleitung zeigt NICHT, wie man einen PCB entwirft. Ihr solltet das schon können oder lernen. Hier nur grundlegende Richtlinien (für USA!), damit ihr keine Gesetze brecht.

Zuerst: Brainstorming – was wollt ihr vom Flug? Typische Messgrößen:

Temperatur
Feuchte
Höhe
Luftqualität
Strahlung
GPS

Temperatursensor muss bis -50 °C (-58 °F) messen, so genau wie möglich. Achtung: Bei starker Sonneneinstrahlung zeigt der Sensor zu hohe Werte (Selbsterwärmung)!

Bergung: gleiche Optionen wie Pfad 1 (SPOT, APRS, Handy – Handy nicht empfohlen).

Gewicht: Nutzlast < 12 lbs, 6 lbs oder 4 lbs je nach Typ. Barometer für Höhe unbrauchbar (> 30.000 ft).

Stromversorgung: Extreme Kälte in der Stratosphäre! Batterien versagen, Arduino auch. Lösung: Logger in Styroporbox (Innentemperatur ~ Raumtemperatur). Alternativ: Solarpaneele, Handwärmer.

Alles durchdacht, Sensoren festgelegt, aufgeschrieben? Dann Schema und PCB entwerfen – Shield oder Voll-PCB, eure Entscheidung (ihr seid erfahren).

Nach Bau: ALLES doppelt prüfen, Funktion testen, Richtlinien einhalten.

Fertig! Logger zeichnet Temp, Feuchte, Beschleunigung auf SD. Höhe: GPS nötig. Rest: verlinkte Guides. Fragen? Kontaktiert uns!

Fazit

Wetterballons sind ein cooler, simpler Weg in die Stratosphäre. Kameras (bei uns 360°-Kamera) liefern tolle Aufnahmen und Daten, mit überschaubaren Regularien. Aber:

LEST DIES!

Alle Regeln beachten, Radarreflektor anbringen, NOTAM (Notice to Airmen) einreichen vor dem Start. Kollision mit Flugzeug ist möglich – Leben nicht gefährden! Alles so stabil bauen, dass nichts herunterfällt. FAA hat wenige Auflagen – nicht durch Regelverstöße erreichen, dass sie alles verbieten und es für alle ruinieren.

Ich hoffe, diese Anleitung hilft. Wir machen gerne solche Guides. Supportet unseren Club: YouTube-Kanal abonnieren, kommentieren, bei Problemen melden!

Happy Arduinoing! (Ist das überhaupt ein Wort?)

NM Rocketry Reviews

Custom Parts & Enclosures

STL-Datei für den Gimbal, der den SPOT Personal Tracker während des Flugs aufrecht hält.

Schaltpläne

Für Pfad 1:
Hochleistungs-Datenlogger für Arduino-Wetterballons
Referenz:

GitHub-Repository für PCB-Dateien und Code

Hier Gerber-Datei für vorgefertigten PCB und Code herunterladen:
https://github.com/nmrocketryreviews/HADLdatalogger

Arduino-gestütztes Wohnraum-Luftdurchflussmessgerät: Bau & Überwachung Kompaktes MIDI-Schlagzeug mit 3D-Druck selbst bauen

Herstellungsprozess

3d Drucken

Automatisierungssteuerung System

Industrietechnik