Ein blinkendes „Hello World“ (MCU Teil 1a)

Hinweis: Tooltips (mouseover) geben Auskunft, zu welchem Tab (oben) der jeweilige Bereich gehört.

Hinweis: Kein Tab ausgewählt, Einträge auf der Tableiste auswählen.

Damit der Microcontroller auf dem NodeMCU erkannt wird, muss zunächst ein Treiber in der Arduino-IDE nachinstalliert werden (oder geprüft werden, ob die Einstellungen bereits vorhanden sind).

Unter Datei/Einstellungen (bzw. File/Preferences) gibt es unten den Punkt “Additional boards manager URLs”, in dem (ggf. neben weiteren) auch die folgende URL eingetragen werden muss:

http://arduino.esp8266.com/stable/package_esp8266com_index.json

Nach dem Klick auf “ok” wird die verlinkte JSON-Datei geladen. Kann im Boardmanager der entsprechende Treiber geladen werden. Boardsmanager öffnen (Tools/Board/BoardsManager):

Im Boards-Manager nach “ESP8266” suchen und die Boards installieren:

Damit der Microcontroller auf dem ESP32 erkannt wird, muss zunächst ein Treiber in der Arduino-IDE nachinstalliert werden (oder geprüft werden, ob die Einstellungen bereits vorhanden sind).

Unter Datei/Einstellungen (bzw. File/Preferences) gibt es den Punkt “Additional boards manager URLs”

Es öffnet sich ein Fenster, in dem die folgende zusätzliche URL eingetragen werden muss:

https://raw.githubusercontent.com/espressif/arduino-esp32/gh-pages/package_esp32_index.json

Nach dem Klick auf “ok” wird die verlinkte JSON-Datei geladen. Dann KANN im Boardmanager der entsprechende Treiber geladen werden. Boardsmanager öffnen (Tools/Board/BoardsManager):

Im Boards-Manager nach dem zum genutzten Microcontrolller passenden Board suchen (z.B. “ESP32” für einfache ESPs) und die Boards installieren:

Für den Arduino Uno bringt die Arduino-IDE bereits alle nötigen Treiber mit, so dass hier keine weitere Installation und Konfiguration nötig ist.

Hinweis: Tooltips (mouseover) geben Auskunft, zu welchem Tab (oben) der jeweilige Bereich gehört.

Hinweis: Kein Tab ausgewählt, Einträge auf der Tableiste auswählen.

Unter Tools/Board/esp8266 öffnet sich eine lange Liste:

Aus dieser Liste sollte der neuste NodeMCU-Treiber gewählt werden:

Bei den allermeisten ESP32-Boards findet sich auf dem Microcontroller die Bezeichnung des verbauten Chips - in Abhängigkeit davon muss das entsprechende Board gewählt werden.

• Häufig ist dies ein ESP WROOM32: dann muss ESP32 Dev-Module gewählt werden. Bei den meisten günstigsten Boards mit Micro-USB-Anschluss wird dies zutreffen.

• Weiter verbreitet sind auch ESP32-C6-WROOM-1-Boards (einige mit USB-C): dann muss ESP32C6 Dev-Module ausgewählt werden. Es erscheinen zwei Ports: für uns relevant ist verwirrenderweise derjenige Port, der nicht mit “ESP32 Family Device” benannt ist.

• Entsprechend muss bei den anderen ESP32-Chips verfahren werden (C3, H2, P4, S2 (…Natvie), S3 (…, Box, USB, CAM), WROOM_DA, Wrover (…Kit), Pico-D4): auf dem Chip steht die jeweilige Version, die auch als Board-Treiber gewählt werden muss.

• Einige ESP32 können nicht mit der Arduino-IDE programmiert werden (z.B. C2, C5, C61, P4)

Eine Übersicht über die Unterschiede findet sich z.B. auf der Seite des Herstellers Espressif oder der englischen Wikipediaseite zum ESP32.

Für Arduino UNO findet es sich unter Tools/Board/Arduino AVR Boards/Arduino UNO.

