ESP32 ADC richtig auslesen: Analogwerte kalibrieren, Nichtlinearität & Rauschen in den Griff bekommen

Die vier Eigenheiten, die alle Probleme verursachen

Bevor Code hilft, muss klar sein, womit du es zu tun hast. Der ESP32-ADC weicht in vier Punkten von dem ab, was man vom AVR-Chip eines UNO R3 gewohnt ist:

Attenuation: der Vorteiler, den du kennen musst

Der eigentliche Wandler des ESP32 misst nur bis etwa 1,1 V. Damit du trotzdem 3,3 V messen kannst, sitzt davor ein umschaltbarer Abschwächer. Dessen Einstellung bestimmt Messbereich und Genauigkeit:

Das brauchst du

Dazu ein Multimeter. Ohne eine zweite Messquelle kannst du nicht kalibrieren, sondern nur raten.

1Erst messen, was der Chip wirklich tut

Bevor du irgendetwas korrigierst, brauchst du eine Bestandsaufnahme. Dieser Sketch zeigt Rohwert, Streuung und die eingebaute Kalibrierung nebeneinander:

#define ADC_PIN 34        // ADC1 - funktioniert auch mit aktivem WLAN

void setup() {
  Serial.begin(115200);
  delay(300);

  analogReadResolution(12);          // 0..4095
  analogSetPinAttenuation(ADC_PIN, ADC_11db);

  Serial.println(F("roh_min roh_max spanne mittel mV_kalibriert"));
}

void loop() {
  const uint16_t N = 200;

  uint32_t summe = 0;
  uint16_t minWert = 4095;
  uint16_t maxWert = 0;

  for (uint16_t i = 0; i < N; i++) {
    uint16_t w = analogRead(ADC_PIN);
    summe += w;
    if (w < minWert) minWert = w;
    if (w > maxWert) maxWert = w;
    delayMicroseconds(200);
  }

  uint16_t mittel = summe / N;

  // analogReadMilliVolts nutzt die im Chip gespeicherte Werkskalibrierung
  uint32_t mv = analogReadMilliVolts(ADC_PIN);

  Serial.print(minWert);   Serial.print('\t');
  Serial.print(maxWert);   Serial.print('\t');
  Serial.print(maxWert - minWert); Serial.print('\t');
  Serial.print(mittel);    Serial.print('\t');
  Serial.println(mv);

  delay(500);
}

2Rauschen bekämpfen: Oversampling und Median

Ein einzelner analogRead() ist beim ESP32 fast wertlos. Mit Mehrfachmessung und dem richtigen Filter wird daraus ein stabiler Wert:

// --- Median: killt einzelne Ausreisser komplett ---
uint16_t leseMedian(uint8_t pin, uint8_t n = 15) {
  uint16_t puffer[31];
  if (n > 31) n = 31;

  for (uint8_t i = 0; i < n; i++) {
    puffer[i] = analogRead(pin);
    delayMicroseconds(100);
  }

  // Einfaches Insertion-Sort - bei n < 32 voellig ausreichend
  for (uint8_t i = 1; i < n; i++) {
    uint16_t schluessel = puffer[i];
    int8_t j = i - 1;
    while (j >= 0 && puffer[j] > schluessel) {
      puffer[j + 1] = puffer[j];
      j--;
    }
    puffer[j + 1] = schluessel;
  }
  return puffer[n / 2];
}

// --- Getrimmter Mittelwert: robust und ohne Sortier-Overhead im Extremfall ---
uint32_t leseMillivoltStabil(uint8_t pin, uint8_t n = 32) {
  uint32_t summe = 0;
  uint32_t minW = 0xFFFFFFFF, maxW = 0;

  for (uint8_t i = 0; i < n; i++) {
    uint32_t w = analogReadMilliVolts(pin);
    summe += w;
    if (w < minW) minW = w;
    if (w > maxW) maxW = w;
    delayMicroseconds(150);
  }

  // Groessten und kleinsten Wert verwerfen
  summe -= (minW + maxW);
  return summe / (n - 2);
}

// --- EMA: glaettet langsame Signale ohne Puffer im RAM ---
float emaWert = NAN;

float leseGeglaettet(uint8_t pin, float alpha = 0.15) {
  float neu = (float) analogReadMilliVolts(pin);
  if (isnan(emaWert)) emaWert = neu;          // beim ersten Mal uebernehmen
  else emaWert = emaWert * (1.0 - alpha) + neu * alpha;
  return emaWert;
}

3Zwei-Punkt-Kalibrierung mit dem Multimeter

Wenn dir die Werkskalibrierung nicht genau genug ist – etwa beim Batteriewächter, wo 0,1 V über "laden" oder "nicht laden" entscheiden – hilft eine eigene Kalibrierung. Du misst zwei bekannte Punkte und legst eine Gerade hindurch:

