Lernende Infrarot-Fernbedienung mit ESP32

In einem Kurs mit dem ESP32 kam die Frage, ob man einen Sender für eine Infrarot-Fernbedienung selbst bauen kann. Ja, das geht. Es ist eine schöne Anwendung für den ESP32.

Zielvorgaben

Worum geht es also? Die Idee war, Signale von einer vorhandenen Infrarot-Fernbedienung einzulesen und dann gesteuert durch den Mikrocontroller zu reproduzieren. Der Controller kann z.B. zu einer bestimmten Zeit das Radio einschalten. Oder man kann einen kleinen Web-Server programmieren, der vom Smartphone gesteuert Licht oder Musik ein- oder ausschaltet. Geräte lassen sich automatisch steuern, ohne dass irgendein Eingriff in das Gerät notwendig ist. Vieles ist denkbar.

Um die Komplexität in Grenzen zu halten, nehmen wir für den Anfang nur drei Kanäle. Es soll also 3 Tasten geben, die jeweils ein angelerntes Signal abspielen können. Eine weitere Taste wird gebraucht, um das kleine Gerät in den Lernmodus zu versetzen. Wenn die Anlern-Taste für eine bestimmte Zeit (hier 3 Sekunden) gedrückt wird, soll das Gerät bereit sein, Signale von einer IR-Fernbedienung zu empfangen und aufzuzeichnen. Schließlich möchten wir noch Leuchtdioden haben, die den aktuellen Status anzeigen. Und die angelernten Daten sollen natürlich dauerhaft über das Stromabschalten hinaus erhalten bleiben. Das ist dann eigentlich schon alles.

IR Signal-Übertragung

Wie funktioniert die IR-Signalübertragung? Die üblichen IR-Sender produzieren Lichtsignale, die mit einer festen Frequenz zwischen 36 und 40 kHz moduliert sind, also sehr schnell ein- und ausgeschaltet werden. Dieser Frequenzbereich wurde gewählt, um den Signalabstand zu Störungen möglichst groß zu halten, denn schließlich ist Infrarotlicht allgegenwärtig, sei es als natürliches Licht von der Sonne oder als gepulstes Licht von diversen Lampen. Die eigentliche Information (z.B. “Radio einschalten”) befindet sich digital kodiert in der zeitlichen Abfolge von kurzen und langen Pulsen (“bursts”) mit z.B. 38 kHz. Ein typisches Signal von einer Fernbedienung kann z.B. 30 Millisekunden lang sein und 30, 40 oder 50 Pulse von kurzer oder langer Dauer enthalten.

Soweit die Theorie. Zum Glück ist in diesem Fall die Praxis nicht weit: Man kann mit einem Oszilloskop das Signal einer IR-Fernbedienung an einer Infrarot-Photodiode gut beobachten.

Schaltung zur Messung des Infrarot-Signals mit einer IR-Fotodiode. Die Fotodiode muss in Sperrrichtung gepolt sein.
Gemessene 38 kHz Bursts einer IR-Fernbedienung, hier eine “Bose Wave” Anlage. Einzelne Bursts sind etwa 550 Mikrosekunden lang. Die gesamte Sequenz erstreckt sich über 30 Millisekunden.

Für unsere Anwendung müssen wir das Signal zum Glück nicht “verstehen”. Aber es muss möglichst exakt aufgezeichnet und wieder abgespielt werden, damit das empfangende Gerät entsprechend reagiert.

Hardware

Es ist relativ einfach, IR-Signale mit einem Mikrocontroller zu generieren. Mit einem Timer wird eine Rechteckschwingung von 38 kHz erzeugt und auf einen der Ports gegeben. Typische IR-Leuchtdioden vertragen Ströme von bis zu 100 mA, was den Port überfordern würde. Deshalb kommt ein einfacher Transistor hinzu, z.B. ein BC337, der das Signal verstärkt. Um die 3.3V Board-Spannung des ESP32 nicht zu sehr durch die 38 kHz Pulse von 100mA zu belasten, wird die Infrarot-LED mit einem 33 Ohm Widerstand nach +5V verschaltet. Damit ist der Strom auf etwas unter 100 mA begrenzt.

Auf der Empfangsseite wird eine Schaltung benötigt, die möglichst empfindlich und gleichzeitig selektiv 38 kHz-IR-Signale herausfiltert und diese dann als digitale Zustände Ein (= Signal vorhanden) oder Aus (= kein Signal vorhanden) verfügbar macht. Das könnte aufwendig werden, wenn es dafür nicht fertige und preisgünstige Komponenten gäbe. Ich verwende den TSOP1138. Dieser oder ähnliche Empfänger mit guter Selektivität und hoher Empfindlichkeit sind in der Arduino-Welt verbreitet und z.B. in Funduino-Bausätzen enthalten. Der TSOP1138 hat drei Anschlüsse: Ground, Spannungsversorgung Vs und Signalausgang. Das Datenblatt sagt, dass die Betriebsspannung 5V betragen sollte. Tatsächlich habe ich sehr gute Ergebnisse mit den 3.3V des ESP32 erreicht. Es besteht also kein Bedarf für Pegelumsetzer.

TSOP1138

Schließlich kommen noch 4 Taster und 3 Leuchtdioden dazu. Damit ist die Hardware komplett. Die Schaltung ist einfach und kann gut auf einem Steckbrett aufgebaut werden.

Schaltbild IR Remote Control
Die Schaltung ist schnell auf einem Breadboard zusammengesetzt. Oben links befindet sich die IR-Sende-Diode mit dem Transistor zur Verstärkung. Oben mittig ist der IR-Empfänger. Taster und Leuchtdioden befinden sich auf der rechten Seite.

Wenn der Schaltplan klar ist, kann man die entsprechenden GPIO-Nummern im Sketch bereitstellen. Das geschieht im Programm ganz am Anfang als globale Konstanten. Damit sind die Definitionen an einem Ort und können bei Bedarf schnell angepasst werden.

// pin assignments
const int bt_learn = 16;
const int bt_play[] = {17, 5, 18};
const int ir_receiver = 34, ir_transmitter = 33;
const int led[] = {27, 26, 25};

Software

Der eigentlich spannende Teil des Projekts ist die Software. Natürlich gibt es ausgefeilte Bibliotheken für die Bearbeitung von Infrarot-Signalen mit einem Arduino (z.B. die multi-protocol-infrared-remote-library von Ken Shirriff). Diese sind aber nicht unbedingt für den ESP32 geeignet. Außerdem fand ich es interessanter, die notwendige Funktionalität mit Board-Mitteln zu programmieren.

System-Takt in Mikrosekunden

Grundsätzlich gibt es zwei mögliche Ansätze, um Zeitverläufe von Signalen aufzuzeichnen:

  1. Man kann mit einem regelmäßigen, möglichst engen Abstand den Zustand des Eingangs-Port testen und den jeweils aktuellen Wert als 0 oder 1 abspeichern. Üblich ist z.B. eine Abtastrate von 50 Mikrosekunden. Der Nachteil dieser Methode besteht darin, dass die Abtastrate unweigerlich einen möglichen zeitlichen Fehler (hier +/- 25 Mikrosekunden) mitbringt.
  2. Alternativ kann der Eingangs-Port ständig mit hoher Geschwindigkeit abgefragt (“Polling”) und jeweils der Zeitpunkt der Umschaltung aufgezeichnet werden. Wenn das Polling ausreichend schnell geschieht, ist die zeitliche Auflösung dieser Methode besser. Dieser Ansatz setzt allerdings eine möglichst exakte System-Uhr im Bereich von Mikrosekunden voraus.

Glücklicherweise verfügt der ESP32 über genau das: Eine Timer-gesteuerte System-Uhr, die die Anzahl der Mikrosekunden seit dem Einschalten zur Verfügung stellt: esp_timer_get_time() (siehe ESP Referenz). Die Ausführung der Funktion benötigt selbst weniger als eine Mikrosekunde, stellt also keine besondere Systemlast dar.

Die Zeitpunkte (Mikrosekunden) des Anfangs (Einschalten) und Ende (Ausschaltens) der einzelnen Bursts werden in Arrays abgelegt. Da wir mit 3 Kanälen arbeiten, gibt es ein zwedimensionales Array, um die Signal-Zeitpunkte abzuspeichern: ir_data[3][250] . Es enthält drei Zeilen, wobei jede Zeile bis zu 250 Datenpunkte aufnehmen kann. In meinen bisherigen Versuchen waren in der Regel nie mehr als 100 Datenpunkte für ein IR-Signal notwendig – aber es kann nicht schaden, Luft nach oben zu lassen.

Zusätzlich benötigen wir noch jeweils eine Integer-Variable, die die tatsächliche Anzahl der Einträge in den Arrays abspeichert. Ich nenne sie ir_data_len[3], ebenfalls ein Array mit 3 Werten für drei Kanäle. ir_data[][] und ir_data_len[] werden als globale Variablen definiert, also im Programmablauf vor allen Funktionen.

// global constants 
const int channel_cnt = 3;                  // this version supports 3 channels (maximum is 10)
const uint16_t ir_data_size = 250;          // size of ir data sequence

// global variables
Preferences prefs;                            // access to non volatile storage (NVS)
uint32_t ir_data[channel_cnt][ir_data_size];  // IR data set, 3 rows of up to 250 data items each
int ir_data_len[channel_cnt] = {0, 0, 0};
bool learn_bt_pressed = false;

Funktion read_ir_data()

Damit wird die Funktion zum Einlesen der IR-Signale read_ir_data() unkompliziert. Die Funktion übernimmt einen Zeiger auf das Daten-Array, in dem die Daten abgelegt werden, und einen Zeiger auf die zugehörige Zähler-Variable. Am Anfang des Lesevorgangs wartet die Software auf das erste Signal von der IR-Fernbedienung und erfasst die aktuelle Startzeit (start_time). Ab jetzt wird bei jedem Wechsel des Eingangs-Ports die aktuelle Zeit gelesen, die Differenz zur Startzeit errechnet (time_stamp) und diese im Array gespeichert. Die boolesche Variable edge sorgt für die Unterscheidung zwischen dem Wechsel von LOW -> HIGH oder HIGH -> LOW. Nach dem Ablauf der voreingestellten Zeit, hier 250 Millisekunden, wird die Erfassung beendet. Die Arrays mit den Umschalt-Zeitpunkten bilden die Datenbasis für eine exakte Reproduktion des Signals.

/* read_ir_data ---------------------------------------------------------------------------
Reads a sequence of ir data via the IR receiver. Captures the start- and stop time points
of each burst and stores them to the array ir_data[]. Data reading continues until either 
the data storage is exceeded or reading timeout is reached. Flashes the corresponding LED
during the reading process. 
Input:    channel -> channel number (0 … 2)
Output:   array ir_data -> ir data points
          int *ir_data_len -> number of data points stored in the array 
*/
void read_ir_data(int channel, uint32_t ir_data[], int *ir_data_len) {
  long start_time;
  uint32_t time_stamp;
  bool edge = true;            // false for falling edge, true for rising edge

  ledcAttachPin(led[channel], led_pwm_channel);                     // flash LED
  ledcWrite(led_pwm_channel, 128);
  *ir_data_len = 0;                                                    // reset array index
  while (digitalRead(ir_receiver) == HIGH);                         // wait for falling edge
  start_time = esp_timer_get_time();                                // capture start time
  do {
    time_stamp = (uint32_t) (esp_timer_get_time() - start_time);    // refresh time stamp 
    if (edge) {                                                     
      if (digitalRead(ir_receiver) == HIGH) {                       // waiting for rising edge
        ir_data[*ir_data_len] = time_stamp;                            // capture time stamp
        ++*ir_data_len;
        edge = false;                                               // switch to falling edge
      };  
    } else {                                                       
      if (digitalRead(ir_receiver) == LOW) {                        // waiting for falling edge
        ir_data[*ir_data_len] = time_stamp;                            // capture time stamp 
        ++*ir_data_len;
        edge = true;                                                // switch to rising edge
      };  
    };
  } while ((time_stamp < ir_read_timeout) &amp;&amp; (*ir_data_len < ir_data_size));
  ledcDetachPin(led[channel]);                                      // clear flashing LED
  digitalWrite(led[channel], HIGH);                                 // switch off LED
}

Um die Arbeitsweise zu kontrollieren, gibt es eine Funktion print_ir_data(), die die eingelesenen Daten auf dem seriellen Monitor ausgibt. Hier die Daten für “Einschalten” bei der “Bose Wave” Anlage. Das Signal wird zum Zeitpunkt 0 eingeschaltet, nach 1047 Mikrosekunden aus, dann nach 2499 Mikrosekunden wieder ein, nach 3040 Mikrosekunden aus, usw.

Channel 0  IR data (71):
1047, 2499, 3040, 3521, 4041, 4491, 5032, 6490, 7034, 8489, 9038, 
9512, 10029, 10507, 11030, 12480, 13023, 13503, 14024, 15475, 16016, 17475, 
18019, 18497, 19010, 19466, 20011, 21465, 22015, 23465, 24007, 24486, 25009, 
26452, 27001, 77482, 78523, 79984, 80526, 81005, 81527, 82002, 82518, 83975, 
84521, 85974, 86524, 86992, 87515, 87992, 88516, 89964, 90508, 90987, 91510, 
92960, 93502, 94960, 95505, 95981, 96496, 96950, 97498, 98949, 99500, 100949, 
101493, 101971, 102494, 103937, 104486

PWM zur Erzeugung des 38 kHz-Signals

Zum Abspielen der aufgezeichneten Signale muss ein 38 kHz-Signal erzeugt und entsprechend ein- und ausgeschaltet werden. Dazu eignet sich die PWM-Funktion der Arduinos. Diese unterscheidet sich beim ESP32 von den 8-Bit-Arduinos, die über die Funktion analogWrite() verfügen. Der ESP32 hat mehr Hardware-Möglichkeiten, insbesondere mehr PWM-Kanäle. Hier wird die PWM mit drei Low Level-Funktionen gesteuert.