Hinweis: Tooltips (mouseover) geben Auskunft, zu welchem Tab (oben) der jeweilige Bereich gehört.

Hinweis: Kein Tab ausgewählt, Einträge auf der Tableiste auswählen.

Das nodeMCU-Board mit ESP8266 bietet uns folgende Möglichkeiten: Eine LED auf dem Microcontrollerboard, die mit dem Ausgang D4 verschaltet ist, eine LED auf dem nodeMCU-Board, die mit dem Ausgang D0 verschaltet ist und ein Taster (“FLASH”), der am Eingang D3 angeschlossen ist:

Nicht alle ESP32-Boards verfügen über Onboard-LEDs. Wir nutzen die intern verbauten LED und Taster des ESP32-Boards: nur beim DevKit v1 ist eine blaue LED auf dem Microcontrollerboard mit dem Ausgang GPIO02 verschaltet, die meisten anderen ESP32 haben leider keine internen LED, die sich leicht ansprechen lassen. Beim DevKit C V2 gibt es zwar eine LED an GPIO1, da diese aber mit USB verbunden ist, spricht für den Anfang viel dafür, hier die Finger wegzunehmen…

Wir nutzen die intern verbauten LED des Arduino-Uno-Boards: Normalerweise ist eine LED auf dem Microcontrollerboard mit dem Ausgang D13 verschaltet.

Sofern Du keinen der drei hier behandelten MCU hast, findest Du für AVR-basierte Microcontroller hier die Pin-Bezeichnung der internen LED.

Hinweis: Tooltips (mouseover) geben Auskunft, zu welchem Tab (oben) der jeweilige Bereich gehört.

Hinweis: Kein Tab ausgewählt, Einträge auf der Tableiste auswählen.

Eine interne LED ist am ESP-12 über 470 Ohm mit dem GPIO D4 verbunden, die nutzen wir für unser Ausgangsbeispiel.

/*  Liste der Ein- und Ausgabeelemente
Datentyp |Name           | Anschlusspin       | Name, Verhalten*/
const int ONBOARD_LED        = D4;           // interne LED 

Wenn Du in der glücklichen Lage bist, dass Dein Board an GPIO1 oder GPIO2 über eine interne LED verfügt, dann kannst Du folgendes probieren:

/*  Liste der Ein- und Ausgabeelemente
Datentyp |Name           | Anschlusspin | Name, Verhalten*/
const int ONBOARD_LED        = 1;       // Interne LED GPIO01 HIGH-Aktiv

Falls Du über keine interne LED verfügst, kannst Du hier nachlesen, wie Du eine LED anschließen kannst.

Häufig gibt es zwei LED: eine, die signalisiert, wenn am seriellen Port (also über USB) Daten übertragen werden. Diese liegt am D0 an. Wir nutzen eine zweite LED, die am D13 angeschlossen ist.

/*  Liste der Ein- und Ausgabeelemente
Datentyp |Name           | Anschlusspin | Name, Verhalten*/
const int ONBOARD_LED        = D13;     // Interne LED

Hinweis: Tooltips (mouseover) geben Auskunft, zu welchem Tab (oben) der jeweilige Bereich gehört.

Hinweis: Kein Tab ausgewählt, Einträge auf der Tableiste auswählen.

Es ist genau umgekehrt: lange Pause, kurzes Leuchten! Um das Verhalten zu verstehen müssen wir uns die interne Schaltung ansehen:

Sobald an D4 ein LOW-Signal anliegt ergibt sich eine Spannungs-Potenzialdifferenz (3,3V - 0V), die zu einem Stromfluss durch die LED führt. Liegt an D4 ein HIGH-Potenzial an, so ergibt sich keine Potenzialdifferenz (beide Seiten auf 3,3V) und die LED leuchtet nicht. Die LED verhält sich also gerade umgekehrt, als man es erwarten würde: sie ist bei einem anliegenden LOW-Potenzial aktiv, man nennt dies auch low-active.

Es gibt eine zweite LED am nodeMCU-Board, zwischen dem “RST”-Taster und den gelben Bauelementen:

Diese LED ist genauso an D0 verschaltet wie die vorige LED an D4:

Wir können daher alle Überlegungen von oben übernehmen, auch das Programm sieht genauso aus, wir müssen lediglich D4 durch D0 ersetzen:

/*  Liste der Ein- und Ausgabeelemente
Datentyp |Name           | Anschlusspin       | Name, Verhalten*/
const int ONBOARD_LED        = D0;            // interne LED

Wenn Dein Board onboard-LED hat, dann kannst Du genau das beobachten: Die LED scheint also zwischen dem ONBOARD_LED Pin und Ground (0v) verschaltet zu sein. Wenn sie leuchtet, sobald ein HIGH-Signal anliegt, spricht man von einem “HIGH”-aktiven Ausgang. Wäre die LED gegen 3,3V verschaltet, so würde sie leuchten, sobald ein LOW-Signal am Ausgang anliegt (das ist z.B. beim ESP8266 der Fall). In diesem Fall spricht man von LOW-aktiv.

So leuchtet die LED auch. Die LED scheint also zwischen dem ONBOARD_LED Pin und Ground (0v) verschaltet zu sein. Wenn sie leuchtet, sobald ein HIGH-Signal anliegt, spricht man von einem “HIGH”-aktiven Ausgang. Wäre die LED gegen 5V verschaltet, so würde sie leuchten, sobald ein LOW-Signal am Ausgang anliegt (das ist z.B. beim ESP8266 der Fall). In diesem Fall spricht man von LOW-aktiv.

Hinweis: Tooltips (mouseover) geben Auskunft, zu welchem Tab (oben) der jeweilige Bereich gehört.

Hinweis: Kein Tab ausgewählt, Einträge auf der Tableiste auswählen.

Der FLASH-Taster, der neben dem Micro-USB-Port sitzt, lässt sich ebenfalls direkt für Programme nutzen. Er darf nur beim Booten des ESP-Boards nicht betätigt sein, danach kann er frei genutzt werden:

Intern ist er mit dem D3-Eingang verschaltet und verfügt über einen Pull-Up-Widerstand. Das heißt: wenn der Taster nicht betätigt ist, liegt ein HIGH-Signal an D3 an.

Bei Betätigung liegt an D3 eine sehr niedrige Spannung an, die als LOW-Signal interpretiert wird. Es sind nicht exakt 0 V, da zwischen D3 und GND noch ein 470\ \Omega Widerstand liegt. Die Potenzialdifferenz zwischen GND (0V) und 3V3 (3,3V) teilt sich im Verhältnis der Widerstände auf, an D3 liegen also 0,11V an:

U_{D3} = 3,3 V \cdot \frac{430 \Omega}{12.000 \Omega + 430 \Omega} = 0,11 V

Gemäß Datenblatt erkennt der ESP8266 Eingangssignale zwischen -0,3V und 0,8 V gesichert als LOW, wir sind somit also auf der sicheren Seite. Der Arduino-Sketch ist folgendermaßen aufgebaut:

• Wir deklarieren eine neue Variable für den internen Taster: const int ONBOARD_BUTTON und weisen ihr den Wert D4 zu.

• In der setup()-Methode wird dieser Pin als Eingang festgelegt: pinMode(ONBOARD_BUTTON, INPUT);. Die LED an Pin D4 wird wieder als Ausgang genutzt.

• In der Dauerschleife (loop()) wird ausgelesen, ob das anliegende Potenzial an D3 ein LOW-Pegel ist: if (digitalRead(ONBOARD_BUTTON)==LOW){...}.

• Bei anliegendem LOW-Pegel wird die Zeit, die die LED aktiviert wird auf kurz eingestellt (200 Millisekunden), sonst auf einen längeren Wert (1200 Millisekunden).

Im Ganzen sieht das so aus:

/*  Liste der Ein- und Ausgabeelemente
Datentyp |Name           | Anschlusspin | Name, Verhalten*/
const int ONBOARD_LED        = D4;          // interne LED
const int ONBOARD_BUTTON     = D3;          // D3 Taster, Pullup

Den so festgelegten Pin müssen wir jetzt noch als Eingang deklarieren:

void setup() {
  pinMode(ONBOARD_LED, OUTPUT);
  pinMode(ONBOARD_BUTTON, INPUT_PULLUP);  
}

Und schließlich in der Programmschliefe den Zustand des Button-Pins abfragen (mit digitalRead()). Wenn der Eingang des Pins LOW ist, soll die LED schnell blinken. Andernfalls soll sie langsam blinken:

void loop() {
  int miliSecondsLow=0;

  if (digitalRead(ONBOARD_BUTTON)==LOW){
    miliSecondsLow = 200;
  }else{
    miliSecondsLow = 1200;
  }
    digitalWrite(ONBOARD_LED, HIGH);
    delay(200);
    digitalWrite(ONBOARD_LED, LOW);
    delay(miliSecondsLow);
}

Nach dem Hochladen kann man erkennen, dass die LED normalerweise langsam blinkt (der Pins also regulär HIGH ist) und nur bei Betätigung des Buttons langsam wird (also LOW). Dieses Verhalten liegt an einem intern verbauten “Pull-Up-Widerstand”. Dazu später mehr, wenn wir uns die Belegung von externen Tastern genauer anschauen.

Ohne weitere Bauteile können wir uns der zweiten großen Aufgabe stellen: digitale Signale einzulesen. Dazu nutzen wir eine weitere Komponente, die auf den meisten NodeMCU-Boards mit ESP32 verbaut ist: der Boot-Button. Er ist direkt mit dem digitalen Eingang GPIO0 verbunden und wird normalerweise genutzt, um den ESP beim Start in den Programmiermodus zu setzen.

Wir nutzen diesen Button nach dem Booten anderweitig:

Bei betätigtem Button soll sich die Geschwindigkeit des Blinkens ändern. Damit wir auch etwas sehen, wenn keine onboard-LED verfügbar ist, geben wir auf dem seriellen Monitor eine Meldung aus.

Dazu brauchen wir zunächst in der Liste der Ein- und Ausgabeelemente eine zusätzliche Zeile für den Taster:

/*  Liste der Ein- und Ausgabeelemente
Datentyp |Name           | Anschlusspin | Name, Verhalten*/
const int ONBOARD_LED        = 1;           // GPIO01 HIGH-Aktiv
const int ONBOARD_BUTTON     = 0;           // GPIO00, Pullup

Den so festgelegten Pin müssen wir jetzt noch als Eingang deklarieren:

void setup() {
  Serial.begin(115200);  // Seriellen Monitor in IDE anzeigen per Strg-Shift-M und 115200baud einstellen!
  pinMode(ONBOARD_LED, OUTPUT);
  pinMode(ONBOARD_BUTTON, INPUT_PULLUP);  
}

Und schließlich in der Programmschliefe den Zustand des Button-Pins abfragen (mit digitalRead()). Wenn der Eingang des Pins LOW ist, soll die LED schnell blinken. Andernfalls soll sie langsam blinken:

void loop() {
  int miliSecondsLow=0;

  if (digitalRead(ONBOARD_BUTTON)==LOW){
    Serial.print("Taster nicht betätigt");
    miliSecondsLow = 200;
  }else{
    miliSecondsLow = 1200;
    Serial.print("Taster betätigt");
  }
    digitalWrite(ONBOARD_LED, HIGH);
    Serial.print("LED an");
    delay(200);
    digitalWrite(ONBOARD_LED, LOW);
    Serial.print("LED aus");
    delay(miliSecondsLow);
}

Nach dem Hochladen kann man erkennen, dass die LED normalerweise langsam blinkt (der Pins also regulär HIGH ist) und nur bei Betätigung des Buttons langsam wird (also LOW). Dieses Verhalten liegt an einem intern verbauten “Pull-Up-Widerstand”. Dazu später mehr, wenn wir uns die Belegung von externen Tastern genauer anschauen.

Leider verfügt der Arduino Uno über keine internen Taster, die genutzt werden können. Um mit Eingaben zu experimentieren, müssen wir also auf externe Taster zurückgreifen.