// Zwei Messpunkte, mit dem Multimeter am Pin ermittelt.
// Waehle sie moeglichst weit auseinander, aber im spaeteren Arbeitsbereich.
const float P1_IST_MV = 500.0;    // Multimeter zeigte 0,500 V
const float P1_ADC_MV = 478.0;    // ESP32 meldete 478 mV

const float P2_IST_MV = 2500.0;   // Multimeter zeigte 2,500 V
const float P2_ADC_MV = 2431.0;   // ESP32 meldete 2431 mV

// Geradengleichung: ist = steigung * gemessen + offset
const float STEIGUNG = (P2_IST_MV - P1_IST_MV) / (P2_ADC_MV - P1_ADC_MV);
const float OFFSET   = P1_IST_MV - STEIGUNG * P1_ADC_MV;

float leseKalibriertMv(uint8_t pin) {
  float roh = (float) leseMillivoltStabil(pin, 32);
  return STEIGUNG * roh + OFFSET;
}

void kalibrierungAusgeben() {
  Serial.print(F("Steigung: "));
  Serial.print(STEIGUNG, 5);
  Serial.print(F("   Offset: "));
  Serial.print(OFFSET, 2);
  Serial.println(F(" mV"));
}

// --- Anwendung: Batteriewaechter fuer eine 18650-Zelle ---
// Spannungsteiler 100k / 100k halbiert die Zellspannung
#define BATT_PIN     35
const float TEILER_FAKTOR = 2.0;   // real nachmessen, nicht annehmen!

float batterieSpannung() {
  return leseKalibriertMv(BATT_PIN) * TEILER_FAKTOR / 1000.0;
}

uint8_t ladezustandProzent(float u) {
  // Grobe Kennlinie einer Li-Ion-Zelle unter kleiner Last
  if (u >= 4.15) return 100;
  if (u <= 3.30) return 0;

  if (u > 3.85) return (uint8_t)(70 + (u - 3.85) * (30.0 / 0.30));
  if (u > 3.60) return (uint8_t)(20 + (u - 3.60) * (50.0 / 0.25));
  return (uint8_t)((u - 3.30) * (20.0 / 0.30));
}

4Praxisfall: Bodenfeuchte und ACS712 sauber auswerten

Zwei Sensoren, zwei völlig verschiedene Kalibrierstrategien. Beim Feuchtesensor sind die Endpunkte willkürlich, beim Stromsensor zählt der Nullpunkt:

#define FEUCHTE_PIN  36     // ADC1
#define ACS_PIN      39     // ADC1

// --- Kapazitiver Bodenfeuchte-Sensor ---
// Beide Werte selbst ermitteln: einmal an der Luft, einmal im Wasserglas.
// Achtung: Der Sensor gibt bei TROCKEN den HOEHEREN Wert aus.
uint32_t TROCKEN_MV = 2650;
uint32_t NASS_MV    = 1180;

void feuchteKalibrieren() {
  Serial.println(F("Sensor an die Luft halten, dann Taste im Monitor..."));
  while (!Serial.available()) { delay(50); }
  while (Serial.available()) Serial.read();
  TROCKEN_MV = leseMillivoltStabil(FEUCHTE_PIN, 64);
  Serial.print(F("Trocken: ")); Serial.println(TROCKEN_MV);

  Serial.println(F("Sensor ins Wasser, dann Taste..."));
  while (!Serial.available()) { delay(50); }
  while (Serial.available()) Serial.read();
  NASS_MV = leseMillivoltStabil(FEUCHTE_PIN, 64);
  Serial.print(F("Nass: ")); Serial.println(NASS_MV);
}

int8_t feuchteProzent() {
  uint32_t mv = leseMillivoltStabil(FEUCHTE_PIN, 32);

  if (TROCKEN_MV <= NASS_MV) return -1;         // Kalibrierung fehlt

  long p = map((long)mv, (long)TROCKEN_MV, (long)NASS_MV, 0, 100);
  return (int8_t) constrain(p, 0, 100);
}

// --- ACS712 5A: Nullpunkt ist alles ---
float acsNullMv = 2500.0;                       // Sollwert, wird ueberschrieben
const float ACS_MV_PRO_A = 185.0;               // 5A-Variante: 185 mV/A

void acsNullpunktMessen() {
  // WICHTIG: dabei darf kein Strom fliessen
  Serial.println(F("Verbraucher abklemmen, dann Taste..."));
  while (!Serial.available()) { delay(50); }
  while (Serial.available()) Serial.read();

  uint32_t summe = 0;
  for (uint16_t i = 0; i < 200; i++) {
    summe += analogReadMilliVolts(ACS_PIN);
    delay(2);
  }
  acsNullMv = summe / 200.0;

  Serial.print(F("Nullpunkt: "));
  Serial.print(acsNullMv, 1);
  Serial.println(F(" mV"));
}