1) ledcSetup(<channel>, <frequency>, <bit resolution>); 
2) ledcAttachPin(<GPIO no>, <channel>);
3) ledcWrite(<channel>, <duty cycle>); 

Mit ledcSetup() wird der gewünschte PWM-Kanals konfiguriert. Die Frequenz ist in unserem Fall 38 kHz. Die Funktion ledcAttachPin() bindet den PWM-Kanal an einen der Ausgabe-Ports (hier der Port für die Infrarot-Leuchtdiode). Schließlich setzt ledcWrite() den gewünschten Duty-Cycle. Wir arbeiten mit einer Bit Resolution von 8, so dass der Wert für Duty Cycle zwischen 0 (entspricht dauerhaft Aus) und 255 (entspricht dauerhaft Ein) liegen darf.

Eine gute Zusammenfassung der PWM beim ESP32 gibt es hier: EPS32 Arduino LED PWM Fading.

Der entsprechende Code im setup()-Block sieht so aus:

  // setup PWM for IR transmitter
  ledcSetup(ir_pwm_channel, ir_pwm_frequency, 8);    // pwm runs with 8 bit resolution
  ledcAttachPin(ir_transmitter, ir_pwm_channel);
  ledcWrite(ir_pwm_channel, 0);                      // switch off the IR transmitter for now

Funktion play_ir_data()

Im Programm übernimmt die Funktion play_ir_data() die Aufgabe, das IR-Signal – basierend auf den angelernten Daten – zu reproduzieren. Dabei kommt wieder die System-Uhr zur Hilfe, um im richtigen Moment die jeweiligen Bursts ein- oder auszuschalten. Einschalten heißt, den Duty-Cycle auf die Hälfte des Maximalwertes, also 128, zu setzen, so dass das PWM ein möglichst ausgeprägtes 38 kHz Signal erzeugt. Ausschalten heißt, den Duty-Cycle auf 0 zu setzen.

/* play_ir_data ---------------------------------------------------------------------------
Plays an IR data sequence
Input:  array ir_data -> holds the start- and stop time points for the bursts
        int ir_data_len -> number of data points in the array
*/
void play_ir_data(uint32_t ir_data[], uint16_t ir_data_len) {
  long start_time;
  uint32_t time_stamp;
  bool edge = true;                     // true for active, false for pause
  int i = 0;

  if (ir_data_len == 0) return;         // if data set is empty, then nothing to do

  start_time = esp_timer_get_time();    // capture start time
  ledcWrite(ir_pwm_channel, 128);       // activate IR transmitter
  do {
    time_stamp = esp_timer_get_time() - start_time;
    if (time_stamp >= ir_data[i]) {
      if (edge) {
         ledcWrite(ir_pwm_channel, 0);    // stop IR transmitter
         edge = false;
      } else {
         ledcWrite(ir_pwm_channel, 128);  // activate IR transmitter
         edge = true;
      };
      ++i;
    }
  } while (i < ir_data_len);
  ledcWrite(ir_pwm_channel, 0);           // ensure that IR transmitter is stopped 
}

Das Oszilloskop zeigt, dass das ursprüngliche Signal mit guter Genauigkeit reproduziert wird.

Ausgangs-Signal am IR-Empfänger für die Funktion “Einschalten” des Bose Wave-Systems
Signal am GPIO-Ausgang des ESP32. Der zeitliche Verlauf des ursprünglichen Signals wird exakt reproduziert.

Daten langfristig sichern: Preferences

Schließlich gibt es noch die Anforderung, dass der ESP32 die Daten der gelernten Signale über das Ausschalten hinaus im Speicher behalten soll. Beim 8-Bit Arduino gibt es das EEPROM zum dauerhaften Abspeichern von Daten. Leider ist der Speicherplatz des EEPROMS begrenzt und die Programmierung dazu etwas umständlich.

Der ESP32 bietet die Möglichkeit, aus dem Programm heraus den Flash-Speicher, in der ESP-Terminologie non-volatile storage (NVS), zu lesen und zu beschreiben. Der hat natürlich sehr viel Platz. Im Arduino-Framework gibt es das Preference-Objekt, mit dem der Flash-Speicher erreichbar ist. Dazu wird ein globales Objekt prefs vom Typ Preferences erzeugt.

#include <Preferences.h>
Preferences prefs;

Dort kann man Bereiche einrichten, die zum Abspeichern beliebiger Daten zur Verfügung stehen. Der Bereich bekommt einen Namen, der als String übergeben wird, und wird mit Begin geöffnet. Der Name kann willkürlich gewählt werden, hier ir_nvs.

prefs.begin("ir_nvs", false);

False bedeutet, dass der Bereich sowohl gelesen als auch beschrieben werden darf. Zum Lesen und Schreiben gibt es die Objekt-Methoden get…() und put…(), jeweils für die üblichen Datentypen, z.B.

 prefs.putUShort(<name_string>, <int value>); 

zum Schreiben eines 16-Bit Integer-Wertes ohne Vorzeichen. Der name_string kann wieder beliebig gewählt werden, muss aber eindeutig sein und dient zur Identifikation der Variable. Eine gute Praxis ist, dafür den Namen der entsprechenden Variable im RAM zu verwenden.

Für Arrays und andere größere Objekte kann man auf die Funktion

prefs.putBytes(<name_string>, <pointer>, <size>);

zurückgreifen, die den entsprechenden Speicherbereich ins Flash kopiert und so dauerhaft verfügbar macht.

Als Gegenstück kann mit

 <short_value> = prefs.getUShort(<name_string>); 

der gespeicherte Wert gelesen werden. Wenn man auf einen bisher noch unbeschrieben Namen zugreift, bekommt man den Wert 0.

Im Programm werden nach dem Einschalten im setup()-Block die Anzahl der abgespeicherten Daten für die drei Kanäle aus dem Flash-Speicher in das Array ir_data_len[] gelesen. Wenn die Werte größer als 0 sind, dann gibt es tatsächlich abgelegte IR-Daten, die dann in das Array ir_data[][] im RAM kopiert werden und für die Funktion play_ir_data() zur Verfügung stehen.

  // read IR data from NVS
  char ir_len_str[10] = "ir_len_0", ir_data_str[10] = "ir_data_0";

  prefs.begin("ir_nvs", false);
  Serial.println();
  Serial.println("Reading NVS ir_data ");
  for (int i = 0; i < channel_cnt; ++i) {
    ir_len_str[7] = '0' + i;
    ir_data_str[8] = '0' + i;
    ir_data_len[i] = prefs.getUShort(ir_len_str);
    Serial.print("Channel " + String(i) + ": ");
    Serial.println(String(ir_data_len[i]) + " Entries");
    if (ir_data_len[i] > 0) 
      prefs.getBytes(ir_data_str, ir_data[i], ir_data_len[i] * sizeof(uint32_t));
  }       
  Serial.println();

Entsprechend werden nach dem Anlernen von IR-Signalen die Daten in den Flash-Speicher geschrieben, so dass sie dauerhaft erhalten bleiben und beim nächsten Einschalten des Geräts gelesen werden können. Das übernimmt die Funktion learn_sequence(), die nacheinander für alle 3 Kanäle die Funktion read_ir_data() aufruft und die Daten dann in den Flash-Speicher schreibt.

/* -------------------------------------------------------------------------------------*/
void learn_sequence(void) {
  char ir_len_str[10] = "ir_len_0", ir_data_str[10] = "ir_data_0";
  for (int i = 0; i < channel_cnt; ++i) {
    read_ir_data(i, ir_data[i], &amp;ir_data_len[i]);
    print_ir_data(i, ir_data[i], ir_data_len[i]);
    ir_len_str[7] = '0' + i;
    ir_data_str[8] = '0' + i;
    prefs.putUShort(ir_len_str, ir_data_len[i]);
    prefs.putBytes(ir_data_str, ir_data[i], ir_data_len[i] * sizeof(uint32_t));
  };
}

Alle Komponenten zusammen setzen

Damit sind die wesentlichen Komponenten für das System vorhanden. Die Schleife loop() fragt die Buttons ab und verzweigt in die jeweiligen Funktionen.