float stromAmpere() {
  float mv = (float) leseMillivoltStabil(ACS_PIN, 32);
  float a  = (mv - acsNullMv) / ACS_MV_PRO_A;

  // Totband: unter 40 mA ist die Messung ohnehin nur Rauschen
  if (fabs(a) < 0.04) a = 0.0;
  return a;
}

5Anzeige mit Rauschband auf dem OLED

Eine reine Zahl verrät nicht, wie stabil sie ist. Diese Anzeige zeigt zusätzlich, wie weit die Einzelmessungen streuen – damit siehst du sofort, ob dein Filter reicht:

#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>

Adafruit_SSD1306 display(128, 64, &Wire, -1);

struct Messung {
  float    mittelMv;
  uint16_t spanne;
};

Messung messeMitStreuung(uint8_t pin, uint8_t n = 40) {
  uint32_t summe = 0;
  uint32_t minW = 0xFFFFFFFF, maxW = 0;

  for (uint8_t i = 0; i < n; i++) {
    uint32_t w = analogReadMilliVolts(pin);
    summe += w;
    if (w < minW) minW = w;
    if (w > maxW) maxW = w;
    delayMicroseconds(150);
  }

  Messung m;
  m.mittelMv = summe / (float) n;
  m.spanne   = (uint16_t)(maxW - minW);
  return m;
}

void zeigeMessung(const Messung& m, uint16_t maxMv) {
  display.clearDisplay();

  display.setTextSize(1);
  display.setCursor(0, 0);
  display.print(F("ADC1 / GPIO34"));

  // Grosser Wert in Volt
  display.setTextSize(3);
  display.setCursor(0, 12);
  display.print(m.mittelMv / 1000.0, 3);
  display.setTextSize(1);
  display.print(F(" V"));

  // Balken mit dem Rauschband als Rahmen darum
  uint8_t x = map((long) m.mittelMv, 0, maxMv, 0, 126);
  uint8_t b = map((long) m.spanne,   0, maxMv, 0, 126);
  if (b < 2) b = 2;

  display.drawRect(0, 40, 128, 8, SSD1306_WHITE);
  display.fillRect(1, 41, x, 6, SSD1306_WHITE);

  // Streubreite als Markierung unterhalb
  int16_t links = (int16_t) x - b / 2;
  if (links < 0) links = 0;
  display.drawFastHLine(links, 50, b, SSD1306_WHITE);

  display.setCursor(0, 56);
  display.print(F("Streuung: "));
  display.print(m.spanne);
  display.print(F(" mV"));

  display.display();
}

Troubleshooting

Praxistipps

• Immer ADC1. GPIO32 bis GPIO39. Schreib es dir an den Monitor, wenn nötig – dieser eine Punkt spart mehr Zeit als alle Filter zusammen.
• analogReadMilliVolts() statt eigener Umrechnung. Die Werkskalibrierung im Chip ist besser als jede Formel, die du dir ausdenkst.
• Kleinste passende Attenuation wählen. Ein Signal, das nur bis 0,9 V geht, gehört auf ADC_0db – dort nutzt du den vollen Wandlerbereich.
• Hardware vor Software. 10 kΩ in Reihe, 100 nF gegen Masse. Zwei Bauteile aus dem Widerstands-Sortiment, die mehr bringen als fünfzig Zeilen Filtercode.
• Sensorleitungen kurz halten. Ab etwa 30 cm ungeschirmtem Kabel fängst du deutlich mehr Störungen ein. Bei längeren Strecken lieber direkt am Sensor digitalisieren und den Wert über I2C übertragen.
• Kalibrierwerte protokollieren. Schreib dir zu jedem Gerät auf, welche Werte du gemessen hast. Nach dem dritten gebauten Sensor weißt du sonst nicht mehr, welcher Wert zu welchem Board gehört.
• Beim Batteriebetrieb unter Last messen. Eine 18650-Zelle zeigt im Leerlauf 3,9 V und unter 500 mA Last 3,6 V. Miss dort, wo dein Gerät tatsächlich arbeitet – sonst schaltet der Unterspannungsschutz zu spät. Passend dazu: TP4056 & MT3608 für Akkuprojekte.
• Wenn es wirklich genau sein muss: Ein externer ADC über I2C umgeht alle Eigenheiten des internen Wandlers. Für die meisten Maker-Projekte ist das aber Überengineering – kalibriert und gefiltert reicht der interne ADC auf etwa 1 % genau, und das ist mehr als die Sensoren selbst hergeben.