/* -------------------------------------------------------------------------------------*/
void loop() {
  uint8_t learn_pressed_cnt = 0;

  // check whether the learn button is pressed for at least 3 seconds
  while (digitalRead(bt_learn) == LOW) {
    delay(200);
    ++learn_pressed_cnt;
    if (learn_pressed_cnt >= 15) {
      learn_sequence();
      learn_pressed_cnt = 0;
    }
  }

  // check the play buttons and play correspoding sequence 
  for (int i = 0; i < channel_cnt; ++i) {
    if (digitalRead(bt_play[i]) == LOW) {
      digitalWrite(led[i], LOW);
      play_ir_data(ir_data[i], ir_data_len[i]);
      digitalWrite(led[i], HIGH);
      delay(250);
    }
  }

Die Bedienung geschieht folgendermaßen:

  • Nach dem Einschalten (Power On) werden die drei Leuchtdioden der Reihe nach kurz durchgeschaltet, um zu zeigen, dass das System aktiv ist.
  • Das Gerät kann drei verschiedene Signale aufzeichnen und abspielen. Dazu dienen die drei Taster. Ein Druck auf einen der Taster bewirkt das Aussenden des entsprechenden Signals. Dabei leuchtet die zugehörige Leuchtdiode kurz auf.
  • Um in den Lernmodus zu gelangen, muss die Anlern-Taste für mindestens 3 Sekunden gedrückt werden. Dann blinkt die Leuchtdiode des ersten Kanals in einem schnellen Rhythmus, um anzuzeigen, dass das Gerät auf ein Signal zum Anlernen wartet. Man sollte jetzt die Fernbedienung auf den IR-Empfänger richten und kurz (!) die gewünschte Funktion drücken. Nachdem das passiert ist, wiederholt sich der Vorgang für Kanal 2 und 3. Damit ist das Gerät programmiert und bereit zum Einsatz.

Hier das ganze Programm.

/* ir_remote_control

This scetch records and reproduces IR signals from any IR remote control.
The IR data is stored in NVS memory and therefore retained beyond power off.
This version supports 3 channels. It can easily be extended to more channels.

Pin assignments:
  bt_learn        input pullup    GPIO16          learn button, push for at least 3 seconds
  bt_play         input pullup    GPIO17, 5, 18   buttons to send signal 
  ir receiver     input           GPIO34          IR receiver chip, e.g.TSOP1138 
  ir transmitter  output          GPIO33          IR transmitter diode, connected via a transistor
  led             output          GPIO27, 26, 25  control leds
  
SLW 10-Sep-2019
*/

#include <Arduino.h>
#include <Preferences.h>

// pin assignments
const int bt_learn = 16;
const int bt_play[] = {17, 5, 18};
const int ir_receiver = 34, ir_transmitter = 33;
const int led[] = {27, 26, 25};

// global constants 
const int channel_cnt = 3;                  // this version supports 3 channels (maximum is 10)
const uint16_t ir_data_size = 250;          // size of ir data sequence
const uint16_t ir_pwm_frequency = 38000;    // ir signal sends at 38kHz
const uint8_t ir_pwm_channel = 0;           // first pwm channel for ir signal
const uint8_t led_pwm_channel = 2;          // second pwm channel for LEDs
const uint16_t led_pwm_frequency = 8;       // frequency for flashing LEDs
const uint32_t ir_read_timeout = 250000;    // max duration is 0.2 sec 

// global variables
Preferences prefs;                            // access to non volatile storage (NVS)
uint32_t ir_data[channel_cnt][ir_data_size];  // IR data set, 3 rows of up to 250 data items each
int ir_data_len[channel_cnt] = {0, 0, 0};
bool learn_bt_pressed = false;

/* startup_msg ---------------------------------------------------------------------------
Flashes the LEDs at startup, just to show that the system is active.
*/
void startup_msg(void) {
  for (int i = 0; i < channel_cnt; ++i) {
    digitalWrite(led[i], LOW);
    delay(500);
    digitalWrite(led[i], HIGH);
  }
}

/* read_ir_data ---------------------------------------------------------------------------
Reads a sequence of ir data via the IR receiver. Captures the start- and stop time points
of each burst and stores them to the array ir_data[]. Data reading continues until either 
the data storage is exceeded or reading timeout is reached. Flashes the corresponding led
during the reading process. 
Input:    channel number
Output:   array ir_data -> ir data points
          int *ir_data_len -> number of data points stored in the array 
*/
void read_ir_data(int channel, uint32_t ir_data[], int *ir_data_len) {
  long start_time;
  uint32_t time_stamp;
  bool edge = true;            // false for falling edge, true for rising edge

  ledcAttachPin(led[channel], led_pwm_channel);                     // flash LED
  ledcWrite(led_pwm_channel, 128);
  *ir_data_len = 0;                                                    // reset array index
  while (digitalRead(ir_receiver) == HIGH);                         // wait for falling edge
  start_time = esp_timer_get_time();                                // capture start time
  do {
    time_stamp = (uint32_t) (esp_timer_get_time() - start_time);    // refresh time stamp 
    if (edge) {                                                     
      if (digitalRead(ir_receiver) == HIGH) {                       // waiting for rising edge
        ir_data[*ir_data_len] = time_stamp;                            // capture time stamp
        ++*ir_data_len;
        edge = false;                                               // switch to falling edge
      };  
    } else {                                                       
      if (digitalRead(ir_receiver) == LOW) {                        // waiting for falling edge
        ir_data[*ir_data_len] = time_stamp;                            // capture time stamp 
        ++*ir_data_len;
        edge = true;                                                // switch to rising edge
      };  
    };
  } while ((time_stamp < ir_read_timeout) &amp;&amp; (*ir_data_len < ir_data_size));
  ledcDetachPin(led[channel]);                                      // clear flashing LED
  digitalWrite(led[channel], HIGH);                                 // switch off LED
}

/* play_ir_data ---------------------------------------------------------------------------
Plays an IR data sequence
Input:  array ir_data -> holds the start- and stop time points for the bursts
        int ir_data_len -> number of data points in the array
*/
void play_ir_data(uint32_t ir_data[], uint16_t ir_data_len) {
  long start_time;
  uint32_t time_stamp;
  bool edge = true;                     // true for active, false for pause
  int i = 0;

  if (ir_data_len == 0) return;         // if data set is empty, then nothing to do

  start_time = esp_timer_get_time();    // capture start time
  ledcWrite(ir_pwm_channel, 128);       // activate IR transmitter
  do {
    time_stamp = esp_timer_get_time() - start_time;
    if (time_stamp >= ir_data[i]) {
      if (edge) {
         ledcWrite(ir_pwm_channel, 0);    // stop IR transmitter
         edge = false;
      } else {
         ledcWrite(ir_pwm_channel, 128);  // activate IR transmitter
         edge = true;
      };
      ++i;
    }
  } while (i < ir_data_len);
  ledcWrite(ir_pwm_channel, 0);           // ensure that IR transmitter is stopped 
}

/* print_ir_data ---------------------------------------------------------------------------
Prints ir data to the serial monitor, for control purpose only
*/
void print_ir_data(int channel, uint32_t ir_data[], uint16_t ir_data_len) {
  int line_cnt = 0;

  Serial.println();
  Serial.print("Channel " + String(channel) + "  IR data (");
  Serial.print(ir_data_len);
  Serial.println("):");
  for (int i = 0; i < ir_data_len; ++i) {
    Serial.print(ir_data[i]);
    if (i < ir_data_len - 1) Serial.print(", ");
    ++line_cnt;
    if (line_cnt > 10) {
      Serial.println();
      line_cnt = 0;
    }
  }
  Serial.println();
}

/* -------------------------------------------------------------------------------------*/
void learn_sequence(void) {
  char ir_len_str[10] = "ir_len_0", ir_data_str[10] = "ir_data_0";
  for (int i = 0; i < channel_cnt; ++i) {
    read_ir_data(i, ir_data[i], &amp;ir_data_len[i]);
    print_ir_data(i, ir_data[i], ir_data_len[i]);
    ir_len_str[7] = '0' + i;
    ir_data_str[8] = '0' + i;
    prefs.putUShort(ir_len_str, ir_data_len[i]);
    prefs.putBytes(ir_data_str, ir_data[i], ir_data_len[i] * sizeof(uint32_t));
  };
}

/* -------------------------------------------------------------------------------------*/
void setup() {
  char ir_len_str[10] = "ir_len_0", ir_data_str[10] = "ir_data_0";

  Serial.begin(115200);

  // read IR data from NVS
  prefs.begin("ir_nvs", false);
  Serial.println();
  Serial.println("Reading NVS ir_data ");
  for (int i = 0; i < channel_cnt; ++i) {
    ir_len_str[7] = '0' + i;
    ir_data_str[8] = '0' + i;
    ir_data_len[i] = prefs.getUShort(ir_len_str);
    Serial.print("Channel " + String(i) + ": ");
    Serial.println(String(ir_data_len[i]) + " Entries");
    if (ir_data_len[i] > 0) 
      prefs.getBytes(ir_data_str, ir_data[i], ir_data_len[i] * sizeof(uint32_t));
  }       
  Serial.println();

  // set pin modes
  for (int i = 0; i < channel_cnt; ++i) {
    pinMode(bt_play[i], INPUT_PULLUP);        // define ports for buttons
    pinMode(led[i], OUTPUT);                  // define ports for LEDs
    digitalWrite(led[i], HIGH);               // switch off the LEDs
  };
  pinMode(bt_learn, INPUT_PULLUP);
  pinMode(ir_receiver, INPUT);
 
  // setup PWM for IR transmitter
  ledcSetup(ir_pwm_channel, ir_pwm_frequency, 8);    // pwm runs with 8 bit resolution
  ledcAttachPin(ir_transmitter, ir_pwm_channel);
  ledcWrite(ir_pwm_channel, 0);                      // switch off the IR transmitter, for now

  // setup PWM for flashing LEDs
  ledcSetup(led_pwm_channel, led_pwm_frequency, 8);

  // show welcome message
  startup_msg();
}

/* -------------------------------------------------------------------------------------*/
void loop() {
  uint8_t learn_pressed_cnt = 0;

  // check whether the learn button is pressed for at least 3 seconds
  while (digitalRead(bt_learn) == LOW) {
    delay(200);
    ++learn_pressed_cnt;
    if (learn_pressed_cnt >= 15) {
      learn_sequence();
      learn_pressed_cnt = 0;
    }
  }

  // check the play buttons and play correspoding sequence
  for (int i = 0; i < channel_cnt; ++i) {  
    if (digitalRead(bt_play[i]) == LOW) {
      digitalWrite(led[i], LOW);
      play_ir_data(ir_data[i], ir_data_len[i]);
      digitalWrite(led[i], HIGH);
      delay(250);
    }
  }
}

Fazit

Eine lernfähige IR-Fernbedienung kann mit dem ESP32 relativ schnell entwickelt werden. Das Gerät arbeitet zuverlässig und hat sich bei verschiedenen Anwendungen bewährt. Die Genauigkeit der Reproduktion ist sehr hoch. Bei mir haben die Zielgeräte bisher klaglos die Signale der “fremden” Fernbedienung akzeptiert.

Bei Bedarf kann die Anzahl der Kanäle weiter erhöht werden, solange GPIOs für Tasten und Leuchtdioden vorhanden sind.

Bleibt die Frage, ob der ESP32 für diese Anwendung Vorteile im Vergleich zum 8-Bit Arduino bietet. Natürlich kann man ein ähnliches Ergebnis auch mit eine Arduino Nano erreichen. Dabei würde es aber im RAM knapp. 3 * 250 Datenpunkte von jeweils 32 Bit belegen mehr als 2 kB und würden das verfügbare RAM des ATmega328 bereits überfordern. Außerdem macht sich beim ESP32 der schnelle Systemtakt für eine höhere Genauigkeit der reproduzierten Signale und der der große Flash-Speicher zum dauerhaften Ablegen der Sequenzen nützlich. Spätestens wenn mehr Kanäle notwendig werden, wird der 8-Bitter nicht ausreichen. Und als Erweiterung kann der ESp32 die Bedienung über ein Web-Interface ermöglichen, was ein weiterer Schritt in Richtung Smart-Home wäre.

Downloads

ESP32

Die 8-Bit Mikroprozessoren sind aus dem elektronischen Alltag nicht mehr wegzudenken. Es gibt kaum ein Projekt in meiner Werkstatt, das nicht mindestens einen ATmega328 verwendet, sei es als “nackter” Prozessor auf der Platine oder zusammen mit USB-Interface und Quarz als Arduino Nano. Die Chips sind zuverlässig, vielseitig und vertraut – wie ein Werkzeug, das sehr gut in der Hand liegt.

Aber das Design der AVR-Prozessoren geht zurück auf die 90er Jahre und stößt natürlich an Grenzen. Besonders wünschenswert wären mehr RAM-Speicher, eine Floating-Point-Unit, mehr Timer und eine höhere Taktrate, die für zeitkritische Anwendungen hilfreich sein kann. Schon seit einiger Zeit gibt es verschiedene 32-Bit-Prozessoren, die mit wesentlich mehr Leistung anbieten und für eigene Entwicklungen geeignet sind. Hervorzuheben sind die STM32-Controller von ST (Nucleo-Boards) oder die SAM D21-Chips von Microchip Technology. Beide haben es auch in die Arduino-Welt geschafft (z.B. Arduino Due, Arduino-Board mit 32-Bit Architektur). Jedoch haben sich diese Chips in der Maker-Szene nicht so durchgesetzt, wie man es hätte erwarten können.

Anders erging des dem ESP32, eine neuere Entwicklung der chinesischen Firma Espressif. Dieser Chip verfügt über (fast) alles, was das Bastler-Herz begehrt, arbeitet mit Taktfrequenzen bis zu 240 MHz und ist darüber hinaus auf kleinen, günstigen Breakout-Boards verfügbar. Espressif hat es geschafft, den ESP32 sehr gut in die Arduino-Welt einzubetten, so dass der Umstieg von anderen Arduinos nicht schwer fällt. So ist es vielleicht nicht überraschend, dass der ESP32 eine beachtliche Verbreitung gefunden hat.

ESP32 Breakout Boards: Links das ESP32 Dev Modul, das leider etwas zu breit für einfache Steckbretter ist, dafür aber sehr preisgünstig. Rechts das etwas teurere ESP32 Pico Board.

Ein Grund für die große Akzeptanz ist sicherlich die Tatsache, dass Espressif WLAN- und Bluetooth-Kommunikation integriert hat. Ein zweiter Prozessor kümmert sich um die Netzwerkschnittstellen und arbeitet die entsprechenden Protokolle ab. Als Anwendungsentwickler hat man auch bei aktivem Netzwerk den Hauptprozessor vollständig zur Verfügung und muss sich nicht mit den Details der Kommunikation beschäftigen. Damit sind auch kleine Projekte ohne großen Aufwand über das Netz erreichbar. Der ESP32 ist zu einer Ikone des Internet of Things (IoT) geworden.

Breakout-Boards

Bei den Boards für den ESP32 gibt es etwas Wildwuchs. In meiner Praxis arbeite ich mit dem ESP32 Dev Module oder dem ESP32 Pico Board. Leider ist das preisgünstige Dev Module etwas zu breit für einfache Breadboards. Man kann aber zwei Breadboards zusammenstecken, so dass das Dev Module gut Platz findet.

ESP32 Dev Module auf zwei zusammengesetzten Breadboards.

Und es muss nicht unbedingt ein Steckbrett sein. Ich habe die Boards mit entsprechenden Buchsen-Leisten auch auf fertigen Platinen im Einsatz.

Die Boards haben viele Pins. Hier ist eine Übersicht der Pins mit ihren wichtigsten Funktionen für das Dev Module:

ESP32 Dev Module Pinout

Wie üblich sind die Pins mehrfach belegt und bieten je nach Konfiguration verschiedenen Funktionen an. Es gibt aber eine Reihe von Einschränkungen:

  • Die Pins 34, 35, 36 und 39 sind nur als Eingänge verfügbar. Eine digitalWrite()-Anweisung für diese Ports wird von der Arduino-IDE klaglos akzeptiert, bleibt aber völlig wirkungslos.
  • GPIO 6 bis 11 werden für den integrierten Flash-Speicher verwendet und stehen daher nicht frei zur Verfügung.
  • Der zweite ADC ist nicht verfügbar, solange der WiFi-Modus aktiv ist.

Wen man diese Dinge nicht weiß, kann die Fehlersuche sehr mühsam werden. Eine gute Zusammenstellung der möglichen Verwendung der Pins gibt es hier: https://randomnerdtutorials.com/esp32-pinout-reference-gpios/

Viel Peripherie

Ich beschäftige mich seit einigen Jahren mit dem ESP32 und habe ihn für verschiedene Projekte eingesetzt, durchweg mit guten Resultaten. Selbst wenn das WLAN nicht gebraucht wird, verfügt der Chip über eine ganze Menge nützlicher Peripherie. Neben den GPIOs und den üblichen Schnittstellen (ISP, SPI, UART) gibt es zwei ADCs, einen DAC, Deep-Sleep-Modus, Zugriff auf den Flash zur permanenten Speicherung von Daten und vieles mehr. Einzig die ADCs erfüllen nicht ganz die Erwartungen. Sie arbeiten zwar mit einer Auflösung von bis zu beachtlichen 12 Bit, leider aber mit mäßiger Linearität (siehe ESP32 ADC Non-linear Issue). Damit sind die ADCs für absolute und genaue Messungen nur eingeschränkt brauchbar. Für relative Vergleiche von Messwerten reicht es aber auf jeden Fall. Wenn für eine gegebene Anwendung ein exakter ADC unentbehrlich ist, dann bleibt natürlich noch die Möglichkeit, einen externen ADC über I2C oder SPI anzuschließen. Ein Ansatz, der z.B. beim Raspberry Pi in jedem Fall notwendig ist.

Vereinfachtes Pinout des ESP32 Dev Module

PlatformIO als Entwicklungsumgebung

Es gibt eine Reihe von Entwicklungsumgebungen, die zur Programmierung verwendet werden können. An erster Stelle steht natürlich die Arduino-IDE, die über den Boardverwalter mit der URL https://dl.espressif.com/dl/package_esp32_index.json für den ESP32 leicht erweitert werden kann. Man fühlt sich schnell Zuhause, wenn auch die Arduino-IDE für komplexere Projekte zu einfach gestrickt ist.

Eine positive Überraschung war für mich PlatformIO (https://platformio.org/), eine komfortable, plattform-übergreifende und als Open Source kostenlose IDE, mit der ich inzwischen sehr gerne an Mikrocontroller-Projekten arbeite. Die Bibliotheken für Arduino und für den ESP32 werden als Extensions installiert. Danach hat man eine große Auswahl an ESP32-Boards.

Der Umgang mit PlatformIO ist im Vergleich zur Arduino IDE etwas gewöhnungsbedürftig. Aber schon nach kurzer Zeit findet man alles, was gebraucht wird. Die zentralen Projekt-Einstellungen werden über die Datei platformio.ini vorgenommen. Hier ein typisches Beispiel für den ESP32:

platformio.ini für ein Projekt mit dem ESP32

Der serielle Monitor, als Debugging-Tool unerlässlich, lässt sich unter den Project Tasks mit “Monitor” anwählen. Mit “Upload and Monitor” wird direkt nach dem Laden des Programms der serielle Monitor aktiviert.

PlatformIO Tasks. Hier findet sich auch der serielle Monitor.

Außerdem sind die wichtigsten Funktionen (Übersetzen, Upload, serieller Monitor und mehr) über eine kleine Taskleiste am unteren Bildschirmrand verfügbar.

PlatformIO Task-Leiste mit vielen Funktionen

Die umfangreiche Funktionalität des ESP32 ist weitgehend in Arduino-Funktionen verpackt, so dass die ersten Programme ohne große Umstellung funktionieren. Wenn man auf spezifische Funktionen des ESP32 zugreifen möchte, dann ist auch das kein Problem. Wie üblich im Ardunio Framework sind die Bibliotheken des Herstellers (nach Einbinden der entsprechenden Header-Files) transparent verfügbar, z.B. Funktionen wie adc1_get_raw(), um den ADC anzusprechen, oder esp_adc_cal_raw_to_voltage() für die Umrechnung der Werte mit Kompensierung von Referenzspannungs-Abweichungen (siehe ESP ADC Reference). Damit steht dem tieferen Einstieg in die Welt des ESP32 nichts im Wege – sofern man bereit ist, sich durch die Beschreibungen und Datenblätter zu arbeiten.

Fazit

Der ESp32 hat sich schnell in meinen Arbeitsalltag integriert und kommt oft zum Einsatz. Umfang und Leistungsfähigkeit stehen zwischen den 8-Bit AVRs auf der einen Seite und dem Raspberry Pi auf der anderen Seite. wobei der Chip kaum teurer ist, als ein einfacher Arduino. Die Integration in das Arduino-Framework und die Verfügbarkeit einer leistungsfähigen Open Source-IDE lassen kaum Wünsche offen.

Software-Update für den Gewitter Monitor v2

Gestern ist wieder einmal ein heftiges Gewitter durch unsere Region gezogen und hinterließ seine Spuren auf dem Display des Gewitter-Monitors. Das war eine gute Gelegenheit, die letzten Software-Updates zu testen. Zur Zeit des Fotos lag das Maximum des Gewitters etwa 1 Stunde zurück. Die Trendanalyse über die letzten 45 Minuten (jetzt durch Pfeilsymbole  unterstützt) zeigte, dass die Summe der Blitze pro Minute stark rückläufig war. Der Mittelwert der letzten 15 Minuten lag aber immer noch so hoch, dass alle drei Alarm-LEDs aktiviert waren.

Seitdem ich die Version 2 im Februar in Betrieb genommen hatte, gab es viele Gelegenheiten, die Funktion der Software im Detail zu testen. Allerlei Feinheiten mussten korrigiert werden. Besonders ärgerlich war ein Fehler in der Trendanalyse, der den Prozessor in eine Endlosschleife schickte, wenn die Zahl der Blitze pro Minute sehr hoch wurde. Außerdem gab es Ungereimtheiten mit der Anzeige des Maximums. Jetzt funktioniert aber alles so, wie es soll.

Die neue Software steht wie immer auf der Ressourcen-Seite zum Download bereit. Die neue Software benötigt die Smart I2C GLCD-Software ab Juni 2018. Sonst können die Pfeilsymbole nicht dargestellt werden.

Von Herrn Wolfgang Richter erreichte mich ein Foto. Er hat seinen Gewitter-Monitor in ein Gehäuse aus schwarzem ABS-Kunststoff (200 x 100 x 65 mm) gesetzt. Sehr schön ist die Antenne,  die über dem Gerät schwebt. Vielen Dank für das Foto!

Gewitter-Monitor von Wolfgang Richter

Herr Richter hat mich auch auf die Forschungen von Hans Baumer zu den sogenannten Sferics aufmerksam gemacht. Dabei handelt es sich um elektrische Entladungen in den Wolken, die ohne Lichterscheinungen von Blitzen einhergehen. Tatsächlich ist mir schon seit langem aufgefallen, dass der Gewitter-Monitor bei labilen Wetterlagen (feuchte und warme Luft) deutliche Aktivitäten anzeigt, und zwar schon lange bevor Gewitter zu beobachten sind. Hierbei handelt es sich wahrscheinlich um die genannten Sferics. Übrigens habe ich die Empfindlichkeit des Geräts so eingestellt, dass die Alarmlevel (rote Leuchtdioden) erst dann aktiviert werden, wenn tatsächliche Gewitter im Umkreis von einigen hundert km registriert sind. Zur Kontrolle eignet sich die sehr informative Website Blitzortung.org.

Neue Software für das Smart I2C Graphik-LCD

Es ist an der Zeit für ein paar kleine Updates zum beschriebenen I2C-Interface für Graphik LC Displays.

Erstens … wollte ich für den Gewitter-Monitor Pfeilsymbole haben, die die Trendanalyse unterstützen. Ein oder zwei Pfeil nach oben oder unten – so schwer kann das doch nicht sein. Herausgekommen ist ein weiterer Zeichensatz, Font #7, mit einigen Symbolen. Der neue Zeichensatz mit einer Höhe von 12 Pixeln wird auch im User-Dokument beschrieben.
Bei Gelegenheit werden noch ein paar Symbole dazu kommen.

Außerdem wurde der Startup-Screen, der sich nach dem Anlegen der Betriebsspannung zeigt, erweitert. Neben der Software-Versionsnummer und Datum werden der Display-Typ mit der Anzahl der Pixel in horizontaler Richtung, die I2C-Puffergröße und Adresse und die aktuelle Helligkeitseinstellung (0 …. 10) präsentiert. Übrigens lässt sich der Startup-Screen unterdrücken durch Abschalten des Verbose-Mode.

Smart I2C GLCD Startup Screen im “Verbose”-Mode

Abgesehen von diesen Erweiterungen und zwei kleinen Bugfixes wurde die Software nicht mehr verändert. Das Display hat sich als recht zuverlässig erwiesen.

Zweitens … ist der erste Satz Platinen (für Display Typ 3 mit 4 Zoll Diagonale) bereits verbaut und tut in verschiedenen Anwendungen seinen Dienst. Deshalb musste ich neue Platinen bestellen. Bei der Gelegenheit habe ich das Layout noch einmal überarbeitet. Die Platine ist etwas kleiner geworden. Es gibt ein Befestigungsloch, das mit dem entsprechenden Loch der Display-Platine fluchtet. Bei der Gelegenheit habe ich den PNP-Transistor für die Steuerung der Beleuchtung ausgetauscht. Der eher seltene BC636 wurde durch den Standard-Transistor BC327 ersetzt.

Neues Layout für das Smart I2C GLCD Interface
Neues Layout für das Smart I2C GLCD Interface

Transistor Q2 (ursprünglich BC636) wurde durch den weit verbreiteten BC327 ersetzt.

Und drittens … gibt es eine erweiterte Arduino-Library zur Ansteuerung des Displays. Die Bibliothek glcd_functions_avr ist speziell für die kleinen 8Bit-AVR-Prozessoren (z. B. ATmega168 oder ATmega328) gedacht, wie sie im Arduino Nano oder Uno zum Einsatz kommen. Dort hat man oft das ärgerliche Problem, dass der beschränkte RAM-Speicher (1 oder 2k Byte) nicht ausreicht. Das hat zwar mit dem Display erst einmal nichts zu tun. Aber wenn man viele Texte im Programm verwalten und auf dem Display anzeigen möchte, dann wird RAM-Speicherplatz sehr schnell eng.  Deshalb ist es sinnvoll, konstante Texte im viel größeren ROM-Speicher zu halten. Dazu gibt es die zusätzlichen Funktionen
draw_pgm_str()draw_center_pgm_str() und draw_radj_pgm_str(). Diese Funktionen übernehmen Texte direkt aus dem Programmspeicher, so dass dafür kein RAM “verbraucht” wird.

Diese zusätzlichen Funktionen machen aber nur Sinn für die kleinen AVR-Prozessoren. Deshalb sollten alle anderen Arduinos (z.B. mit STM32, ESP32, etc.), die wesentlich mehr RAM-Speicher zur Verfügung haben, die normale Library glcd_functions verwenden.

Die neuen Gerber-Files, Software und Dokumente sind auf der Ressourcen-Seite verfügbar.

Übrigens: Da ich jetzt einen kleinen Vorrat an Platinen habe, gebe ich gerne Einzelstücke zum Selbstkostenpreis ab. Einfach per E-Mail melden.

Mehr Arduino-Training

Der Arduino-Kurs hat drei weitere Module bekommen. In “LC-Display” geht es um den Anschluss eines einfachen LC-Display, so dass Texte und Daten ausgegeben werden können. Das Modul “Bits und Bytes” behandelt die Eingabe über externe Taster. Zusammen mit dem Display wird daraus ein Reaktionszeit-Tester. Das dritte Modul, das neu dazu gekommen ist, bearbeitet Timer und Interrupts. So lassen sich quasi-parallele Aufgaben unabhängig voneinander ausführen.

Arduino Kurs – Bits und Bytes
Arduino Kurs – LC-Display
Arduino Kurs – Timer und Interrupts

Die Kursskripte und die zugehörigen Sketches sind auf der Ressourcen-Seite abrufbar.

Wie immer sind Kommentare und Anregungen willkommen.

Weitere Text-Funktionen für das Smart I2C Graphic Display

Das Smart-I2C Graphic Display kommt bei verschiedenen Projekten zum Einsatz. Neulich begegneten uns zwei Probleme, die zu kleinen Erweiterungen der Funktionalität führten.

Rechts-bündige Texte ausgeben

Manchmal ist es hilfreich, Texte rechtsbündig auszugeben.  Das ist zum Beispiel nützlich, wenn man mehrere Zahlenwerte untereinander positionieren möchte.

Also wurde die Firmware für das Display noch einmal geöffnet und um die Funktion draw_radj_str() erweitert. Der zugehörige Command-Token ist 37. Damit gibt es jetzt drei Funktionen zur Text-Ausgabe, wie in Smart I2C GLCD Instruction Set_v1-1 erläutert:

Ausschnitt aus dem Dokument "Smart I2C GLCD Instruction Set_v1.1.pdf"
Ausschnitt aus dem Dokument “Smart I2C GLCD Instruction Set_v1.1.pdf”

Das folgende Beispiel zeigt einen Arduino-Sketch, der die drei Text-Funktionen verwendet und die Ausgabe produziert, die hier als Beitrags-Bild zu sehen ist.

Arduino Beispiel-Programm, das die drei Funktionen der Text-Ausgabe zeigt.
Arduino Beispiel-Programm, das die drei Funktionen der Text-Ausgabe zeigt.

In der setup()-Funktion werden die drei Texte ausgegeben. In der loop()-Funktion wird dann gezeigt, wie man z.B. eine Zahl in die untere, rechte Ecke des Displays setzt. Dazu wird die Zahl mit itoa() in einen String konvertiert, der dann mit draw_radj_str() ausgegeben wird.

Die neue Firmware für das I2C GLCD und das Instructions-Dokument stehen auf der Ressourcen-Seite bereit. Auch die Arduino-Bibliothek wurde angepasst.

Texte aus dem Programm-Speicher ausgeben

Ein notorisches Problem der 8-Bit AVR-Prozessoren ist der sehr limitierte RAM-Speicherplatz. Zum Beispiel hat der ATmega328 nur 2 kByte RAM an Board. Die üblichen Funktionen zur Textausgabe, z.B.  draw_str(“Dieses ist Text”);  haben den Nachteil, dass der Text erst in das RAM kopiert wird, bevor er zur Ausgabe gelangt. Das ist für konstante Texte, wie sie z.B. als Titel-Texte, Menü-Items oder Beschriftungen häufig zum Einsatz kommen, nicht sinnvoll und führt schnell zu Engpässen im RAM-Speicher.

Zum Glück gibt es die Möglichkeit, Texte direkt aus dem Flash-Programm-Speicher auszugeben. Davon hat der ATmega eine ganze Menge zu bieten. Wenn man mit dem Atmel-Studio in C arbeitet, sieht das etwa so aus:

#include <avr/pgmspace.h>
#include "i2cmaster.h"

#define GLCD_DRAW_STR 33

/* glcd_draw_pgm_string ------------------------------------------
* Funktion to plot a zero-terminated string from program memory
*/
void glcd_draw_pgm_str(const char *my_str)
{
  char my_char;
  i2c_start_wait(GLCD_ADDR + I2C_WRITE);
  i2c_write(GLCD_DRAW_STR);
  do {
    my_char = pgm_read_byte(my_str);
    i2c_write(my_char);
    ++my_str;
  } while (my_char > 0);
  i2c_stop();
};

...

const char str_title[] PROGMEM = "Dieses ist ein Titel-Text";

glcd_draw_pgm_str(str_title);

...

Dieses Beispiel geht davon aus, dass die I2C-Funktionen bereit stehen. Ich verwende üblicherweise die I2C-Master-Bibliothek von Peter Fleury (siehe http://jump.to/fleury).

Natürlich klappt das auch mit dem Arduino. Die entsprechenden Funktionen zur Textausgabe aus dem Programm-Speicher wurden in die GLCD-Bibliothek arduino_glcd_functions aufgenommen und heißen draw_pgm_str(), draw_center_pgm_str() und draw_radj_pgm_str(). Die Anwendung ist damit sehr einfach, wie das folgende Beispiel zeigt:

#include <Wire.h>
#include <glcd_functions.h>
#include <avr/pgmspace.h>

const char str_title[] PROGMEM = "Dieses ist ein Titel-Text";

glcd gd(0x20);     // creates an instance of the Graphic LCD

...

gd.draw_pgm_str(str_title);     // plots a string from program memory

...

Die Arduino-Bibliothek mit den neuen Funktionen zur Textausgabe ist – wie immer  – auf der Ressourcen-Seite verfügbar.

Bleibt noch zu erwähnen, dass diese Methode natürlich nur für Texte und Strings klappt, die als Konstante definiert werden können und sich im Laufe des Programms nicht ändern. Und dass das Problem des limitierten RAM-Speichers eine AVR-8-Bit-Eigenart ist. Sobald man mit grösseren Prozessoren, z.B. den STM32-Prozessoren oder gar dem Raspberry Pi unterwegs ist, sind solche Klimmzüge zur Text-Ausgabe nicht mehr notwendig.

Ich hoffe, die neuen Funktionen sind hilfreiche. Kommentare und Rückmeldungen sind sehr willkommen.

 

 

 

Neues vom Gewitter-Monitor: Version 2

Der Gewitter-Monitor mit graphischer Anzeige war ein Projekt, das ich im Jahr 2014 fertig gestellt hatte. Seit dem habe ich das Gerät immer wieder einmal im Einsatz, und es tut gute Dienste. Inzwischen ist es aber an der Zeit für etwas Modell-Pflege. Rechtzeitig vor der nächsten Gewitter-Saison stelle ich hier die neue Version 2 vor.

Version 2 verwendet im Kern einen Arduino, wodurch das Programmieren und Flashen vereinfacht wurde. Das I2C-Smart Graphic LCD ermöglicht ansprechende Graphiken. Dazu gibt es eine vollständig neu entwickelte Software mit vielen neuen Features, z.B. einen mehrstufigen Alarm-Level, eine Trend-Analyse und ein Konfigurations-Menü.

Bewährtes Design mit neuen Funktionen

Das Grundprinzip des Gewitter-Monitors bleibt bestehen und wird hier kurz zusammengefasst.

Wer Radiohören noch aus den Zeiten von Mittelwelle und Langewelle kennt, der weiß, dass Gewitter-Blitze als störendes Krachen im Lautsprecher zu hören waren. Seit dem Umstieg auf Frequenzmodulation oder gar digitale Verfahren ist das aus unserem Radio-Alltag verschwunden. Das Prinzip eignet sich aber nach wie vor, um Gewitter-Blitze zu beobachten und zu registrieren.

Die hier vorgestellte Schaltung arbeitet mit zwei Langewelle-Empfängern, die auf einer freien Frequenz (ungefähr 100kHz) ständig in den Äther hören. Sobald ein Signal erfasst wird, wird es von einem Mikrocontroller untersucht. Typisch für Blitze sind schnell ansteigende Flanken (im Lautsprecher als “Knacken” vernehmbar), die mit Hilfe des Analog-Digital-Converters (ADC) im Mikrocontroller selektiert und vermessen werden. Die Software sammelt die Anzahl der registrierten Blitze und die Summe der Pegel, die für jeden Blitz erreicht werden. Die Daten werden dann auf einem graphischen Display angezeigt. Das Display zeigt nicht nur die aktuell gemessenen Werte, sondern auch den Verlauf über die letzten Stunden. Die Daten erlauben die Analyse des Alarm-Levels, der über Leuchtdioden angezeigt werden. Darüber hinaus gibt es eine Trend-Analyse, um abzuschätzen, wie sich die Gewitteraktivitäten entwickeln werden.

Block-Diagramm
Block-Diagramm

Der analoge Schaltungsteil des vorherigen Gewitter-Monitors mit AM-Empfängern und der Peak-Detection-Schaltung hat sich bewährt und wurde übernommen. Die einzige Veränderung bezieht sich auf die Zeitkonstante der Peak-Detection, was weiter unten beschrieben wird.

Es gibt aber drei wesentliche Neuerungen:

(1) Die erste Veränderung trägt dem Feedback von einigen Nachbauten Rechnung. Basierend auf der zunehmenden Popularität des Arduino-Frameworks habe ich mich entschlossen, den ATmega-Prozessor im DIL-Gehäuse durch einen Arduino Nano zu ersetzen. Ich muss zugeben, dass ich für meine Entwicklungen lieber direkt mit den AVR-Prozessoren arbeite. Die  Arduino-Boards waren bisher immer gross, teuer und unhandlich für die Entwicklung von eigenständigen Geräten. Mit der Verfügbarkeit des kleinen und preisgünstigen Arduino Nano-Boards hat sich das aber verändert. Die kleine Platine hat ein komplettes Kernsystem für den ATmega-Prozessor an Board, was den Aufbau vereinfacht. Es bleibt der Nachteil, dass der Arduino im Vergleich zu einem “nackten” ATmega-Prozessor relativ strom-hungrig ist, da die Peripherie, z.B. das USB-Interface und die eingebaute Leuchtdiode, immer unter Spannung stehen. Da der Gewitter-Monitor aber wahrscheinlich nicht mit Batterie-Strom betrieben wird, ist dieser Nachteil verschmerzbar.

Arduino Nano
Der Arduino Nano hat ein komplettes System auf einem kleinen Board: ATmega328 Prozessor, 16 MHz Quarz, USB-Interface, LEDs und Spannungsregler. Sogar ein Reset-Taster ist dabei.

(2) Die zweite Veränderung bezieht sich auf das Graphik-Display. Bei dem vorher verwendeten ST7920 gab es Beschaffungsprobleme für die SPI-Variante. Außerdem fand ich die u8glib-Bibliothek unhandlich. Was lag also näher als eines der gut verfügbaren KS0108-Displays einzusetzen und mit dem Smart-I2C-Interface zu kombinieren, das an anderer Stelle beschrieben ist (siehe Universelles I2C-Interface für Graphik-LCD). Konkret habe ich mich für das 4-Zoll Display (Typ 3) entschieden, dass mit einer Auflösung von 192 x 64 Pixeln bei ansprechender Größe neue Möglichkeiten eröffnet. Das Graphik LCD-Display ist z.B. bei eBay unter dem Stichwort 4″ 192×64 Graphic LCD Modul Display in verschiedenen Farben erhältlich.

(3) Und schließlich war es an der Zeit, die Software komplett zu überarbeiten. Der neue Gewitter-Monitor hat einige neue Funktionen bekommen, speziell zur Analyse des Alarm-Status und der Trend-Entwicklung. Außerdem lässt sich das neue System flexible konfigurieren über ein Menü zur Einstellung der wichtigsten Parameter. Die Software wurde komplett in der Arduino-Entwicklungsumgebung geschrieben und kann mit dem vorhandenen USB-Interface des Arduinos in den Programmspeicher übertragen werden. Ein separater AVR-Programmer ist dafür nicht notwendig.

Die Schaltung

Der neue Gewitter-Monitor besteht aus dem Antennen-Modul, das wie oben beschrieben ohne Veränderung von der vorherigen Version übernommen wurde, und dem Hauptteil, das für die Auswertung und Anzeige zuständig ist. Das Antennen-Modul wird über ein 6-poliges Flachband-Kabel mit dem Hauptteil verbunden.

Gewitter-Monitor Antennen Modul
Schaltung des Antennen Modul mit dem AM-Empfänger IC TA7642 und einer Ferritstab-Antenne. Dieses Modul ist zweimal vorhanden.

Hier arbeitet ein AM-Empfänger mit dem TA7642 und einem Ferritstab als magnetische Antenne. Der Ferritstab hat eine Richtwirkung mit engen aber stark ausgeprägten Minima in Richtung der Ferritstab-Achse. Deshalb werden zwei Empfänger eingesetzt, die senkrecht zueinander stehen. So wird eine lückenlose Abdeckung von 360 Grad erreicht.

Gewitter Monitor Antenne-Modul
Antenne-Modul mit zwei senkrecht zueinander angeordneten Ferritstäben

Der Hauptteil des Gerätes verwendet, wie oben beschrieben, einen Arduino Nano und das Smart-I2C-Graphic-Display.

Schaltung des neuen Gewitter Monitors
Schaltung des neuen Gewitter Monitors

Das Signal vom Antennen-Modul wird mit einem Transistor (BC549C) verstärkt und dann an die Peak-Detection-Schaltung mit dem Operationsverstärker MCP602 geführt. Diese Schaltung folgt ansteigen Flanken sehr schnell und lässt das Signal dann langsam abfallen. So wird es möglich, mit dem naturgemäß relativ langsamen ADC die kurzen Blitz-Impulse sicher zu erfassen. Die Funktionsweise der Peak-Detection lässt sich mit dem Oszilloskop beobachten.

Eingang und Ausgang der Peak-Detection.
Eingang (untere Kurve) und Ausgang (obere Kurve) der Peak-Detection-Schaltung. Die Anregung erfolgt mit einem kurzen Impuls von wenigen µsec und erzeugt eine abfallende Flanke über mehrere msec. Der ADC tastet den Eingang mit einer Periode von 500µsec ab (4 mal pro Raster-Einheit).

Im Gegensatz zum vorherigen Gewitter-Monitor wurde die ADC-Abtast-Frequenz erhöht auf 2000 Hz pro Kanal. Entsprechend konnte die Zeitkonstante der Peak-Detection-Schaltung reduziert werden (10nF statt vorher 100nF). Dadurch erreicht das neue System eine etwa 10-fach höhere zeitliche Auflösung. Ereignisse, die vorher als ein einziger Blitz registriert wurden, können jetzt in mehrere diskrete Blitze aufgelöst werden.

Rechts oben im Schaltplan befindet sich die Spannungsversorgung für das Antennen-Modul. Die Empfangs-Empfindlichkeit der TA7642-ICs lässt sich über die Versorgungsspannung einstellen. Die Schaltung verwendet eine Band Gap-Referenz (TL431), die exakte 2.5V produziert, und einen Emitterfolger mit einem weiteren BC549C. Mit einem Trimmer kann der gewünschte Spannungswert gewählt werden. Ich habe die besten Erfahrungen mit 1.6V gemacht, gemessen am Eingang des Antennenmoduls (vor der Diode).

Für die Bedienung des Geräts sind drei Tasten verfügbar, die mit Select, Down und Up bezeichnet sind. Die Tasten befinden sich zusammen mit den Leuchtdioden für die Anzeige des Alarm-Levels und der Blitz-Erkennung auf einer kleinen Platine, die hier als Front-Panel bezeichnet wird.

Die Spannungsversorgung der Schaltung geschieht über ein externes Stecker-Netzteil, das mindestens 7V liefern sollte. Der Strombedarf ist abhängig von der eingestellten Beleuchtungsstärke des Displays und liegt maximal bei 150mA. Intern arbeitet ein Festspannungsregler. Zwar hat der Arduino einen eigenen 5V-Regler an Board, den man auch zur Versorgung der anderen Schaltungsteile heranziehen könnte. Ich habe mich aber für eine separate Versorgung entschlossen, weil der Regler auf dem Arduino bei größeren Eingangsspannungen vom Stecker-Netzteil (in meinem Fall 12V) und Strömen oberhalb von 100mA durchaus recht warm werden.

Damit ist die Schaltung beschrieben. Durch den Einsatz des integrierten Arduino Nano-Boards ist der Aufbau überschaubar. Dazu trägt auch die Tatsache bei, dass der Audio-Verstärker, der in der vorherige Version vorhanden war, hier weggelassen wurde.  Es hat sich gezeigt, dass beim laufenden System keine Notwendigkeit besteht, das Signal akustisch auszugeben.

Rückseite des Gewitter Monitor v2
Ein Blick hinter die Kulissen: Im Inneren geht es recht aufgeräumt zu. Das Arduino-Board sitzt auf zwei 15-poligen Pfostenleisten, so dass man es im Falle eines Falles leicht austauschen kann. Die USB-Micro Buchse ist gut zugänglich.

Vollständig neue Software

Der Umstieg auf Arduino und das Smart-I2C-GLCD erforderte eine vollständige Überarbeitung der Software. Das Grundprinzip ist aber weitgehend gleich geblieben.

Die Software besteht aus 4 Modulen:

  • GewitterMonitor_v2.ino ist das Hauptprogramm mit den setup() und loop()-Funktion und der Timer-getriebene Interrupt-Routine
  • GewitterMonitor_graphs.ino beinhaltet die Funktionen zur Anzeige auf dem Display
  • GewitterMonitor_stats.ino beherbergt die Statistik-Funktionen
  • GewitterMonitor_config.ino ist für die Verwaltung der Konfiguration zuständig.

Zusätzlich benötigt das Programm die Arduino-Bibliothek für das Graphik-Display glcd_functions. Um erfolgreich zu kompilieren, muss sich der glcd_functions-Folder im librariers-Ordner der Arduino-Sketche befinden – – wie bei Arduino üblich.

File-Struktur im Arduino-Verzeichnis
File-Struktur im Arduino-Verzeichnis

Alle Dateien sind auf der Ressourcen-Seite zum Download verfügbar. Für die glcd_functions-Bibliothek muss darauf geachtet werden, dass die Version vom 21-Feb-2018 (oder neuer) benötigt wird.

Kernstück der Software ist die Interrupt-Routine im Hauptprogramm. Diese Routine wird durch einen Timer-Interrupt 4000 mal pro Sekunde aufgerufen und liest wechselweise die ADC-Kanäle 0 und 1 ein. Das bedeutet, dass die Ausgänge vom Antennen-Modul wie oben beschrieben 2000 mal pro Sekunde abgefragt werden. Wenn sich zwei aufeinanderfolgende Werte um einen bestimmten Wert unterscheiden, wird dieses als Erkennung einer ansteigenden Flanke gewertet und entsprechend ein Blitz registriert. Der Schwellwert zur Blitzerkennung ist ein wichtiger Parameter des Systems, der sich konfigurieren lässt. Kleinere Werte bedeuten höhere Empfindlichkeit aber auch höhere Anfälligkeit gegen Störsignale. Größere Werte bedeuten geringere Empfindlichkeit. Als Default-Wert wird 150 eingesetzt, was bei dem Wertebereich des ADC von 1024 also etwa 15% Ausschlag entspricht. Damit habe ich die besten Erfahrungen gemacht.

Wenn der Trigger für die Blitzerkennung ausgelöst wurde, ermittelt das Programm den Maximalwert des Blitzes. Für jede Minute speichert das Programm die Anzahl der Blitze (flash_cnt) und die Summe der gemessenen Blitz-Maxima (flash_sum) in einem Array ab. Die Werte der letzten 150 Minuten stehen zur Anzeige zur Verfügung.

4 verschiedene Alarm-Level

Der Alarm-Level soll Auskunft geben, wie stark oder möglicherweise gefährlich die derzeitige Gewitter-Aktivität ist. Diese Information mag den interessierten Wetterbeobachter erfreuen oder hilfreich sein, um z.B. ein geplantes Picknick im Freien zu verschieben oder eine windanfällige Markise einzufahren.

Das System kennt 4 verschiedene Alarm-Level. Der Alarm-Level 1 schaltet die Display-Beleuchtung ein. Die Idee ist, dass das Gerät bei geringer Gewitteraktivität selbstständig um Aufmerksamkeit bittet. Die folgenden Alarm-Level 2 bis 4 werden über die drei roten Leuchtdioden als aufsteigende Reihe angezeigt.

Für die Berechnung des Alarm-Levels werden die Daten der letzten 15 Minuten herangezogen, sofern nichts anderes eingestellt wurde. Das Zeitfenster für die Auswertung des Alarm-Levels (alarm window) ist wiederum ein Parameter, den der Anwender konfigurieren kann. Der Default-Wert von 15 Minuten kann zwischen 5 und 60 Minuten gewählt werden.

Die Datenbasis für den Alarm-Level ist das Array mit den Summenwerten der Blitze pro Minute (flash_sum). Das Programm erlaubt zwischen zwei verschiedenen Algorithmen zu wählen. Entweder wird der Durchschnittswert (average) der Summenwerte berechnet, oder es wird der Maximalwert (max) gesucht. Durchschnittswerte sind robuster gegen einzelne Ausreißer, aber sie reagieren auch träger auf Veränderungen. Hier muss man Erfahrung sammeln, um zu schauen, was sich am Besten eignet. Für meinen Einsatz bevorzuge ich die Durchschnittsberechnung. In jedem Fall liefert das Programm einen Wert, entweder Durchschnitt oder Maximum, der dann mit einem Alarm-Schwellwert verglichen wird. Wird der Schwellwert übertroffen, dann wird der Alarm-Level 1 ausgelöst. Die anderen Alarm-Level verhalten sich entsprechend einer geometrischen Reihe:

  • Durchschnitt oder Maximum > Schwellwert: Alarm-Level 1
  • Durchschnitt oder Maximum > 2 * Schwellwert: Alarm-Level 2
  • Durchschnitt oder Maximum > 4 * Schwellwert: Alarm-Level 3
  • Durchschnitt oder Maximum > 8 * Schwellwert: Alarm-Level 4

Man kann leicht erkennen, dass es bei einem Alarm-Level 4 wirklich gewaltig kracht und das Gewitter in direkter Nähe ist.

Der Schwellwert des Alarm-Levels (alarm threshold) lässt sich ebenfalls konfigurieren. Man kann sowohl den gewünschten Algorithmus (Durchschnitt oder Maximum) als auch den Wert selber wählen. Als Default-Wert verwendet das System die Durchschnitts-Methode bei einem Schwellwert von 50.

Ich muss an dieser Stelle erwähnen, dass ich aufgrund der winterlichen Wetterlage bisher noch keine praktische Erfahrung mit den Alarm-Leveln sammeln konnte. Sicherlich wird es im Laufe des Sommers den einen oder anderen Software-Update geben.

Anzeige und Bedienung

Nach diesen Erklärungen sind das Display und die Bedienelemente hoffentlich einleuchtend.

Display und Bedienungselemente
Display und Bedienungselemente

Das 4-Zoll Display macht den Hauptteil der Frontseite aus. Es gibt dort zwei Bereiche: Auf der rechten Seite werden die aktuellen Messdaten für die laufende Minute gezeigt. Count steht für die Anzahl der registrierten Blitze in dieser Minute, und Sum für den Summenwerte über die gemessenen Maxima. Der Sekundenzähler unten in Bild läuft immer von 0 bis 60. Sobald die Minute voll ist, werden die aktuellen Daten übernommen und in den Verlauf eingefügt, der dabei um eine Reihe (= eine Minute) nach links verschoben wird.

Im rückblickenden Verlauf steht jede vertikale Linie für die Summe der Blitze während einer Minute. Am oberen Rand ist die Zeit-Skala angedeutet. Die kleinen Striche stehen für jeweils 15 Minuten, und der etwas größere Strich für eine Stunde. Man muss beachten, dass die vertikale Achse automatisch skaliert wird, um auch den größten gemessenen Wert sinnvoll abbilden zu können. Wenn z.B. der größte gemessene Wert 350 ist, dann wird die Skala bis 500 skaliert, usw.

Die gepunktete vertikale Linie zeigt das Zeitfenster für die Berechnung des Alarm-Levels. Alle Werte zwischen der gepunkteten Linie und dem rechten Rand (der aktuellen Zeit) werden für die Berechnung der Alarm-Level herangezogen. Wenn man im Konfigurations-Menü das Zeitfenster anders einstellet, wandert die gepunktete Linien an ihren neuen Platz.

Oben links im Display wird das Maximum (max) und der Durchschnittswert (avg) für das aktuelle gewählte Zeitfenster angezeigt.

Die restlichen Bedienelemente sind schnell erklärt. Die beiden gelben Leuchtdioden oben leuchten kurz auf (200 msec), sobald ein Blitz registriert wurde. Mit den beiden gelben Tasten lassen sich die Graphik-Bildschirme durchschalten. Man kann entweder die Anzeige der Summen oder die Anzeige der Anzahl der Blitze wählen. Schließlich ist die rote Taste ist für das Konfigurations-Menü vorgesehen.

Die Beleuchtung der Anzeige schaltet sich nach einiger Zeit ab, sofern kein Alarm-Level gesetzt ist. Wenn der neugierige Zeitgenosse trotzdem die aktuellen Daten sehen möchte, genügt ein Druck auf eine der Tasten, womit die Beleuchtung für 2 Minuten aktiviert wird.

Trend-Analyse

Interessanter als der Verlauf der letzten Minuten oder Stunden ist eigentlich das, was kommt. Wird das Gewitter noch stärker werden oder zieht es ab? In die Zukunft schauen kann der Gewitter Monitor natürlich nicht. Aber die Daten der Vergangenheit geben Anhaltspunkte. Zu dem Zweck habe ich eine Trend-Analyse in das Programm aufgenommen. Genaugenommen wird eine lineare Regression nach der Methode der kleinsten Quadrate über die Werte der letzten 45 Minuten (Regressions-Zeitfenster) berechnet und angezeigt. Die resultierende Gerade kann ansteigen oder abfallen, was sich in einem positiven oder negativen Steigungs-Koeffizienten erkennen lässt. Dieser Wert wird angezeigt – allerdings nur, wenn der Korrelations-Koeffizient grösser als 0.5 ist und somit einen sinnvollen Zusammenhang zeigt. Positive Werte bedeuten also, dass die Gewitter-Aktivität in den letzten 45 Minuten zugenommen hat, während negative Werte die Abnahme anzeigen. Wenn die Messwerte durchgängig bei 0 liegen oder wild streuen, so dass die Statistik keinen Trend erkennen lässt, dann wird im Display nur “–.-” angezeigt.

Trend-Analyse mit linearer Regression.
Das Schlimmste ist vorbei! Trend-Analyse mit linearer Regression.

Die Trend-Analyse kann jederzeit mit den Up– oder Down-Tasten dazu geschaltet werden. Die beiden gelben Tasten laufen hintereinander 4 verschiedene Darstellungen durch:

  • Zeitverlauf der Summenwerte (Flash Sum)
  • Zeitverlauf der Summenwerte zusätzlich mit Trend-Analyse (Flash Sum + Trend)
  • Zeitverlauf der Anzahl der Blitze pro Minute (Flash Count)
  • Zeitverlauf der Anzahl der Blitze pro Minute mit Trend-Analyse (Flash Count + Trend)

Auch hier gilt die oben gemachte Bemerkung, dass ich bisher noch keine Erfahrung mit dieser Funktion sammeln konnte. Der Sommer wird möglicherweise Software-Updates bringen.

Konfiguration

Wie oben beschrieben gibt es die Möglichkeit, die wichtigsten System-Parameter zu konfigurieren und an den Aufstellungsort und die Anwender-Vorlieben anzupassen. Ein langer Druck (> 3 sec) auf die rote Select-Taste führt in das Konfigurations-Menü.

Konfigurations-Menü
Konfigurations-Menü

Die Auswahl des gewünschten Parameters erfolgt über die Up– and Down-Tasten. Dann führt ein Druck auf die rote Select-Taste in die Einstellung für den gewählten Wert.

Editieren eines Konfigurations-Wertes
Editieren eines Konfigurations-Wertes

Mit den Up– und Down-Tasten kann der gewählte Werte verändert werden. Ein weiterer Druck auf Select übernimmt den neuen Wert und führt zurück zum Menü. Mit der Anwahl des letzten Eintrags, Exit, verlässt man das Konfigurations-Menü.

Alle Parameter haben Default-Werte, die bei dem ersten Programmstart eingestellt werden. Diese Werte haben sich bisher als eine gute Wahl während des Testbetriebs herausgestellt.

Hier eine kurze Zusammenfassung der Konfigurations-Parameter mit ihren Default-Werten

  • Trigger threshold ist die minimale Schrittgröße zwischen zwei aufeinander folgenden Messwerten, um eine ansteigende Flanke als Blitz zu interpretieren. Kleine Werte erhöhen die Empfindlichkeit aber auch die Anfälligkeit gegenüber Störsignalen.
    Default-Wert: 150
  • Alarm window ist die Anzahl der letzten, verstrichenen Minuten, die zur Berechnung des Alarm-Levels herangezogen werden.
    Default-Wert: 15
  • Alarm threshold selektiert den Algorithmus (Durchschnitt oder Maximum) und den Schwellwert für das Setzen der Alarm-Levels. Alarm-Level 1 wird beim Überschreiten des einfachen Schwellwertes aktiviert, Alam-Level 2 beim doppelten Wert, usw.
    Default-Wert: Avg 50
  • Display light setzt die Helligkeit des Displays. Die Werte reichen von 0 (= 0%, aus) bis 10 (= 100%, maximale Helligkeit).
    Default-Wert: 8
  • Startup screen selektiert die Graphik, die nach dem Einschalten des Geräts gezeigt wird. Mögliche Werte sind:
    Flash Sum
    Flash Sum + Trend
    Flash Count
    Flash Count + Trend
    Default-Wert: Flash Sum

Es bleibt noch zu erwähnen, dass alle Konfigurations-Parameter im EEPROM des Prozessors abgelegt werden. Damit bleiben die eingestellten Parameter auch nach dem Abschalten (oder beim Überwintern im Bastelkeller) erhalten – wie es sich für eine Anwendung dieser Art gehört.

Aufstellung und Einstellung

Zum Schluss ein paar Tips für die Inbetriebnahme. Das Gerät empfängt die magnetische Komponenten der elektromagnetische Schwingungen von Blitzen. Zum Glück sind die magnetischen Störfelder im Haus meist weniger stark ausgeprägt als die elektrischen Felder. Trotzdem reagiert das Gerät empfindlich auf Störsignale von manchen Schaltnetzteilen. Das ist natürlich insbesondere relevant für das Stecker-Netzteil, mit dem das Gerät betrieben wird. Hier gibt es deutliche Unterschiede. Im Zweifelsfall ist es keine schlechte Idee, etwas mehr Geld zu investieren. In meinem Fall steht das Gerät in einer Fensterecke, die sich ein bisschen abseits von den anderen Geräten befindet.

Es kann sinnvoll sein, das Gerät an eine Erdung (z.B. Wasserleitung, Heizung, etc.) anzuschliessen. In meinem Fall konnte ich dadurch den Störpegel deutlich reduzieren und die Empfindlichkeit weiter erhöhen. Das sollte aber nicht unbedingt notwendig sein.

Für die erste Inbetriebnahme sollte die Versorgungsspannung des Antennen-Moduls am Trimpoti auf 1.6V eingestellt werden. Für die Software empfehlen sich die Default-Parameter wie oben beschrieben.  Nach dem Einschalten – und in Abwesenheit von Gewittern – sollten die Blitz-Indikatoren nicht aufleuchten. Wenn es gelegentlich ein Signal gibt, dann ist das normal und kommt wahrscheinlich von technischen Geräten. In jedem Fall sollten die Werte aber deutlich unter der Schwelle für den ersten Alarm-Level liegen.

Zum Testen der Funktion nehme ich eine alte 9V-Batterie, die ich mit einem etwa 30 cm langen Drahtstück ein paar Mal kurz schließe. Wenn ich das in etwa 20 bis 30 cm Entfernung von der Antenne mache, sollte das Gerät dies als Blitze registrieren. Wenn das geklappt hat, ist alles in Ordnung und man kann entspannt auf die nächste gewittrige Wetterlage warten.

Es gibt zwei Optionen, die Empfindlichkeit zu verändern. Zuerst kann man mit dem Trimmpoti die Antennen-Spannungsversorgung vergrößern (höhere Empfindlichkeit) oder verkleinern (geringere Empfindlichkeit). Als zweite Option, und besonders um unerwünschte Störsignale heraus zu filtern, kann der Konfigurations-Parameter Trigger Threshold verkleinert (höhere Empfindlichkeit) oder vergrößert (geringere Empfindlichkeit) werden.  Tatsächlich ist eine sehr große Empfindlichkeit gar nicht wünschenswert. In Sommernächten kann das Gerät Reichweiten von vielen 100 km erreichen. Dann ist es fraglich, ob man sich ein Gewitter in den fernen Alpen anzeigen lassen möchte.

Zum Schluss

Ich hoffe, dass der neuen Gewitter Monitor v2 das Interesse des einen oder anderen Bastlers weckt. Wie immer freue ich mich über Rückmeldungen, Kommentare, Vorschläge oder Ideen. Natürlich bin ich auch gerne bereit, bei der Beschaffung von Komponenten zu unterstützen oder Prozessoren zu programmieren.

Die Software hat ein gewisses Mass an Komplexität erreicht – und wird sicherlich allerlei Fehler enthalten. Auch hierzu sind Rückmeldungen willkommen. Ich gehe davon aus, dass es bei Gelegenheit Updates geben wird, die – Arduino sei Dank – über die USB-Schnittstelle sehr einfach eingespielt werden können.

Die Software für dieses Projekt kann von der Ressourcen-Seite herunter geladen werden.

 

 

 

 

 

 

Erste Begegnung mit 3D-Druck: Prusa I3

3D-Druck ist populär, und Drucker für den Heimgebrauch sind billiger geworden. Für den Elektroniker hat diese Technik viel zu bieten: Mechanische Kleinteil wie z.B. Gehäuse, Zahnräder, Seilrollen und ähnliches können im Handumdrehen selbst hergestellt werden. Das klingt so gut, dass es an der Zeit ist, die Technik selbst auszuprobieren.

Um es vorweg zu nehmen: Im Handumdrehen geht bei der 3D-Druckerei gar nichts. Der Weg vom Modell zum fertigen Produkt ist weit. Aber die Resultate können überzeugen!

Geeetech Prusa I3 X

Für meine ersten Versuche bestellte ich mir einen Bausatz der chinesischen Firma Geeetech, basierend auf dem quelloffenen FDM 3D-Drucker Prusa I3, ein einfaches und zuverlässiges Konzept, das sich bewährt hat. Geeetech ist einer von vielen Herstellern, die Prusa I3-Nachbauten anbieten.

Etwa eine Woche nach der Bestellung kam das Paket an. Es enthielt auf zwei Styropor-Lagen verteilt eine Unzahl von kleinen und großen Bauteilen, die alle gut geordnet und sorgfältig durchnummeriert waren. Per Email erreicht mich ein Link zu der PDF-Bauanleitung auf dem Geeetech-Server.

Bausatz-Inhalt
Bausatz-Inhalt, sorgfältig verpackt auf zwei Styropor-Lagen

Für den Zusammenbau sollte man sich Zeit nehmen. Laut Geeetech ist der Nachbau in 11 Stunden möglich. Davon würde ich abraten. Ich selbst habe 5 Tage benötigt, wobei ich jeden Tag 3 oder 4 Stunden investieren konnte. Die englischsprachige Anleitung ist gut gemacht und erklärt die Schritte mit vielen Bildern. Darüber hinaus gibt es einen Satz von YouTube-Videos, die alles ausführlich zeigen.

Der Rahmen des Geräts besteht im Wesentlichen aus 8 mm starken, schwarzen Acrylplatten. Die Teile sind exakt geschnitten. Ob das schwarz-glänzende “Klavierlack-Finish” für den Einsatz in der Werkstatt optimal ist, sei dahingestellt. Die Schrauberei ging bei guter Passgenauigkeit der Teile zügig voran. Zum Glück sind viele der Kleinteile in der Überzahl enthalten, so dass es kein Problem war, wenn ein kleines Schräubchen nicht mehr auffindbar war.

Allerdings scheinen einige Details ständig überarbeitet zu werden, so dass es immer wieder Abweichungen zwischen den Bildern und den tatsächlich vorhandenen Bauteilen gab. Insgesamt benötigte der Zusammenbau aktives Mitdenken und ein gutes technisches Verständnis. Leider fehlt eine gute Übersichtsbeschreibung des Gerätes mit Markierung der einzelnen Komponenten (in früheren Zeiten gab es so etwas als “Explosions-Zeichnung”), so dass ich streckenweise Bauteile zusammensetzte, ohne ihre Rolle zu verstehen. Wenn man dann etwas falsch zusammengesetzt hat, ist das aber kein Problem, weil alle Komponenten verschraubt sind und wieder gelöst werden können.

Zusammenbau des Prusa I3 Pro X
Der Zusammenbau macht Fortschritte

Es gab eine Hürde, die ich nach Bauanleitung nicht lösen konnte: Die Z-Achse machte Probleme. Während die X- (links/rechts) und Y- (vorne/hinten) Achsen durch Zahnriemen gesteuert werden, was auf Anhieb gut funktionierte, wird die Z-Achse (oben/unten) durch Gewindestangen bewegt.  Nach dem ersten Zusammenbau saßen die Gewindestangen so fest, dass sie sich absolut nicht mit den Motoren drehen ließen. Die 8 mm Führungslöcher in den entsprechenden Plastikteilen waren genau auf Größe geschnitten und ließen der M8-Stange keine Luft. Zur Behebung des Problems wurden die Löcher direkt am Schlitten und an der oberen Platte auf 10 mm aufgebohrt.

Aufbohren der Führungslöcher für die Gewindestange
Aufbohren der Führungslöcher für die Gewindestange

Da die Gewindestange jetzt keinen zuverlässigen Halt mehr hatte, setzte ich zur Stabilisierung auf die obere Platte jeweils ein Kugellager mit 8 mm Innendurchmesser. Dadurch war eine reibungsfreie Lagerung bei präziser Führung gewährleistet. Ähnliche Ansätze mit 3D-gedruckten Konstruktionen werden in den Foren diskutiert (Stichwort z axis wobble fix). In meinem Fall fiel die Wahl auf Sperrholz, weil ich eine Lösung brauchte, bevor der Drucker funktionsfähig war.

Kugellager am oberen Ende der Gewindestange
Nachträglich angebrachtes Kugellager am oberen Ende der Gewindestange zur reibungsfreien Führung

Außerdem hatte eine der beiliegenden Gewindestangen einen deutlichen Schlag und wurde durch eine Stange besserer Qualität aus dem Baumarkt ersetzt. Mit einigen wenigen Tropfen harz-freiem Öl an der Gewindemuffe auf der Gewindestange lief der Antrieb dann reibungsfrei.

Zum Abschluss wurde alle Komponenten elektrisch verbunden durch eine Vielzahl von Steckverbindungen – genau nach Bauanleitung. Wieder musste ich mich damit auseinander setzten, dass einige Details der Controller-Platine von der Beschreibung abwichen. Trotzdem war alles logisch und nachvollziehbar angeordnet.

Inbetriebnahme

Geeetech stellt ein zweites Dokument bereit, das User Manual, das die Inbetriebnahme und das Fine Tuning beschreibt. Bevor es zum Einschalten ging, musste die zugehörige Software auf dem steuernden PC installiert werden. Geeetech verwendet Repetier Host, ein gut etabliertes Open Source-Programm. Tatsächlich verlief die Installation auf meinem Windows 10-PC völlig problemlos.

Dann kam der spannende Moment: Strom ein! Aber kein Grund zur Aufregung. Die Verbindung zwischen PC und Controller-Board funktionierte sofort, und die Drucker-Funktionen ließen sich gut steuern. Vom PC aus lassen sich alle Achsen manuell ansteuern. So konnte ich auch die problematische Z-Achse ausprobieren und nachjustieren, bis es reibungslos lief.

Dann aber gab es Probleme beim Heizen des Extruders. Zwischenzeitlich zeigte das Geräte die “MINTEMP”-Fehlermeldungen, was bedeutet, dass der Thermistor einen Temperaturwert unter 19 Grad erfasst.  Anscheinend hatte der Thermistor im Alu-Block des Extruders keinen zuverlässigen Kontakt mit dem Board. Eine genauere Analyse ergab, dass die kleinen Steckverbinder am Alu-Block keine stabile Verbindung hatten. Die Kontakte befinden sich unter gelben Klebeband und sind deshalb nicht so leicht zu finden. Nachdem ich sie mit einer Zange nachgedrückt hatte, lief alles nach Plan. Das Klebeband habe ich inzwischen durch zwei Kabelbinder ersetzt. Übrigens konnte ich meinem Impuls, die Verbindungen mit dem Lötkolben dauerhaft zu machen, widerstehen. Das Problem dabei ist, dass die Lötstellen bei Temperaturen oberhalb von 200 Grad nicht halten. Also lieber klemmen!

Anschlüsse des Thermistors
Die Anschlüsse des Thermistors benötigten einen Druck mit der Zange, bis sie zuverlässig funktionierten

Zum Schluss musste noch das Druckbett nivelliert werden, was nach der Anleitung gut machbar war.

Dann konnte es losgehen. Geeetech legt 3 Meter gelbes Filament in den Karton. Der erste Versuch, einen runde Scheibe zu produzieren, die als *.stl-File auf dem Geeetech-Server bereitsteht, war weitgehend erfolgreich. Prima. Was kommt als nächstes?

Tool Chain

Sinn und Zweck des Druckers in meinem Elektronik-Labor ist es, nützliche Kleinteile für meine elektrischen Geräte zu produzieren. Der nächste Schritt ist also eine Software, die die Erstellung solcher Bauteile am PC ermöglicht. Meine Wahl fiel auf FreeCAD, ein beeindruckendes, wenn auch leider nicht ganz fehlerfreies Programm, um 3-dimensionale Objekte zu designen.  Auch dieses Programm braucht etwas Einarbeitungszeit. Zum Glück gibt es sehr hilfreiche YouTube-Tutorials, die die Grundlagen gut erklären. Man sollte sich aber Zeit nehmen.

Die Ausgaben von FreeCAD sind nicht ohne weiteres mit dem Drucker kompatible. Die Körper sind z.B. mit papier-dünnen Wänden definiert und nicht “wasserdicht” (mannigfaltig). In der Regel muss noch ein Mesh erzeugt werden, das die Körper füllt. Zwar kann FreeCAD auch diesen Schritt übernehmen. Ich habe aber besser Erfahrungen mit dem ebenfalls freien Programm Meshmixer von Autodesk gemacht. Dort lässt sich über die Funktionen edit -> solid fill ein Körper erzeugen, der dann direkt vom Repertier Host importiert und zum Druck geschickt werden kann.

Toolchain für den 3D-Druck
Der lange Weg von der Idee bis zum Produkt: Toolchain für den 3D-Druck

Ein weiteres praktisches Problem ergab sich dadurch, dass manches Mal der erste gedruckte Layer nicht recht auf der Alu-Fläche des Druckbettes halten wollte. Wenn der erste Layer nicht stabil liegt, dann endet der Druck über kurz oder lang im Chaos. Das ist ein viel diskutiertes Thema in den Internet-Foren. Dort fand ich auch Abhilfe: Eine Schicht Tesa Abdeckband für Maler (wieder aus dem Baumarkt meines Vertrauens), das ohne Lücke oder Überlapp auf die Alu-Platte geklebt wird, erhöht die Haftung. Wenn die Nivellierung stimmt, dann hält die erste Schicht absolut fest. Das Band ist Verbrauchsmaterial und musste nach ein paar Ausdrucken erneuert werden.

Prusa-Drucker bei der Arbeit
Der Prusa-Drucker bei der Arbeit. Hier wird ein Display-Halter produziert.

Endlich 3D drucken!

So, jetzt konnte es endlich losgehen. Als eines der ersten Objekte produzierte ich Halter für das Graphik LCD-Display, mit dem ich oft arbeite, so dass das Display bei meinen Experimenten nicht mehr lose auf dem Arbeitstisch liegen muss. Für eine bessere Druckqualität habe ich die Druckgeschwindigkeit etwas heruntergesetzt. Auch mit der Temperatur des Extruders kann man experimentieren. Die Zahl der Parameter zur Feinabstimmung ist groß und braucht Geduld und Experimentierfreude. Das Resultat ist dann aber wirklich sehr schön und ein wohlverdienter Lohn der Mühe!

Halter für das Graphik LCD
Halter für das Graphik LCD, designed mit FreeCAD und produziert mit dem Prusa I3

Es ist sehr erfreulich, wenn man dann das fertigen Bauteil vom Druckbett löst und ohne weitere Bearbeitung – keine Löcher bohren, keine Ausschnitte nachfeilen – an das Display schraubt.

Fazit

Der Geeetech Prusa I3 X ist gut geeignet für den Einstieg in die 3D-Druckerei. Der Bausatz ist durchdacht und bietet gute Qualität, wenn auch einige Details angepasst werden müssen. Die Bauanleitung beantwortet nicht alle Fragen, so dass Mitdenken, technisches Verständnis und gelegentliches Stöbern in einschlägigen Foren gefordert sind.

Der Einstieg in das Thema benötigt viel Zeit. Es ist sicherlich kein Consumer-Produkt, das nach Aufstellen und Einschalten bereits gute Ergebnisse produziert. Hier sind mehr Investitionen vom Anwender gefragt. Wenn man die Hürden aber genommen hat, dann eröffnet der Drucker enorme Möglichkeiten und belohnt den Anwender mit guter Qualität.

Mehr gedruckte Objekte werden folgen!

Download

FreeCad und konvertiertes STL-File für den Display-Halter: DisplayHalter

 

 

 

 

 

 

Laborpraxis: Ein versteckter Fehler

Wer mit Elektronik arbeitet, muss unweigerlich Fehler suchen. Das gehört einfach dazu. Es gibt sicherlich kein Projekt, das von der Idee bis zum Prototypen fehlerfrei funktioniert. Meistens kann man mit schrittweisem Vorgehen die Fehler einigermaßen gezielt lokalisieren und beseitigen. Jetzt ist mir aber ein verstecktes Problem begegnet, dass mich an der Weltordnung der Elektronik zweifeln ließ.

Es ging um eine Schaltung mit zwei ATmega-Prozessoren, die als Master und Slave über den I2C-Bus miteinander im Gespräch sind. Soweit so gut. Erst einmal funktionierte auch alles wie geplant, aber dann gab es sporadische Ausfälle.  Sporadisch, also nicht gezielt reproduzierbar, ist hier das Stichwort. Mal lief die Schaltung für Stunden ohne Probleme, und dann war plötzlich der I2C-Bus weg. Der Slave-Prozessor reagierte nicht mehr. Ein anderes Mal wollte die Schaltung schon nach dem Einschalten nicht so, wie sie sollte.

Zuerst einmal wurde gemessen. Das Oszilloskop zeigte ein vernünftiges I2C-Signal am Takt und auf der Datenleitung. Dann wurde die Software auf den Kopf gestellt. Stürzt die Slave-Software ab? Wo hängt die Geschichte? Aber ohne Ergebnisse. Eine regelmäßige blinkende LED wurde eingebaut, und als nach Stunden reibungsloser Tätigkeit der Fehler wieder auftauchte, zeigte die LED, dass der Slave nach wie vor sein Programm abarbeitete und auf Input wartete. Auch ein Austausch des Prozessors gegen ein fabrik-neues Exemplar brachte keine nachhaltige Besserung. Verflixt!

Als ich dann die laufende Platine in die Hand nahm, merkte ich, dass mechanische Spannungen, z.B. leichtes Verdrehen der beiden Seiten, den I2C-Bus wieder belebten. Also ein Lötproblem? Genaue Inspektion der Lötpunkte und Nachlöten aller I2C-involvierten Leitungen halfen immer noch nicht weiter. Mein Frustrationslevel erreichet den Siedepunkt. Ich legte die Platine zur Seite und baute einen zweiten Prototype, der für das Projekt sowieso gebraucht wurde. Und siehe da, diese zweite Platine arbeitet bis heute tadellos. Meine Elektroniker-Welt war halwegs wieder zurecht gerückt.

Aber natürlich war das Problem damit noch nicht behoben. Tage später setzte ich mich noch einmal an die fehlerhafte Platine. Dabei zog ich den Slave-Prozessor aus der Fassung, um ihn mit einem Software-Update zu versorgen. Und dann fiel es mir wie Schuppen von den Augen: Pin 27 der IC-Fassung sah irgendwie anders aus, als die anderen Pins. Genauer hingeschaut konnte ich erkennen, dass der innere Ring im Pin-Anschluss fehlte. Aha, eine fehlerhafte IC-Fassung! Ich steckte den Prozessor noch einmal in die Fassung und konnte mit einem Multimeter erkennen, dass Pin 27 nur gelegentlich Kontakt zum Chip hatte. Und tatsächlich: Bei diesem Pin handelt es sich um die Datenleitung des I2C-Bus.

Fehlerhafte IC-Fassung für den I2C-Slave-Prozessor
Fehlerhafte IC-Fassung für den I2C-Slave-Prozessor

Da es sich um “nur” um einen Prototypen handelte, wurde zur Fehlerbehebung der Pin des Prozessors direkt in der Fassung verlötet. Seit dem läuft die Platine tadellos.

Sporadische, nicht reproduzierbare Fehler brauchen Geduld und hohe Frustrationstoleranz. Um so schöner ist es, wenn der Fehler dann doch gefunden wird.

Ein Kollege sagte einmal: Wenn du frustriert bist, dann bist du dabei, etwas zu lernen! In diesem Sinne: Viel Erfolg beim Aufbau der nächsten Schaltung!

 

Nano-Scope: Oszilloskop mit Arduino und Graphic LC-Display

Kürzlich wurden in der Zeitschrift Elektor Mini-Oszilloskope besprochen. Es sind einfache Geräte, die im Kern einen Mikrocontroller mit schnellem Analog-Digital-Converter (ADC) aufweisen und mit einem einfach Display versehen sind. Die Ergebnisse sind durchaus beachtlich. Durch diesen Bericht animiert stellte ich mir die Frage: Kann man so etwas mit ganz einfachen Mitteln machen? Wie weit kommt man mit dem Arduino Nano, basierend auf einem ATmega32 mit 16MHz Taktfrequenz und einem I2C Graphic-LCD?

Die Frage lässt sich nur durch einen Test-Aufbau beantworten. Von Anfang an war klar, dass es kein “konkurrenzfähiges” Produkt werden soll. Die getesteten Mini-Oszilloskope sind so günstig zu kaufen, zum Teil als Bausatz, dass es keinen Sinn macht, ein vergleichbares Gerät selbst zu entwickeln. Hier geht es also um das Prinzip. Und wie immer gibt es dabei viel zu lernen.

Vorüberlegungen

Der ATmega32 hat einen ADC auf dem Chip, der bereits mit einer sample-and-hold Schaltung ausgerüstet und somit für die Erfassung dynamischer Spannungsverläufe gut geeignet ist. Die Grundidee ist ganz einfach: Ein regelmäßiger Timer-Interrupt liest mit Hilfe des ADC den aktuellen Spannungswert am Eingang ein. Mit einer Trigger-Logik wird festgestellt, ob ein (einstellbarer) Schwellwert (trigger threshold) überschritten wurde. Wenn das der Fall ist, erfolgt die Datensammlung in ein Array. Sobald das Array gefüllt ist, wird es als Kurve auf dem Display ausgegeben.

Die Auflösung des ADC beträgt 10 Bit, also Werte von 0 bis 1023, was mehr als genug ist für diese Anwendung. Tatsächlich ist das Display mit seinen vertikalen 64 Pixeln, also 6 Bit, der beschränkende Faktor. Im Programm wird die Auflösung in zwei Stufen reduziert. Zuerst einmal wird nur das höherwertige Byte des ADC ausgelesen. Das lässt sich einfach machen, indem das Flag for left adjusted result (ADLAR) gesetzt wird. Es bleiben also 8 Bit. Diese Auflösung wird für die Trigger-Logik verwendet. Für die Anzeige der Kurve auf dem Display wird der Wert dann noch einmal um 2 Bit nach rechts verschoben, wodurch der verbleibende Wertebereich 0 bis 63 beträgt und somit gut auf das Display passt.

Der ADC arbeitet hier mit der internen Spannungsreferenz des ATmega von knapp 1.1V, wodurch der Messbereich festgelegt ist. Für diese einfache Anwendung habe ich auf eine analoge Verstärkung oder Aufbereitung des Signals, wie es für ein praktisch einsetzbares Oszilloskop unabdingbar wäre,  verzichtet.

Eine kritische Frage ist die errechbare Geschwindigkeit des Daten-Samplings, ein wichtiges Qualitätsmerkmal jedes digitalen Oszilloskops. Der ADC des ATmega ist von einfacher Bauweise. Deshalb sollte man keine zu großen Ansprüche stellen. Der ADC wird mit einem internen Takt versorgt, der mit einem Vorteiler aus dem Systemtakt generiert wird. Das ATMEL Datenblatt empfiehlt Taktraten zwischen 50 und 200 kHz. Außerdem kann man dort erfahren, dass eine Umwandlung 13 Taktzyklen benötigt. Bei 200 kHz würde eine Umwandlung also 65µsec benötigen, was einer Sampling-Frequenz von 15 kHz entspricht. Geht es schneller? Das Datenblatt erwähnt, dass höhere Taktraten möglich sind, wenn man nicht die volle Auflösung von 10 Bit benötigt. Da in dieser Anwendung nur die höheren 8 Bit verwendet werden, habe ich mich für eine Taktrate von 500 kHz entschieden. Dadurch sinkt die Umwandlungszeit auf  26µsec, entsprechend 38kHz. Tatsächlich läuft die Abfrage des ADC mit einem Interrupt von 20kHz, was sich in den Experimenten als eine stabile Frequenz erwiesen hat. Man sollte aber nicht unterschätzen, dass der Prozessor damit unter signifikanter Systemlast steht.

Hardware

Der Aufbau ist minimalistisch und lässt sich schnell auf eine Steckbrett zusammen setzen. Im Zentrum stehen der Arduino Nano und das Graphik-Display, die über den I2C-Bus miteinander verbunden werden. Alle Details zum Graphik-Display sind an anderer Stelle beschrieben (Universelles I2C Interface für Graphik LC-Displays)  Die Stromversorgung kommt über den USB-Port des Arduino. Das zu messende Eingangssignal gelangt über einen Kondensator an den Analog-Port A0 des Arduino. Ein lineares 100kOhm-Poti fügt eine feste Gleichspannung hinzu, womit die vertikale Position eingestellt werden kann. Für die interne ADC Spannungsreferenz wird noch ein 100nF-Kondensator gegen Masse am Referenz-Pin benötigt.

Eine LED am digitalen Port D6 dient als Anzeige des Trigger-Modus. Schließlich gibt es noch vier Tasten an den digitalen Ports D2 bis D5, über die die horizontale Zeitachse und der Trigger-Level eingestellt werden können. Damit ist der Aufbau auch schon beschrieben.

Schaltplan des Arduino Nano-Oszilloskops
Schaltplan des Arduino Nano-Oszilloskops

Software

Der Arduino-Sketch sieht komplizierter aus als er ist. Allerdings habe ich für die Steuerung von Interrupt und ADC nicht die Arduino-Funktionen gewählt, sonder die ATmega-Register direkt angesprochen. So war es möglich, das enge Timing besser unter Kontrolle zu halten. Zum Glück ist all das innerhalb der Arduino-IDE ohne Probleme möglich.

Eine zentrale Funktion ist die Interrupt-Service-Routine (ISR), die mit 20kHz aufgerufen wird. In dieser Routine wir der ADC ausgelesen und gleich wieder gestartet für den nächsten Durchlauf. Darauf folgt die Trigger-Logik und bei gesetztem Trigger das Abspeichern der Daten im Array für die Anzeige. Im zweiten Teil der ISR werden die vier Tasten (im Programm-Code etwas hochtrabend als keyboard bezeichnet) abgefragt und entprellt. Es gibt sogar eine einfache Tasten-Repeat-Funktion.

Die Sampling-Frequenz lässt sich über die Tastatur herunter regeln, was einer langsameren Zeitachse entspricht. Die Tabelle sar_table enthält die möglichen Einstellungen. Die derzeitige Software erlaubt 7 verschiedene Werte. Die ISR läuft in jedem Fall mit 20kHz. Für langsamere Einstellungen werden mehrere ADC-Werte gemittelt wie in der Tabelle angegeben (interrupts per sample).

Einstellbereich der Zeitachse.
Einstellbereich der Zeitachse. Die Werte werden über die Taster angewählt. Der aktuelle Wert für die Dauer eines Rasterfeldes (time per grid) wird in der unteren, rechten Ecke des Displays angezeigt.

Die setup()-Funktion erledigt alle Systemeinstellung und zeichnet die statischen Elemente auf den Bildschirm. Die loop()-Funktion schließlich wartet auf das Signal von der Interrupt-Routine, dass Daten zur Anzeige bereitstehen, und erledigt dieses mit der glcd-Funktion draw_function(). Die Software ergänzt den Kurven-Verlauf mit einem Raster aus gepunkteten Linien. Außerdem werden im Hauptprogramm mögliche Aktivitäten des Keyboards ausgewertet.

Für die Datenanzeige gibt es noch eine erwähnenswerte Besonderheit. Bevor ein neuer Kurvenzug gezeichnet werden kann, muss vorher der bestehende, “alte” Kurvenzug gelöscht werden. In einer ersten Version des Programmes hatte ich dazu den Bildschirm vollständig gelöscht, was allerdings ein deutlich sichtbares Flackern zur Folge hatte. Eleganter geht das mit zwei Datenarrays. Eines enthält die vorherigen, “alten” Daten und wird zum Löschen benutzt, während das zweite die aktuellen, “neuen” Daten hat. Mit jedem Durchlauf wird zwischen den beiden Datenarrays hin- und hergeschaltet. Mit dieser Logik ist die Anzeige weitgehend frei von Flackern.

Anwendung

Die Anzeige ist einfach zu lesen. Die vertikalen, gepunkteten Linien sind das Raster für die Zeitachse. Die horizontale, gepunktete Linie zeigt den aktuelle Trigger-Wert. Am rechten Rand des Bildschirms befinden sich die eingestellten Parameter: der Trigger-Wert und die Zeitachse. Der Wert für die Zeitachse ist die Dauer eines Raster-Feldes in msec.

Zu beachten ist, dass das Gerät nur dann aktiv wird, wenn der Trigger eine ansteigende Flanke erkannt hat. Es gibt also keinen Auto-Modus wie bei anderen Geräten, in dem auch ohne Trigger der Signalverlauf angezeigt wird. Die LED, die bei jedem Trigger kurz aufleuchtet, erweist sich als ein gutes Hilfsmittel.

Anzeige des Nano-Scopes
Anzeige des Arduino Nano Oszilloskops. Der Messbereich liegt zwischen 0 und 1.1V. Die horizontale gestichelte Linie zeigt den aktuellen Trigger-Level, hier 0.1V, und die ms-Angabe am unteren rechten Rand die Zeitdauer eines Rasterfeldes, hier 10 msec.

Fazit

Das kleine Oszilloskop macht sich in der Praxis erstaunlich gut, sofern die vergleichsweise niedrige Abtastrate kein Problem ist. Frequenzen von einigen 100Hz lassen sich sehr gut darstellen. Auch bei 2000Hz (entspricht 10 Datenpunkte pro Schwingung) bekommt man noch einen brauchbaren Eindruck der Signalform. Darüber ist aber kein sinnvolles Arbeiten mehr möglich. Ein schnellerer ADC wäre wünschenswert. Auch die vertikale Auflösung des Displays setzt klare Grenzen. Trotzdem ist es beeindruckend, was mit diesem geringen Materialaufwand und der einfachen Software machbar ist.

Download

Sketch des Arduino Nano Scope: Arduino_Nano_Scope (03-Jan-2018)