Inhalt diese Tutorials

• Nachrichten per Telegram senden
• E-Mails versenden
• Nachrichten per WhatsApp senden

Nachrichten per Telegram senden

Eine gängige Möglichkeit ist es, Nachrichten per Telegram zu senden – genauer gesagt an einen Telegram-Bot. Diese Nachrichten kannst du dann umgehend auf deinem Smartphone lesen. Auf Pollux Labs gibt es einige Projekte, die auf Telegram zurückgreifen, zum Beispiel einen Dash Button oder eine Fotofalle mit der ESP32-CAM. Für letzteres Projekt ist Telegram besonders interessant, denn es ist damit auch möglich, Bilder zu senden.

Zunächst benötigst du einen Telegram-Bot. Wie du diesen im Handumdrehen einrichtest, erfährst du in diesem Tutorial. Außerdem benötigst du die Bibliothek UniversalTelegramBot, die du im Bibliotheksverwalter der Arduino IDE findest. Achte darauf, die neueste Version zu installieren und die Bibliothek aktuell zu halten. Sollte die Version im Bibliotheksverwalter veraltet sein, findest du auf GitHub immer die neueste Version zum Download.

Hier der Beispiel-Sketch für deinen ESP8266. Dieser versendet nach dem Start des Boards eine Nachricht:

#include <ESP8266WiFi.h>
#include <WiFiClientSecure.h>
#include <UniversalTelegramBot.h>

// Deine WLAN-Zugangsdaten
const char* ssid = "DEIN WLAN-NETZWERK";
const char* password = "DEIN PASSWORT";

// Dein Bot-Token
#define botToken "DEIN TOKEN"  // den Bot-Token bekommst du vom Botfather)

//Deine User ID
#define userID "DEINE USER ID"

WiFiClientSecure client;
UniversalTelegramBot bot(botToken, client);

void setup() {
  Serial.begin(115200);
  client.setInsecure();

  // Verbindung zum WLAN
  Serial.print("Verbinde mit mit: ");
  Serial.println(ssid);

  WiFi.mode(WIFI_STA);
  WiFi.begin(ssid, password);

  while (WiFi.status() != WL_CONNECTED) {
    Serial.print(".");
    delay(500);
  }

  Serial.println("");
  Serial.println("Verbunden!");

  bot.sendMessage(userID, "Hier spricht dein ESP8266.", "");
}

void loop() {
}

Nach dem Upload sollte in deiner Telegram-App folgende Nachricht erscheinen:

So funktioniert der Sketch

Nachdem du die benötigten Bibliotheken eingebunden hast (die zwei ersten sind bereits vorinstalliert), musst du ein paar Daten ergänzen. Das sind deine WLAN-Zugangsdaten sowie dein Bot-Token und deine User-ID. Wenn du die beiden letzteren noch nicht hast, schau dir zunächst unser oben verlinktes Tutorial an.

Anschließend initialisierst du den WifiClient sowie den UniversalTelegramBot mit jeweiligen Instanzen:

WiFiClientSecure client;
UniversalTelegramBot bot(botToken, client);

Im Setup stellst du dann die Verbindung zu deinem WLAN her. Sobald die Verbindung steht, verwendest du die Funktion bot.sendMessage, um eine Nachricht an deinen Telegram-Bot zu senden:

bot.sendMessage(userID, "Hier spricht dein ESP8266.", "");

Der erste Parameter in dieser Funktion ist deine userID, die du zu Beginn des Sketchs hinterlegt hast – gefolgt von der Nachricht, die du senden möchtest. Und das war es im Prinzip auch schon! Du kannst dieses Muster nun für dein Projekt adaptieren, indem du die Nachricht zum Beispiel sendest, wenn eine bestimmte Temperatur überschritten wurde – als Inhalt der Nachricht könnte dann z.B. der aktuelle Messwert dienen.

Mit dem ESP32 eine Telegram-Nachricht senden

Natürlich kannst du statt des ESP8266 auch mit einem ESP32 oder einer ESP32-CAM Nachrichten per Telegram senden. Hierfür musst du nur eine Bibliothek austauschen. Statt ESP8266WiFI.h verwendest du WiFi.h.

#include <WiFi.h>
#include <WiFiClientSecure.h>
#include <UniversalTelegramBot.h>

Und: Um eine korrekte Nachricht zu senden, kannst du noch den Inhalt anpassen.

bot.sendMessage(userID, "Hier spricht dein ESP32.", "");

E-Mails mit dem ESP8266 oder ESP32 versenden

Nach Telegram schauen wir uns den Klassiker der elektronischen Nachrichten an, E-Mails. In diesem Tutorial verwenden wir den Service Gmail, um die E-Mails zu versenden. Auch wenn du schon eine Adresse bei Gmail haben solltest, empfehlen wir fürs Experimentieren auf jeden Fall eine brandneue Mail-Adresse anzulegen. Sollte etwas schief laufen, z.B. eine Kontosperrung, weil dein ESP8266 versehentlich zahllose Mails in kurzer Abfolge versendet, ist deine private Mail-Adresse hiervon nicht betroffen.

___STEADY_PAYWALL___

Um eine neue Adresse anzulegen, rufe zunächst hier Gmail auf und klicke auf Konto erstellen. Sobald dein Konto eingerichtet ist, benötigst du ein App-Passwort, das dein ESP8266 verwenden kann. Um ein App-Passwort anzulegen, öffne dein Google-Konto und klicke auf den Menüpunkt Sicherheit. Klicke anschließend auf den Menü-Punkt Bestätigung in zwei Schritten und folge den Anweisungen, um diese Zwei-Faktor-Authentifizierung zu aktivieren – sie ist nämlich die Voraussetzung für ein App-Passwort.

Sobald du mit der Einrichtung fertig bist, öffne wieder Sicherheit > Bestätigung in zwei Schritten und scrolle ganz nach unten zum Eintrag App-Passwörter. Erstelle nun ein Passwort für E-Mail und wähle als Gerät Andere (benutzerdefinierter Name) aus. Anschließend kannst du einen Namen vergeben, also z.B. ESP8266 oder ESP32.

Das war es zunächst mit den Vorbereitungen, weiter geht es mit einem Beispielsketch, der eine E-Mail an dich versendet.

Eine E-Mail senden

Zunächst benötigst du eine Bibliothek, die du über den Bibliotheksverwalter installieren kannst: ESP Mail Client

Nach der Installation kannst du dich gleich dem Sketch zuwenden. Wir verwenden in diesem Tutorial den Sketch des Blogs RandomNerdTutorials, der ein sehr guter Startpunkt für dieses Thema ist. Im folgenden Sketch musst du nur ein paar Anpassungen machen. Trage an den folgenden Stellen deine Daten ein:

#define WIFI_SSID "REPLACE_WITH_YOUR_SSID" //Dein WLAN-Name
#define WIFI_PASSWORD "REPLACE_WITH_YOUR_PASSWORD" //Dein WLAN-Passwort
#define AUTHOR_EMAIL "YOUR_EMAIL@XXXX.com" //Deine Absendeadresse (die du bei Gmail angelegt hast)
#define AUTHOR_PASSWORD "YOUR_EMAIL_APP_PASS" //Dein App-Passwort
#define RECIPIENT_EMAIL "RECIPIENTE_EMAIL@XXXX.com" //Die Empfänger-Adresse

Der gesamte Sketch:

/*
  Rui Santos
  Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files.
  The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
  Example adapted from: https://github.com/mobizt/ESP-Mail-Client
*/

#include <Arduino.h>
#if defined(ESP32)
  #include <WiFi.h>
#elif defined(ESP8266)
  #include <ESP8266WiFi.h>
#endif
#include <ESP_Mail_Client.h>

#define WIFI_SSID "REPLACE_WITH_YOUR_SSID"
#define WIFI_PASSWORD "REPLACE_WITH_YOUR_PASSWORD"

/** The smtp host name e.g. smtp.gmail.com for GMail or smtp.office365.com for Outlook or smtp.mail.yahoo.com */
#define SMTP_HOST "smtp.gmail.com"
#define SMTP_PORT 465

/* The sign in credentials */
#define AUTHOR_EMAIL "YOUR_EMAIL@XXXX.com"
#define AUTHOR_PASSWORD "YOUR_EMAIL_APP_PASS"

/* Recipient's email*/
#define RECIPIENT_EMAIL "RECIPIENTE_EMAIL@XXXX.com"

/* Declare the global used SMTPSession object for SMTP transport */
SMTPSession smtp;

/* Callback function to get the Email sending status */
void smtpCallback(SMTP_Status status);

void setup(){
  Serial.begin(115200);
  Serial.println();
  WiFi.begin(WIFI_SSID, WIFI_PASSWORD);
  Serial.print("Connecting to Wi-Fi");
  while (WiFi.status() != WL_CONNECTED){
    Serial.print(".");
    delay(300);
  }
  Serial.println();
  Serial.print("Connected with IP: ");
  Serial.println(WiFi.localIP());
  Serial.println();

  /*  Set the network reconnection option */
  MailClient.networkReconnect(true);

  /** Enable the debug via Serial port
   * 0 for no debugging
   * 1 for basic level debugging
   *
   * Debug port can be changed via ESP_MAIL_DEFAULT_DEBUG_PORT in ESP_Mail_FS.h
   */
  smtp.debug(1);

  /* Set the callback function to get the sending results */
  smtp.callback(smtpCallback);

  /* Declare the Session_Config for user defined session credentials */
  Session_Config config;

  /* Set the session config */
  config.server.host_name = SMTP_HOST;
  config.server.port = SMTP_PORT;
  config.login.email = AUTHOR_EMAIL;
  config.login.password = AUTHOR_PASSWORD;
  config.login.user_domain = "";

  /*
  Set the NTP config time
  For times east of the Prime Meridian use 0-12
  For times west of the Prime Meridian add 12 to the offset.
  Ex. American/Denver GMT would be -6. 6 + 12 = 18
  See https://en.wikipedia.org/wiki/Time_zone for a list of the GMT/UTC timezone offsets
  
  config.time.ntp_server = F("pool.ntp.org,time.nist.gov");
  config.time.gmt_offset = 1;
  config.time.day_light_offset = 0;
  */

  /* Declare the message class */
  SMTP_Message message;

  /* Set the message headers */
  message.sender.name = F("ESP");
  message.sender.email = AUTHOR_EMAIL;
  message.subject = F("ESP Test Email");
  message.addRecipient(F("Sara"), RECIPIENT_EMAIL);
    
  /*Send HTML message*/
  /*String htmlMsg = "<div style=\"color:#2f4468;\"><h1>Hello World!</h1><p>- Sent from ESP board</p></div>";
  message.html.content = htmlMsg.c_str();
  message.html.content = htmlMsg.c_str();
  message.text.charSet = "us-ascii";
  message.html.transfer_encoding = Content_Transfer_Encoding::enc_7bit;*/

   
  //Send raw text message
  String textMsg = "Hallo Mensch!";
  message.text.content = textMsg.c_str();
  message.text.charSet = "us-ascii";
  message.text.transfer_encoding = Content_Transfer_Encoding::enc_7bit;
  
  message.priority = esp_mail_smtp_priority::esp_mail_smtp_priority_low;
  message.response.notify = esp_mail_smtp_notify_success | esp_mail_smtp_notify_failure | esp_mail_smtp_notify_delay;


  /* Connect to the server */
  if (!smtp.connect(&config)){
    ESP_MAIL_PRINTF("Connection error, Status Code: %d, Error Code: %d, Reason: %s", smtp.statusCode(), smtp.errorCode(), smtp.errorReason().c_str());
    return;
  }

  if (!smtp.isLoggedIn()){
    Serial.println("\nNot yet logged in.");
  }
  else{
    if (smtp.isAuthenticated())
      Serial.println("\nSuccessfully logged in.");
    else
      Serial.println("\nConnected with no Auth.");
  }

  /* Start sending Email and close the session */
  if (!MailClient.sendMail(&smtp, &message))
    ESP_MAIL_PRINTF("Error, Status Code: %d, Error Code: %d, Reason: %s", smtp.statusCode(), smtp.errorCode(), smtp.errorReason().c_str());

}

void loop(){
}

/* Callback function to get the Email sending status */
void smtpCallback(SMTP_Status status){
  /* Print the current status */
  Serial.println(status.info());

  /* Print the sending result */
  if (status.success()){
    // ESP_MAIL_PRINTF used in the examples is for format printing via debug Serial port
    // that works for all supported Arduino platform SDKs e.g. AVR, SAMD, ESP32 and ESP8266.
    // In ESP8266 and ESP32, you can use Serial.printf directly.

    Serial.println("----------------");
    ESP_MAIL_PRINTF("Message sent success: %d\n", status.completedCount());
    ESP_MAIL_PRINTF("Message sent failed: %d\n", status.failedCount());
    Serial.println("----------------\n");

    for (size_t i = 0; i < smtp.sendingResult.size(); i++)
    {
      /* Get the result item */
      SMTP_Result result = smtp.sendingResult.getItem(i);

      // In case, ESP32, ESP8266 and SAMD device, the timestamp get from result.timestamp should be valid if
      // your device time was synched with NTP server.
      // Other devices may show invalid timestamp as the device time was not set i.e. it will show Jan 1, 1970.
      // You can call smtp.setSystemTime(xxx) to set device time manually. Where xxx is timestamp (seconds since Jan 1, 1970)
      
      ESP_MAIL_PRINTF("Message No: %d\n", i + 1);
      ESP_MAIL_PRINTF("Status: %s\n", result.completed ? "success" : "failed");
      ESP_MAIL_PRINTF("Date/Time: %s\n", MailClient.Time.getDateTimeString(result.timestamp, "%B %d, %Y %H:%M:%S").c_str());
      ESP_MAIL_PRINTF("Recipient: %s\n", result.recipients.c_str());
      ESP_MAIL_PRINTF("Subject: %s\n", result.subject.c_str());
    }
    Serial.println("----------------\n");

    // You need to clear sending result as the memory usage will grow up.
    smtp.sendingResult.clear();
  }
}

So funktioniert der sketch

Weiter oben hast du bereits die Stellen kennengelernt, die du anpassen musst, damit der Sketch funktioniert. Außerdem kannst du noch deine Zeitzone einstellen, um der E-Mail den richtigen Timestamp zu geben:

  config.time.ntp_server = F("pool.ntp.org,time.nist.gov");
  config.time.gmt_offset = 1;
  config.time.day_light_offset = 0;

Der gmt_offset für Deutschland (also der Abstand zur Greenwich Mean Time) wäre in diesem Beispiel 1 – in der Winterzeit. Im Sommer sind es hingegen 2 Stunden.

Den Betreff und den Absender- bzw. Empfängernamen trägst du hier ein:

  /* Set the message headers */
  message.sender.name = F("ABSENDERNAME");
  message.sender.email = AUTHOR_EMAIL;
  message.subject = F("BETREFF");
  message.addRecipient(F("EMPFÄNGERNAME"), RECIPIENT_EMAIL);

Die eigentliche Nachricht findest du hier:

  //Send raw text message
  String textMsg = "Hallo Mensch!";

Hier kannst du, je nachdem was in deinem eigenen Projekt sinnvoll ist, natürlich auch Variablen mitsenden. Lade den Sketch mit deinen Anpassungen auf deinen ESP8266 oder ESP32. Im Seriellen Monitor kannst du mitverfolgen, wie die E-Mail versendet wird und schließlich im Posteingang deines Empfängers landet.

Der obige Sketch funktioniert sowohl für den ESP8266 als auch für den ESP32. Anpassungen sind beim Wechsel der Boards nicht nötig.

Eine WhatsApp-Nachricht mit dem ESP8266 und ESP32 versenden

Kommen wir zu dritten Möglichkeit, deinen ESP8266 oder ESP32 eine Nachricht versenden zu lassen: WhatsApp. Voraussetzung ist hier ein externer Service. Im Folgenden verwenden wir CallMeBot.com – eine kostenlose API, mit deren Hilfe du WhatsApp-Textnachrichten auf dein Smartphone senden kannst.

Hierfür ist keine aufwändige Registrierung nötig, du musst nur kurz deine Mobilfunknummer bei der API anmelden, um einen API-Key zu erhalten. Über den Link oben kannst du die offizielle Anleitung aufrufen – oder einfach die folgenden Schritte ausführen:

• Füge über WhatsApp die folgende Nummer deinen Kontakten hinzu (den Kontaktnamen kannst du frei wählen): +34 644 71 81 99
• Sende anschließend die folgende Nachricht an diese Nummer: I allow callmebot to send me messages
• Du erhältst daraufhin eine Antwort mit deinem API-Key – und das war’s auch schon

Die Bibliothek zum Codieren der Nachrichten

Auch um Nachrichten per WhatsApp senden zu können, benötigst du eine Bibliothek, die du ganz schnell über den Bibliotheksverwalter installieren kannst: UrlEncode

Diese brauchst du, da die Nachrichten über eine URL übertragen werden – z.B. so:

https://api.callmebot.com/whatsapp.php?phone=+49123123123&text=Dieser+Text+ist+codiert&apikey=123123

Die Bibliothek, die du gleich installierst, übernimmt die Aufgabe, deinen Nachrichten-String in das richtige Format zu bringen. Öffne also den Bibliotheksverwalter und suche nach UrlEncode. Installiere anschließend die neueste Version.

die WhatsApp-Nachricht senden

Hier kommt der vollständige Sketch, um eine WhatsApp-Nachricht mit deinem ESP8266 zu verschicken:

#include <ESP8266WiFi.h>
#include <ESP8266HTTPClient.h>
#include <WiFiClient.h>
#include <UrlEncode.h>

const char* ssid = "DEIN WLAN-NETZ";
const char* password = "DEIN WLAN-PASSWORT";

// Deutschland +49, Beispiel: +49176999888777
String phoneNumber = "DEINE MOBILFUNKNUMMER";
String apiKey = "DEIN API-KEY";

void sendMessage(String message) {

  // Daten, die gesendet werden
  String url = "http://api.callmebot.com/whatsapp.php?phone=" + phoneNumber + "&apikey=" + apiKey + "&text=" + urlEncode(message);
  WiFiClient client;
  HTTPClient http;
  http.begin(client, url);

  // Header
  http.addHeader("Content-Type", "application/x-www-form-urlencoded");

  // HTTP Post request senden
  int httpResponseCode = http.POST(url);
  if (httpResponseCode == 200) {
    Serial.print("Message sent successfully");
  } else {
    Serial.println("Error sending the message");
    Serial.print("HTTP response code: ");
    Serial.println(httpResponseCode);
  }

  http.end();
}

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

  WiFi.begin(ssid, password);
  Serial.println("Connecting");
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  Serial.println("");
  Serial.print("Connected to WiFi network with IP Address: ");
  Serial.println(WiFi.localIP());

  // WhatsApp-Nachricht
  sendMessage("Hier spricht dein ESP8266");
}

void loop() {
}

Zu Beginn des Sketchs hinterlegst du wieder deine WLAN-Zugangsdaten. Außerdem benötigst du deine eigene Mobilfunknummer, die du im internationalen Format (also z.B. für Deutschland mit einem +49 zu Beginn) hinterlegen musst. Zuletzt trägst du noch deinen API-Key ein, den du per WhatsApp-Nachricht empfangen hast:

const char* ssid = "DEIN WLAN-NETZ";
const char* password = "DEIN WLAN-PASSWORT";

// Deutschland +49, Beispiel: +49176999888777
String phoneNumber = "DEINE MOBILFUNKNUMMER";
String apiKey = "DEIN API-KEY";

Alles weitere im Sketch dient der Verbindung zu deinem WLAN und dem API-Request (in der Funktion sendMessage(String message)). Recht weit am Ende kannst du deine Textnachricht eingeben, die gesendet werden soll:

// WhatsApp-Nachricht
sendMessage("Hier spricht dein ESP8266");

Lade den Sketch auf deinen ESP8266. Nach dem Upload sollte innerhalb von wenigen Sekunden die entsprechende Nachricht auf deinem Smartphone erscheinen.

Die WhatsApp-Nachricht mit dem ESP32 senden

Wenn du statt eines ESP8266 einen ESP32 oder eine ESP32-CAM verwenden möchtest, musst du nur ein paar andere Bibliotheken zu Beginn des Sketchs einbinden:

#include <WiFi.h>
#include <HTTPClient.h>
#include <UrlEncode.h>

Den restlichen Sketch kannst du beibehalten ohne weitere Anpassungen. Beachte bitte, dass du mit CallMeBot nur reine Textnachrichten (die natürlich auch Variablen enthalten können) senden kannst. Bilder zu senden, funktioniert mit diesem Service leider nicht. Solltest du das vorhaben, verwende besser Telegram oder schaue dir einmal textmebot.com an – diese API ist allerdings kostenpflichtig.

Fazit

In diesem Tutorial hast du drei Methoden kennengelernt, mit denen du Nachrichten versenden kannst – per Telegram, E-Mail oder WhatsApp. Passende Projekte findest du auf Pollux Labs: Du könntest zum Beispiel die ESP8266 Wetterstation um Warnungen ergänzen, die du erhältst, sobald bestimmte Messwerte über- oder unterschritten werden.

So kann dein ESP zum Beispiel alle 20 Minuten aufwachen, einen Sensorwert übermitteln und sich dann wieder schlafen legen. In diesem Tutorial erfährst du, wie du dabei vorgehst und wie den Deep-Sleep-Modus programmierst.

Benötigte Materialien

Für einen ersten Test ohne Sensoren benötigst du nicht viel:

• Ein ESP8266 Modul (z.B. NodeMCU oder Wemos D1 Mini)
• Ein USB-Kabel zum Programmieren
• Arduino IDE

Übrigens – falls du es noch nicht weißt – bei uns erfährst du, wie du deinen ESP8266 mit der Arduino IDE programmierst.

Verkabelung für den ESP8266 Deep Sleep

Die gute Nachricht, du benötigst nur ein einziges Kabel: Um den Deep-Sleep-Modus zu nutzen, muss der RESET-Pin des ESP8266 mit dem D0-Pin verbunden werden. Entweder verwendest du hier ein Female-Female-Kabel, das du direkt an die Pins des ESP steckst – oder du verwendest ein Breadboard. Mehr musst du für den Schlafmodus nicht tun.

Der Sketch

Lege in der Arduino IDE einen neuen Sketch an und füge den folgenden Code ein und lade ihn auf deinen ESP8266.

void setup() {
  // Beginne die serielle Kommunikation mit einer Baudrate von 9600
  Serial.begin(9600);

  // Ausgabe einer Nachricht, wenn der ESP8266 aufwacht
  Serial.println("Der ESP8266 ist aufgewacht!");
}

void loop() {
  // Warte ein wenig, bevor der ESP8266 in den Deep-Sleep-Modus wechselt
  delay(2000);

  // Ausgabe einer Nachricht, bevor der ESP8266 in den Deep-Sleep-Modus wechselt
  Serial.println("Der ESP8266 geht in den Deep-Sleep-Modus...");

  // Gib dem ESP8266 Zeit, die Nachricht zu senden, bevor er in den Deep-Sleep-Modus geht
  delay(100);

  // ESP8266 in den Deep-Sleep-Modus versetzen
  // Die Zeit ist in Mikrosekunden angegeben
  // 1 Sekunde = 1.000.000 Mikrosekunden
  // In diesem Fall wird der ESP8266 alle 10 Sekunden aufwachen
  ESP.deepSleep(10e6);
}

Nun sollte dein ESP8266 alle 10 Sekunden für 2 Sekunden aufwachen.

Benötigte Materialien:

1. Arduino (z.B. Arduino Uno, Mega oder Nano)
2. OLED-Display (z.B. 128×64 Pixel, I2C-Kommunikation)
3. Jumper-Kabel (männlich-männlich)
4. Breadboard (optional)

Schritt 1: Verkabelung

Bevor wir mit der Programmierung beginnen, müssen wir das Display mit dem Arduino verbinden. Hier ist, wie Du es verkabelst:

1. Schließe GND (Ground) des OLED-Displays an den GND-Pin des Arduino an.
2. Verbinde VCC (Power) des Displays mit dem 5V-Pin des Arduino.
3. Schließe SDA (Daten) des Displays an den A4-Pin (SDA) des Arduino Uno oder Mega, bzw. an den A4-Pin (SDA) des Arduino Nano an.
4. Verbinde SCL (Clock) des Displays mit dem A5-Pin (SCL) des Arduino Uno oder Mega, bzw. an den A5-Pin (SCL) des Arduino Nano.

Wenn Du ein Breadboard verwendest, stecke das -Display auf das Breadboard und verbinde es mit dem Arduino über Jumper-Kabel.

Schritt 2: Bibliotheken installieren

Um das OLED-Display mit dem Arduino zu verwenden, benötigen wir zwei Bibliotheken: die Adafruit-GFX-Bibliothek und die Adafruit-SSD1306-Bibliothek. Du kannst sie direkt aus der Arduino-IDE heraus installieren:

1. Öffne die Arduino-IDE und gehe zu “Sketch” > “Bibliothek einbinden” > “Bibliotheken verwalten…”.
2. Suche nach “Adafruit GFX Library” und installiere die neueste Version.
3. Suche anschließend nach “Adafruit SSD1306” und installiere auch hier die neueste Version.

Schritt 3: Beispielcode laden und anpassen

Jetzt, wo die Verkabelung und die Bibliotheken bereit sind, können wir den Beispielcode laden und anpassen:

1. Öffne die Arduino-IDE und gehe zu “Datei” > “Beispiele” > “Adafruit SSD1306” > “ssd1306_128x64_i2c”.
2. Suche im Code nach der Zeile #define OLED_RESET 4 und ändere sie in #define OLED_RESET -1, um den Reset-Pin zu deaktivieren (wir benötigen ihn nicht).
3. Suche im Code nach der Zeile Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, OLED_RESET); und ändere sie in Adafruit_SSD1306 display(128, 64, &Wire, -1); für ein 128×64 Pixel OLED-Display.

Schritt 4: Code hochladen und Display testen

Es ist Zeit, den angepassten Beispielcode auf Deinen Arduino zu laden und das OLED-Display zu testen:

1. Stelle sicher, dass Dein Arduino über USB mit Deinem Computer verbunden ist.
2. Wähle in der Arduino-IDE unter “Werkzeuge” > “Board” das richtige Arduino-Board aus (z.B. Arduino Uno, Mega oder Nano).
3. Wähle unter “Werkzeuge” > “Port” den richtigen USB-Anschluss für Deinen Arduino aus.
4. Klicke auf den “Hochladen”-Button (Pfeilsymbol) in der Arduino-IDE, um den Code auf Deinen Arduino zu übertragen.

Sobald der Code erfolgreich hochgeladen wurde, sollte das Display verschiedene Muster und Text anzeigen. Herzlichen Glückwunsch, Du hast erfolgreich ein OLED-Display an Deinen Arduino angeschlossen und verwendet!

Schritt 5: Dein eigenes Display-Design erstellen

Nun, da Du weißt, wie Du ein OLED-Display anschließt und den Beispielcode verwendest, kannst Du Deine eigenen Designs und Texte erstellen! Hier sind einige grundlegende Funktionen, die Du nutzen kannst:

• display.clearDisplay(); – Löscht den Display-Inhalt.
• display.setTextSize(1); – Setzt die Textgröße (1, 2, 3…).
• display.setTextColor(WHITE); – Setzt die Textfarbe (OLED-Displays sind normalerweise monochrom, daher ist Weiß die Standardfarbe).
• display.setCursor(0, 0); – Setzt den Cursor an die angegebene Position (x, y).
• display.println("Hallo, Maker!"); – Gibt Text auf dem Display aus.
• display.display(); – Aktualisiert das Display, um die vorgenommenen Änderungen anzuzeigen.

Fühle Dich frei, mit diesen Funktionen zu experimentieren und Dein eigenes Display-Design zu erstellen. Denke daran, den Befehl display.display(); nach Deinen Anweisungen zu verwenden, um die Änderungen auf dem Display sichtbar zu machen. Übrigens, in diesem Tutorial lernst du, wie du Bilder auf dem OLED-Display anzeigst.

Der Anschluss am ESP8266

Der Anschluss eines OLED-Displays an einen ESP8266 ist ebenso einfach wie beim Arduino. Hier ist, wie Du es verkabelst:

Benötigte Materialien:

1. ESP8266 (z.B. NodeMCU, Wemos D1 Mini)
2. OLED-Display (z.B. 128×64 Pixel, I2C-Kommunikation)
3. Jumper-Kabel (männlich-männlich)
4. Breadboard (optional)

Schritt 1: Verkabelung und Code

Um das OLED-Display mit dem ESP8266 zu verbinden, führe die folgenden Schritte aus:

1. Schließe GND (Ground) des OLED-Displays an den GND-Pin des ESP8266 an.
2. Verbinde VCC (Power) des Displays mit dem 3.3V-Pin des ESP8266.
3. Schließe SDA (Daten) des Displays an den D2-Pin (GPIO4, SDA) des ESP8266 an.
4. Verbinde SCL (Clock) des Displays mit dem D1-Pin (GPIO5, SCL) des ESP8266.

Wenn Du ein Breadboard verwendest, stecke das OLED-Display auf das Breadboard und verbinde es mit dem ESP8266 über Jumper-Kabel.

Die restlichen Schritte zur Installation der Bibliotheken und zum Anpassen des Beispielcodes bleiben dieselben. Du musst lediglich eine kleine Änderung am Beispielcode vornehmen, um die Pin-Belegung für den ESP8266 festzulegen:

1. Füge im Code die Zeile #include <Wire.h> hinzu, um die Wire-Bibliothek einzubinden.
2. Füge direkt nach der Zeile Wire.begin(); die folgenden Zeilen hinzu, um die I2C-Pins für den ESP8266 festzulegen:

#if defined(ESP8266)
  Wire.begin(4, 5); // SDA, SCL
#endif

Das war’s! Jetzt kannst Du den angepassten Code auf Deinen ESP8266 hochladen und das Display wie zuvor beschrieben verwenden.

Was ist der VL53L0X-Sensor?

Der VL53L0X ist ein Time-of-Flight (ToF)-Laserabstandssensor, der mithilfe von Infrarot-Licht die Entfernung zu einem Objekt misst. Er ist kompakt und leicht zu integrieren, was ihn ideal für die Anwendung in Roboterprojekten, Drohnen oder zur Objekterkennung macht.

Was benötigst Du für dieses Projekt?

Neben dem Sensor benötigst du nur einen Microcontroller – in diesem Tutorial verwenden wir den Arduino UNO. Selbstverständlich kannst du auch jedes andere verwenden, sofern es über I²C verfügt.

AZDelivery Mikrocontroller Board AZ-ATmega328-Board mit USB-Kabel inklusive E-Book!

Sichern Sie sich jetzt einen AZDelivery Mikrocontroller Board zum Vorteilspreis.

9,79 €

AZDelivery VL53L0X Time of Flight Sensor 940nm kompatibel mit Arduino inklusive E-Book!

Schnelle Reaktionszeit: 50 ms.

7,49 €

Verkabelung des Sensors mit dem Arduino UNO

Bevor wir anfangen, den Sensor zu programmieren, müssen wir ihn erst einmal mit dem Arduino UNO verbinden. Die Verkabelung ist denkbar einfach:

1. Verbinde den VCC (oder auch VIN)-Pin des VL53L0X mit dem 5V-Pin des Arduino UNO.
2. Verbinde den GND-Pin des Sensors mit dem GND-Pin des Arduino UNO.
3. Verbinde den SDA-Pin mit dem A4-Pin (SDA) des Arduino UNO.
4. Verbinde den SCL-Pin mit dem A5-Pin (SCL) des Arduino UNO.

Programmierung des Arduino UNO

Um den VL53L0X-Sensor verwenden zu können, musst Du zunächst die passende Bibliothek in Deiner Arduino IDE installieren. Hierzu gehst Du wie folgt vor:

1. Öffne die Arduino IDE auf Deinem Computer.
2. Klicke im Menü auf “Sketch” > “Bibliothek einbinden” > “Bibliotheken verwalten…”.
3. Suche im Bibliotheksmanager nach “VL53L0X” und installiere die Bibliothek “VL53L0X von Pololu”.

Jetzt können wir mit dem Programmieren beginnen! Erstelle einen neuen Sketch und füge den folgenden Code ein:

#include <Wire.h>
#include <VL53L0X.h>

VL53L0X sensor;

void setup() {
  Serial.begin(9600);
  Wire.begin();

  sensor.init();
  sensor.setTimeout(500);

  Serial.println("VL53L0X-Sensor bereit!");
}

void loop() {
  int distance = sensor.readRangeSingleMillimeters();

  if (sensor.timeoutOccurred()) {
    Serial.print("Timeout! ");
  }

  Serial.print("Abstand: ");
  Serial.print(distance);
  Serial.println(" mm");

  delay(1000);
}

Lade den Sketch auf Deinen Arduino UNO hoch und öffne den seriellen Monitor. Du solltest nun alle Sekunden die gemessene Entfernung in Mill

imetern angezeigt bekommen.

Wie funktioniert der Code?

Lass uns einen Blick auf die einzelnen Bestandteile des Codes werfen, um besser zu verstehen, wie das Programm funktioniert: Zuerst binden wir die benötigten Bibliotheken ein, nämlich Wire.h für die I2C-Kommunikation und VL53L0X.h für den Sensor.

#include <Wire.h>
#include <VL53L0X.h>

Danach erstellen wir ein Objekt sensor der Klasse VL53L0X.

VL53L0X sensor;

Im setup()-Funktionsteil initialisieren wir die serielle Kommunikation mit einer Baudrate von 9600, die I2C-Kommunikation und den Sensor. Wir setzen außerdem ein Timeout von 500 ms für den Sensor, damit das Programm nicht ewig hängt, falls es Probleme bei der Messung geben sollte.

void setup() {
  Serial.begin(9600);
  Wire.begin();

  sensor.init();
  sensor.setTimeout(500);

  Serial.println("VL53L0X-Sensor bereit!");
}

In der loop()-Funktion lesen wir die Entfernung in Millimetern mit sensor.readRangeSingleMillimeters() und speichern den Wert in der Variable distance. Wir überprüfen, ob ein Timeout aufgetreten ist, und geben eine entsprechende Meldung aus. Anschließend geben wir den gemessenen Abstand auf dem seriellen Monitor aus und warten eine Sekunde, bevor wir die nächste Messung durchführen.

void loop() {
  int distance = sensor.readRangeSingleMillimeters();

  if (sensor.timeoutOccurred()) {
    Serial.print("Timeout! ");
  }

  Serial.print("Abstand: ");
  Serial.print(distance);
  Serial.println(" mm");

  delay(1000);
}

Jetzt weißt Du, wie Du den Time-of-Flight-Sensor mit Deinem Arduino UNO verbinden und verwenden kannst, um präzise Entfernungsmessungen durchzuführen. Mit dieser neuen Fähigkeit kannst Du nun kreative Projekte entwickeln, bei denen Entfernungen eine wichtige Rolle spielen, wie beispielsweise Parkassistenten, Hinderniserkennung für Roboter oder sogar interaktive Kunstinstallationen.

Die ENtfernung auf einem OLED-Display anzeigen

Um das Projekt zu erweitern und die gemessene Entfernung auf einem OLED-Display anzuzeigen, benötigst Du zusätzlich:

• Ein I2C-OLED-Display (128×64 Pixel, z.B. SSD1306)
• Ein paar zusätzliche Jumper-Kabel

Verkabelung des OLED-Displays mit dem Arduino UNO

Die Verkabelung des OLED-Displays ist ähnlich einfach wie beim VL53L0X-Sensor:

1. Verbinde den VCC-Pin des OLED-Displays mit dem 5V-Pin des Arduino UNO.
2. Verbinde den GND-Pin des OLED-Displays mit dem GND-Pin des Arduino UNO.
3. Verbinde den SDA-Pin des OLED-Displays mit dem A4-Pin (SDA) des Arduino UNO.
4. Verbinde den SCL-Pin des OLED-Displays mit dem A5-Pin (SCL) des Arduino UNO.

Da das OLED-Display und der VL53L0X-Sensor beide I2C-Geräte sind, können sie gemeinsam an den I2C-Bus des Arduino UNO angeschlossen werden.

Programmierung des Arduino UNO

Um das OLED-Display zu verwenden, musst Du zunächst die passenden Bibliotheken in Deiner Arduino IDE installieren. Hierzu gehst Du wie folgt vor:

1. Öffne die Arduino IDE auf Deinem Computer.
2. Klicke im Menü auf “Sketch” > “Bibliothek einbinden” > “Bibliotheken verwalten…”.
3. Suche im Bibliotheksmanager nach “Adafruit SSD1306” und installiere die Bibliothek “Adafruit SSD1306 by Adafruit”.
4. Suche im Bibliotheksmanager nach “Adafruit GFX” und installiere die Bibliothek “Adafruit GFX Library by Adafruit”.

Jetzt können wir den Code erweitern, um das OLED-Display zu nutzen. Erstelle einen neuen Sketch oder bearbeite den bestehenden und füge den folgenden Code ein:

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

#define SCREEN_WIDTH 128
#define SCREEN_HEIGHT 64

VL53L0X sensor;
Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire);

void setup() {
  Serial.begin(9600);
  Wire.begin();

  sensor.init();
  sensor.setTimeout(500);

  display.begin(SSD1306_SWITCHCAPVCC, 0x3C);
  display.clearDisplay();
  display.setTextSize(1);
  display.setTextColor(WHITE);
  display.setCursor(0, 0);

  Serial.println("VL53L0X-Sensor bereit!");
}

void loop() {
  int distance = sensor.readRangeSingleMillimeters();

  if (sensor.timeoutOccurred()) {
    Serial.print("Timeout! ");
  }

  display.clearDisplay();
  display.setCursor(0, 0);
  display.print("Abstand: ");
  display.print(distance);
  display.print(" mm");
  display.display();

  Serial.print("Abstand: ");
  Serial.print(distance);
  Serial.println(" mm");

  delay(1000);
}

Lade den Sketch auf Deinen Arduino UNO hoch. Die gemessene Entfernung sollte nun auf dem OLED-Display angezeigt werden.

Möchtest du die Entfernung lieber mit Ultraschall messen? Bei uns erfährst du auch, wie das geht.

Der Arduino ist ein einfaches, kostengünstiges Mikrocontroller-Board, das für viele verschiedene Dinge verwendet werden kann, z. B. zum Erstellen einfacher Spiele, zum Messen von Temperatur oder Licht, zum Steuern von Motoren oder zum Auslesen analoger Sensoren. Es wird mit einer einfach zu bedienenden integrierten Entwicklungsumgebung (IDE) geliefert, so dass du dich nicht um die Details der Hardwareprogrammierung kümmern musst. Stattdessen schließt du einfach deinen Arduino an, schreibst deinen Code in C++, kompilierst ihn und lädst ihn auf deinen Mikrocontroller.

Was brauchst du also, um loszulegen? Den Arduino selbst, ein USB-Kabel und einen Computer samt IDE. Schauen wir uns das genauer an. Im Folgenden erfährst du Schritt für Schritt, wie du mit der Arduino-Programmierung beginnst.

Welche Hardware benötige ich?

Natürlich geht es nicht ohne ein Arduino-Board. Okay, das ist nicht ganz richtig, du könntest einen Arduino in einem Simulator wie Tinkercad programmieren – aber natürlich macht es mehr Spaß mit echter Hardware. Wenn du bei Google oder Amazon “Arduino” eingibst, wirst du mit Alternativen überschüttet. Es gibt Originalplatinen von den namensgebenden Erfindern des Boards und eine Vielzahl von Klonen.

Gegen einen Klon ist nichts einzuwenden – die meisten von ihnen sind genauso gut wie das Original. Allerdings gibt es auch sehr billige Produkte, die mehr Ärger als Freude bereiten. Achte also zumindest ein wenig auf den Preis.

Auch innerhalb der Arduino-Familie gibt es eine Vielzahl von Alternativen. Angefangen hat alles mit dem Arduino UNO, der immer noch das erste Board für die meisten Anfänger ist. Mittlerweile gibt es aber auch Boards, die einfach mehr Leistung und Anschlusspins haben (wie der Arduino MEGA) oder auch speziell für den Bereich der künstlichen Intelligenz konzipiert wurden, wie der Arduino Nano 33 BLE Sense.

Wenn du deinen ersten Arduino kaufen willst, wählst du am besten einen UNO – entweder das Original oder einen Klon im Bereich von 10€. Apropos Hardware: Du benötigst natürlich einen Computer, an den du den Arduino anschließen kannst. Die Arduino IDE, über die du gleich mehr lernst, läuft unter Windows, Mac OS und Linux.

Welche Software benötige ich?

Die einfachste Methode, um deinen Arduino zu programmieren, ist die Arduino IDE. Diese erhältst du kostenlos direkt bei Arduino. Achte darauf, dir die neueste Version herunterzuladen und das Programm regelmäßig zu aktualisieren. Denn nur mit einer aktuellen Version gehst du sicher, dass deine Programme einwandfrei funktionieren.

Du kannst die Programme für deinen Arduino natürlich auch mit jeder anderen Textverarbeitung schreiben – allerdings hat die IDE einige Vorteile: Du kannst mit ihr Programm-Bibliotheken verwalten, die dir nützliche Funktionen für Sensoren, Displays und vieles mehr bereitstellen. Außerdem zeigt sie dir Fehler im Code schon beim Kompilieren an und verfügt natürlich auch über einen Upload-Button, der dein Programm (im Arduino-Kontext nennt man Programme übrigens Sketches) auf den Arduino lädt.

Weitere Alternativen zur Arduino IDE sind der Web-Editor, mit dem du deinen Arduino im Browser programmieren kannst. Und es gibt noch die Arduino IDE 2.0 – hierbei handelt es sich um eine Weiterentwicklung der Arduino IDE in den Versionen 1.x, die weitere nützliche Features, wie z.B. Autovervollständigung, besitzt. Aber wie gesagt: Als Einsteiger ist die Arduino IDE in den Versionen 1.x, installiert auf einem Computer, die beste Wahl.

Welche Programmiersprache muss ich lernen?

Der Arduino wird üblicherweise in der Sprache C++ programmiert. Hierbei handelt es sich um eine recht “alte” Sprache – ihre Anfänge gehen zurück ins Jahr 1985. C++ kommt oft zum Einsatz, wenn es darum geht, Hardware zu programmieren. D.h. Code direkt auf einem Microcontroller ausführen zu lassen.

Viele Leute denken, C++ sei sehr speziell und daher auch schwer zu lernen – aber das stimmt nicht. Viele Grundkonzepte, was du vielleicht schon von anderen Sprachen wie Python oder JavaScript kennst, ist auch in C++ vorhanden: Variablen, Loops, Funktionen etc.

Außerdem greift dir die Arduino IDE stark unter die Arme. Vieles, was nötig ist, um Code auf dem Arduino laufen zu lassen, erledigt sie alleine im Hintergrund. Hierum musst du dich nicht kümmern, sondern kannst dich ganz auf deine Ideen konzentrieren.

Wo kann ich lernen, meinen Arduino zu programmieren?

Es gibt mittlerweile viele Videos und Online-Tutorials im Internet, mit denen du lernen kannst, deinen Arduino zu programmieren. Auch gibt es viele Starter Kits, in denen du neben einer Vielzahl von Bauteilen auch kurze Beschreibungen findest, wie du diese in einem Programm ansteuerst und verwendest.

Hier bei Pollux Labs gibt es einen Online-Kurs, in dem du die Grundlagen von C++ lernst, indem du Arduino-Projekte baust. Im Kit findest du auch einen ESP8266 – ein Microcontroller mit WLAN – mit dem du auch Projekte im Bereich Internet of Things bauen kannst. So wirst du vom Einsteiger zum Maker!

Das Internet of Things liegt im Trend und wird sicherlich auch nicht wieder verschwinden. So ist es nur logisch, dass sich auch ältere Kinder und Heranwachsende mit diesem spannenden Thema beschäftigen möchten.

Ein besonders interessanter Bausatz in diesem Bereich ist Spencer – der DIY Sprachassistent von CircuitMess.

Spencer ist ein Sprachassistent, der eine Vielzahl von Anweisungen verstehen und ebenso viele Fragen beantworten kann. Du kannst ihn z.B. nach der Uhrzeit fragen, oder wie das Wetter draußen ist. Oder ihn bitten, dir einen Witz zu erzählen. Der Fokus liegt hier auf Spaß – viele deiner Fragen wird Spencer mit einem launischen Kommentar beantworten. Trotzdem ist er immer wieder für einen Überraschung gut.

Allerdings: Aktuell (Stand Mai 2021) versteht und spricht Spencer nur Englisch. Da die Gespräche jedoch recht einfach gehalten sind, sollten auch größere Kinder (der Bausatz ist ab 11 Jahren) mit ihrem Schulenglisch gut zurecht kommen.

CircuitMess Spencer – DIY Sprachassistent Bausatz | Lerne Elektronik und Programmieren | Robotik Lernen | Mint Projekte für Kinder | ab 11 Jahren | Mint Bauspielzeug

114,99 €

Was kann ich lernen?

Du steckst den Bausatz nicht einfach nur zusammen und fertig. Um Spencer aufbauen zu können, musst du ein paar wenige Bauteile verlöten – deshalb ist ein Lötkolben unbedingt erforderlich. Das Löten hält sich aber in Grenzen und ist auch recht einfach gehalten. Du musst lediglich ein paar Stiftleisten, Widerstände, Kondensatoren etc. auf die Platinen löten. Schiefgehen kann hier eigentlich nichts.

Abgesehen vom Löten lernst du auch deine eigenen Programme zu erstellen. CircuitMess hat hierfür einen eigenen Code-Editor erstellt, mit dem du grafisch – also ohne tatsächlich Code zu schreiben – sogenannte Sketches für den Spencer programmieren kannst.

Die Bedienung erinnert hier stark an den beliebten Editor Scratch. Du kannst damit z.B. deinen Spencer so programmieren, dass er dir auch Knopfdruck zuhört und nachspricht, was er verstanden hat.

Was ist der CircuitMess Spencer eigentlich?

Spencer ist im Prinzip ein kleiner Kasten aus Acryl-Glas mit einem großen roten Knopf darauf. In ihm schlummert aber recht aktuelle Technik.

An der Frontseite verleiht im ein großen Panel mit LEDs ein Gesicht. Hier kannst du Animationen laufen lassen oder auch die Uhrzeit anzeigen.

Angetrieben wird Spencer von einem ESP32 – ein Microcontroller, der für seinen Bereich recht leistungsstark ist und sich auch mit deinem WLAN verbinden kann. Apropos Internet: Um Spencer sinnvoll verwenden zu können, solltest du Zugriff auf ein WLAN-Netzwerk haben.

Auf der Rückseite befindet sich ein kleiner Lautsprecher, über den dir Spencer antworten kann. Fehlt noch der große rote Knopf – diesen drückst du, um Fragen zu stellen und Anweisungen zu geben. Natürlich kannst du ihn in deinen eigenen Programmen auch anderweitig einsetzen.

Das ist im Bausatz enthalten

Du findest im Karton natürlich alle benötigten Teile:

• Zwei Platinen mit LEDs und dem ESP32
• Widerstände, Kondensatoren, LED etc. zum selbst verlöten
• Die Box aus Acrylglas
• Lautsprecher und Knopf
• Schrauben und Muttern
• Das passende USB-Kabel

Nicht enthalten ist das Werkzeug. Du benötigst du noch einen Lötkoblen samt Lötzinn, einen Saitenschneider und einen Kreuzschraubendreher.

Auch ein Netzteil ist nicht dabei – du kannst deinen Spencer zwar über USB von deinem Computer aus mit Strom versorgen. Falls du das nicht möchtest, benötigst du noch ein handelsübliches 5V-Netzeil mit USB-Port.

Spencer aufbauen

Für den Aufbau solltest du dir ungefähr zwei Stunden Zeit nehmen, um dich in aller Ruhe dem Löten widmen zu können. Denn damit fängt alles an.

CircuitMess hat eine sehr gute Anleitung bereitgestellt, die dich Schritt für Schritt mit vielen Bildern durch den Aufbau führt. Du findest die Anleitung hier. Auch diese Anleitung ist auf Englisch – allerdings sehr einfach geschrieben, sodass sie dir keine Probleme bereiten sollte.

Wie gesagt, beginnst du mit dem Löten. Hier ist alles klar beschrieben und auf den Platinen beschriftet. Damit finden sich auch Löteinsteiger gut zurecht, zumal die Lötstellen sehr gut zugänglich sind und weit entfernt von sensiblen Teilen liegen.

Die Gefahr, dass du beim Löten also etwas kaputt machst, ist sehr gering.

Nach dem Löten folgt der Zusammenbau. Auch das macht aufgrund der Einfachheit recht viel Spaß. Alle Teile passen perfekt zusammen, sodass sich die Fummelei stark in Grenzen hält.

Die Maker von CircuitMess haben hier ganze Arbeit geleistet und dafür gesorgt, dass zu keiner Zeit auch nur ein Hauch Frust aufkommt.

CircuitBlocks installieren

Nachdem du deinen Spencer zusammengebaut hast, wird es Zeit für etwas Code! Auf dem ESP32 ist bereits eine sogenannte Firmware vorinstalliert. Sobald du deinen neuen Sprachassistenten per USB mit Strom versorgst, startet er mit einer Begrüßung und dem Hinweis, dass er dein Zugangsdaten fürs Internet braucht.

Um diese Einstellung vorzunehmen – und Spencer danach auch neu zu programmieren – eignet sich der hauseigene Editor CircuitBlocks, den du hier herunterladen kannst. Sobald du CircuitBlocks installiert hast, erwartet dich eine aufgeräumte Oberfläche.

Oben rechts findest du die beiden Buttons Restore firmware und Spencer Settings. Mit ersterem kannst du deinen Spencer jederzeit wieder in den Anfangszustand versetzen. Hinter dem zweiten trägst du deine WLAN-Zugangsdaten ein und legst fest.

Wir möchten an dieser Stelle nicht zu tief in die Grundlagen von CircuitBlocks einsteigen, denn auch hierfür gibt es eine sehr gute Anleitung.

Dein erstes eigenes Programm

Diese Anleitung führt dich auch Schritt für Schritt durch die Basics und du “schreibst” deinen ersten eigenen Code für deinen CircuitMess Spencer. Allerdings “schreibst” du ihn nicht wirklich, sondern verwendest die Code-Blöcke auf der linken Seite. Du kannst dir aber jederzeit den Code, der hieraus in der Programmiersprache C++ generiert wird, anzeigen lassen.

Mit den Beispiel-Programmen in der Anleitung zauberst du zunächst Animationen auf das LED-Panel und lässt verschiedene Sound abspielen. Anschließend wird es allerdings schon spannender: Mit wenigen Blöcken bringst du Spencer dazu, dir zuzuhören und das, was er gehört hat, nachzusprechen. Er versteht allerdings nur Englisch, wie gesagt.

Fazit

Dieser Bausatz vom jungen, kroatischen Unternehmen CircuitMess vereint mehrere interessant Aspekte des Bastelns mit Elektronik. Da wäre zum Einen das Löten, das seinen ganz eigenen Charme hat – allerdings hier auch Anfänger nicht überfordert. Allerdings hat natürlich nicht jede*r einen Lötkolben zu Hause – diese gibt es jedoch schon sehr günstig im Handel. Und wer weiß, vielleicht ist das ja nicht das letzte Lötprojekt.

Zum Anderen, dass Spencer zum Themenbereich Internet of Things gehört, also mit der Welt da draußen interagieren kann. CircuitMess spricht auch gerne davon, dass Bastler etwas über künstliche Intelligenz und Spracherkennung lernen. Das stimmt zwar im weitesten Sinne, wir hätten uns jedoch etwas mehr “Stoff” zu diesem Thema gewünscht.

Apropos, zu vielen Aspekten dieser Themen findest du Tutorials bei Pollux Labs.

Die Verarbeitung aller Bauteile ist exzellent und auch die Verpackung ist liebevoll gestaltet und hochwertig – was für den relativ hohen Preis auch gerechtfertigt ist.

Angehende Makerinnen und Maker finden im CircuitMess Spencer viel Anregung und eine Herausforderung, die gut zu bewältigen ist. Und auch nach dem Aufbau bietet das Programmieren und Ausprobieren noch viele Wochen Spaß – wenn das Thema denn begeistert.

CircuitMess Spencer – DIY Sprachassistent Bausatz | Lerne Elektronik und Programmieren | Robotik Lernen | Mint Projekte für Kinder | ab 11 Jahren | Mint Bauspielzeug

114,99 €

In diesem Tutorial erfährst du, wie du die das RTC-Modul DS1307 am Arduino anschließt und damit die aktuelle Uhrzeit samt Datum auf einem Display anzeigst.

Was ist eine Real Time Clock?

In den meisten Fällen erhältst du beim Kauf einer Real Time Clock* ein Modul, auf dem oft ein DS1307 samt einer kleinen Batterie verbaut ist. Diese sorgt dafür, dass dein Arduino die aktuelle Zeit ermitteln kann, auch wenn es zwischenzeitlich zu einem Stromausfall gekommen ist – denn die RTC wird weiterhin mit Strom versorgt.

Diese Bauteile sind in der Regel recht preisgünstig und werden per I²C am Microcontroller angeschlossen. Die Genauigkeit ist für die allermeisten Projekte ausreichend und die Knopfbatterie hält bis zu fünf Jahre durch.

Die RTC am Arduino anschließen

Dank der Verbindung per I²C benötigst du nur vier Kabel, um die Real Time Clock an deinem Arduino anzuschließen. Wenn du einen Arduino UNO verwendest, benötigst du (neben GND und 5V) hierfür die Pins A4 und A5. Orientiere dich an folgender Skizze:

Wenn du ein anderes Arduino-Modell verwendest, findest du die benötigten Pins in der Arduino-Referenz. Am ESP8266 kommunizierst du mit den Pins D1 (SCL) und D2 (SDA) per I²C. Da der ESP8266 über WLAN verfügt, kannst du hier natürlich aber auch die aktuelle Zeit von einem NTP-Server abfragen.

Die benötigten Bibliotheken

Um eine RTC mit dem Chip DS1307 verwenden zu können, benötigst du zwei Bibliotheken. Öffne hierfür den Bibliotheksverwalter und suche dort nach nach DS1307rtc. Du findest neben der gleichnamigen Bibliothek auch die Bibliothek Time. Installiere jeweils die aktuelle Version.

Sollte deine Real Time Clock einen anderen Chip haben, suche stattdessen nach dessen Namen. Im Folgenden arbeiten wir jedoch mit dem DS1307 weiter.

Wenn beide Bibliothek in deiner Arduino IDE installiert sind, kann es auch schon mit dem Einstellen der Uhr weitergehen.

Die aktuelle Uhrzeit in der RTC einstellen

Bevor in deinem RTC-Modul die Uhr ticken kann, muss es natürlich erst einmal wissen, wie viel Uhr es ist. Hierfür benötigst du einen Sketch, der bereits in den mitgelieferten Beispielen der Bibliothek DS1307RTC vorhanden ist.

Den Sketch findest du in der Arduino IDE unter Datei > Beispiele > DS1307RTC > SetTime

Öffne ihn und lade ihn auf deinen Arduino. Mit diesem Sketch “lädt” dein Arduino die aktuelle Uhrzeit samt Datum von deinem Computer und speichert beides in der RTC.

Das war es auch schon mit der Konfiguration. Den Sketch SetTime musst du erst wieder nach dem nächsten Batteriewechsel ausführen.

Uhrzeit und Datum im Seriellen Monitor ausgeben

Für einen ersten Test reicht ebenfalls ein Beispiel-Sketch der Bibliothek. Öffne im gleichen Verzeichnis den Sketch ReadTest und lade ihn auf deinen Arduino.

In deinem Seriellen Monitor sollte nun im Sekundentakt die aktuelle Uhrzeit und das Datum erscheinen.

Uhrzeit und Datum auf einem LCD-Display anzeigen

Der Serielle Monitor ist das Eine – aber eine Digitaluhr ist etwas ganz Anderes. Schließe hierfür zunächst dein LCD-Display am Arduino zusätzlich zur RTC an.

Danach kommt der Sketch an die Reihe. Um es einfach zu halten, haben wir einfach den Sketch ReadTest modifiziert und um das Setup des LCD-Displays und der Ausgabe darauf erweitert.

Du findest im Loop nun unter jeder Ausgabe von Stunden, Minuten etc. auch den entsprechenden lcd.print() direkt darunter.

Ein besonderer Clou ist hierbei die Funktion void print2digits(), die auch schon im Sketch vorhanden ist. Diese Funktion sorgt dafür, dass jede Zahl zweistellig angezeigt wird. Ohne diese Funktion würde die Uhrzeit 16:08 als 16:8 auf dem Display dargestellt.

Hier nun der gesamte Sketch:

#include <Wire.h>
#include <TimeLib.h>
#include <DS1307RTC.h>

#include <LiquidCrystal.h>
const int rs = 11, en = 12, d4 = 2, d5 = 3, d6 = 4, d7 = 5; //Anschlüsse LCD -> Arduino
LiquidCrystal lcd(rs, en, d4, d5, d6, d7);

void setup() {
  Serial.begin(9600);
  while (!Serial) ; // wait for serial
  delay(200);
  Serial.println("DS1307RTC Read Test");
  Serial.println("-------------------");
}

void loop() {

  // Festlegen, wie viele Zeichen und Reihen das Display hat:
  lcd.begin(16, 2);

  tmElements_t tm;

  if (RTC.read(tm)) {
    Serial.print("Ok, Time = ");
    print2digits(tm.Hour);
    lcd.setCursor(0, 0);
    lcd.print(tm.Hour);

    Serial.write(':');
    lcd.print(':');

    print2digits(tm.Minute);
    lcd.print(tm.Minute);

    Serial.write(':');
    lcd.print(':');

    print2digits(tm.Second);
    lcd.print(tm.Second);

    Serial.print(", Date (D/M/Y) = ");
    Serial.print(tm.Day);
    lcd.setCursor(0, 1);
    lcd.print(tm.Day);

    Serial.write('/');
    lcd.print('/');
    
    Serial.print(tm.Month);
    lcd.print(tm.Month);

    Serial.write('/');
    lcd.print('/');
    
    Serial.print(tmYearToCalendar(tm.Year));
    lcd.print(tmYearToCalendar(tm.Year));
    
    Serial.println();
  } else {
    if (RTC.chipPresent()) {
      Serial.println("The DS1307 is stopped.  Please run the SetTime");
      Serial.println("example to initialize the time and begin running.");
      Serial.println();
    } else {
      Serial.println("DS1307 read error!  Please check the circuitry.");
      Serial.println();
    }
    delay(9000);
  }
  delay(1000);
}

void print2digits(int number) {
  if (number >= 0 && number < 10) {
    Serial.write('0');
    lcd.print('0');
  }
  Serial.print(number);
}

Wie geht es weiter?

Weiter Anleitungen zu Bauteilen und vollständige Arduino Projekte findest du in unserem Buch für angehende Maker:

Vom Anfänger zum Maker: Mit dem Arduino und ESP8266

• Kumbartzki, Frederik (Autor)

17,90 €

Bei Amazon kaufen

Du hast nun die Möglichkeit, in deinem Projekt immer die aktuelle Uhrzeit zu verwenden. Welche Ideen kommen dir nun in den Sinn? Wie wäre es z.B. mit einem Wecker, der dich mit einem Piezo weckt?

In diesem Tutorial lernst du, wie du den DHT11 und den DHT22 am Arduino und ESP8266 anschließt und verwendest.

Den Sensor DHT11 anschließen

Der Anschluss des DHT11 am Arduino ist ganz leicht, du benötigst lediglich drei Kabel. Orientiere dich beim Anschluss an folgender Skizze. An welchen Digital-Pin du deinen Sensor anschließt, steht dir natürlich frei. Damit der Code dieses Tutorials passt, wähle bitte den Pin 4.

Den Sensor DHT22 anschließen

Um deinen DHT22 am Arduino oder ESP8266 anzuschließen, benötigst du neben Sensor, Microcontroller, Breadboard und Kabeln einen Widerstand mit 10 kΩ. Orientiere dich beim Anschluss am Arduino an folgender Skizze:

Hier ist der Signalpin des DHT22 am Digital-Pin 4 des Arduinos angeschlossen – so passt der Anschluss zum Sketch unten. Prinzipiell steht es dir natürlich frei, welchen Digital-Pin du verwendest.

Der Anschluss am ESP8266 sieht folgendermaßen aus:

Beim Arduino kannst du den DHT11 oder DHT22 entweder mit 5 Volt oder 3,3 Volt versorgen. Beim ESP8266 stehen dir natürlich nur 3,3 Volt zur Verfügung.

Die passenden Bibliotheken

Du benötigst zwei Bibliotheken, von denen du jedoch nur eine im Sketch einbinden musst. Öffne zunächst deinen Bibliotheksmanager und suche dort nach Adafruit Unified Sensor. Installiere anschließend die aktuelle Version.

Suche nun nach DHT11 oder DHT22 und installiere die Bibliothek DHT sensor library.

Wenn du beide Bibliotheken erfolgreich installiert hast, geht es weiter mit der Messung.

Temperatur und Luftfeuchtigkeit messen

Binde als erstes die Bibliothek für den Sensor zu Beginn deines Sketchs ein:

#include "DHT.h"

Anschließend definierst du den Pin, an dem der Sensor angeschlossen ist. In der Zeile danach legst du den Typ des DHT fest: In unserem Fall also DHT22 – wenn du einen DHT11 verwendest, kannst du die Zeile entsprechend abändern.

#define DHTPIN 4   
#define DHTTYPE DHT22

Nun fehlen noch zwei Variablen für die Temperatur und die Luftfeuchtigkeit sowie ein Objekt für den Sensor namens dht.

float temp;
float humidity;

DHT dht(DHTPIN, DHTTYPE);

In der Setup-Funktion startest du den Sensor mit

dht.begin();

Die eigentliche Messung findet dann im Loop statt. Diese könnte dank der eingebundenen Bibliothek kaum einfacher sein, da es passende Funktionen gibt. Die Messergebnisse speicherst du in den entsprechenden Variablen:

temp = dht.readTemperature();
humidity = dht.readHumidity();

Und das war es schon. Hier nun der vollständige Sketch, in dem du die Messergebnisse alle zwei Sekunden im Seriellen Monitor ausgibst:

#include "DHT.h"

#define DHTPIN 4   
#define DHTTYPE DHT22

float temp;
float humidity;

DHT dht(DHTPIN, DHTTYPE);

void setup() {
  Serial.begin(9600);
  dht.begin();
}

void loop() {

  temp = dht.readTemperature();
  humidity = dht.readHumidity();
  
  Serial.print("Temperatur: ");
  Serial.print(temp);
  Serial.println(" *C");
  Serial.print("Luftfeuchtigkeit: ");
  Serial.print(humidity);
  Serial.println(" %");

  Serial.println();
  delay(2000);

}

Wie geht es weiter?

Wie wäre es mit einem eigenen ESP8266 Web Server, über den du die aktuelle Temperatur vom Smartphone aus abrufen kannst?

Hier lernst du, wie du einen Farbsensor* anschließt, damit Farben erkennst und diese in das bekannte RGB-Modell umrechnest. In diesem Tutorial verwenden wir den gängigen Sensor TC3200.

AZDelivery Farbsensor TCS230 TCS3200 Farben Sensor Modul kompatibel mit Arduino inklusive E-Book!

Chip: TAOS TCS3200 RGB Sensor; Eingangsspannung: DC 3 ~ 5V; Hellweiße LEDs...

8,99 €

Den Farbsensor am Arduino anschließen

Am Sensor findest du insgesamt 8 Pins, von denen du 7 mit deinem Arduino wie folgt verbinden kannst. Die Wahl der Digitalpins ist natürlich dir selbst überlassen.

Eine kurze Erklärung zu den einzelnen Pins am Farbsensor: Mit den Pins S0 und S1 kannst du die Ausgangsfrequenz des Sensors steuern. So kannst du deine Ergebnisse optimieren, was wir in diesem Tutorials allerdings erst einmal beiseite lassen.

Die Pins S2 und S3 steuern die einzelnen Photodioden des Sensors. Hiervon gibt es je 16 Stück für die Farben Rot, Grün, Blau und Clear (also ohne Farbfilter). Die beiden Pins kannst du von deinem Arduino entweder auf HIGH oder LOW setzen – die Kombination bestimmt dann, welche Dioden angesprochen und welche Farbe also “gelesen” werden soll:

Gleich im Sketch schauen wir uns diese Kombinationen genauer an. Es fehlt allerdings noch der Pin OUT – hierüber liest dein Arduino die Messergebnisse ein.

Der Sketch zum Farben erkennen

Kommen wir also zum Code. Du benötigst für den Farbsensor keine eigene Bibliothek, sondern kannst die Messungen mit ein paar einfachen Funktionen selbst erledigen. Definiere zunächst die verwendeten Anschlüsse zu Beginn des Sketchs:

#define S0 6
#define S1 7
#define S2 8
#define S3 9
#define sensorOut 10

Anschließend benötigst du noch je drei Variablen für die Roh- und RGB-Werte der einzelnen Farben Rot, Grün und Blau:

int frequencyR = 0;
int frequencyG = 0;
int frequencyB = 0;

int red = 0;
int green = 0;
int blue = 0;

Die Setup-Funktion

Hier startest du deinen Seriellen Monitor und definierst die einzelnen pinModes:

Serial.begin(115200);

pinMode(S0, OUTPUT);
pinMode(S1, OUTPUT);
pinMode(S2, OUTPUT);
pinMode(S3, OUTPUT);
pinMode(sensorOut, INPUT);

Wie du siehst, sprichst du die Pins S1 bis S3 von deinem Arduino aus an (OUTPUT) und möchtest vom Pin sensorOut Messdaten erhalten (INPUT). Fehlt noch eine Sache: Wie oben kurz erwähnt, steuerst du mit den Pins S1 und S2 die Ausgangsfrequenz. Diese setzt du mit den folgenden zwei Zeilen auf 20%:

digitalWrite(S0, HIGH);
digitalWrite(S1, LOW);

Für die Ausgangsfrequenz gibt es festgelegte Werte und Kombinationen. Wenn du etwas tiefer einsteigen und die Ergebnisse deines Sensors optimieren möchtest, orientiere dich an dieser Tabelle:

Der Loop

Kommen wir also zu den Messungen. Im Loop deines Sketchs führst du für jede der drei Farben Rot, Grün und Blau eine separate Messung durch und rechnest deine Ergebnisse in den RGB-Farbraum um. Zunächst der Code für Rot:

digitalWrite(S2, LOW);
digitalWrite(S3, LOW);

frequencyR = pulseIn(sensorOut, LOW);
Serial.print("Red = ");
Serial.print(frequencyR);

Als erstes setzt du die beiden Pins S2 und S3 auf LOW, um nur die Photodioden mit rotem Farbfilter anzusprechen. Anschließend liest du den Wert mit der Funktion pulseIn() ein und speicherst den Wert in der Variablen frequencyR. Zuletzt gibst du ihn im Seriellen Monitor aus. In der Arduino-Referenz lernst du mehr über die Funktion pulseIn().

Mit diesen Messergebnissen kannst du noch nicht viel anfangen – besser ist es, wenn du einen bekannten Wert wie den Rotanteil im RGB-Modus erhältst. So kannst du nämlich zusammen mit den Ergebnissen der Farben Grün und Blau die Farbe vor deinem Sensor mehr oder weniger genau bestimmen und sie z.B. zur Kontrolle auf einem TFT-Display* anzeigen.

Um das zu erreichen, bietet sich die Funktion map() an:

map(frequencyR, 20, 120, 255, 0)

In dieser Funktion benötigst du fünf Argumente: Zunächst den Messwert frequencyR und den Messbereich des Sensors. Hierfür machst du am besten ein paar Testmessungen mit verschiedenfarbigen Objekten vor deinem Farbsensor und schaust dir die Minimal- und Maximalwerte im Seriellen Monitor an. Bei uns lagen die Werte ungefähr im Bereich von 20 bis 120 – das kann bei dir jedoch anders sein.

Wenn du deinen passenden Wertebereich ermittelt hast, kommen die letzten beiden Argumente ins Spiel. Diese geben den maximalen (255) und minimalen Rotwert (0) im RGB-Modus an. Je “mehr” Rot dein Farbsensor erkennt, desto geringer sein Messwert (bei uns also in Richtung 20). Das entspricht jedoch einem hohen Wert im RGB-Farbraum – deshalb “mappst” du die 20 auf die 255 und andersherum die 120 auf die 0.

Alle Farben zusammen

Und das war es im Prinzip. Für die Farben Blau und Grün wiederholst du einfach das Prozedere der Farbe Rot. In deinem Seriellen Monitor siehst du nun die RGB-Werte jeder einzelnen Farbe, die zusammen in etwa die Farbe des Objekts vor dem Sensor ergeben sollten.

Hier nun der gesamte Sketch zum Rauskopieren:

//pins for color sensor
#define S0 6
#define S1 7
#define S2 8
#define S3 9
#define sensorOut 10

//raw and RGB values for each color
int frequencyR = 0;
int frequencyG = 0;
int frequencyB = 0;

int red = 0;
int green = 0;
int blue = 0;

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

  pinMode(S0, OUTPUT);
  pinMode(S1, OUTPUT);
  pinMode(S2, OUTPUT);
  pinMode(S3, OUTPUT);
  pinMode(sensorOut, INPUT);
  digitalWrite(S0, HIGH);
  digitalWrite(S1, LOW);
}

void loop() {
  digitalWrite(S2, LOW);
  digitalWrite(S3, LOW);

  frequencyR = pulseIn(sensorOut, LOW);
  Serial.print("Red = ");
  //Serial.print(frequencyR);
  red = map(frequencyR, 20, 150, 255, 0);
  Serial.print(red);


  digitalWrite(S2, LOW);
  digitalWrite(S3, HIGH);

  frequencyB = pulseIn(sensorOut, LOW);
  Serial.print(" Blue = ");
  //Serial.print(frequencyB);
  blue = map(frequencyB, 20, 150, 255, 0);
  Serial.print(blue);


  digitalWrite(S2, HIGH);
  digitalWrite(S3, HIGH);

  frequencyG = pulseIn(sensorOut, LOW);
  Serial.print(" Green = ");
  //Serial.println(frequencyG);
  green = map(frequencyG, 20, 150, 255, 0);
  Serial.println(green);

  delay(100);
}

Wie geht es weiter?

Du kannst nun Farben mit einem Farbsensor erkennen und sie in den RGB-Farbraum übertragen. Wie wäre es, wenn du dir einen eigenen Color Picker baust, mit dem du die RGB-Werte einzelner Objekte ermittelst? Hierfür bietet sich ein TFT-Display an, auf dem du die ermittelte Farbe auch gleich darstellen kannst.

Früher oder später kommt jeder Maker an den Punkt, an dem er ein Projekt mit einem Servo-Motor bauen möchte – z.B. für einen Zeiger oder für einen Roboterarm. In diesem Tutorial lernst du, wie du einen Servo am Arduino anschließt und steuerst. Du erfährst, wie du den kleinen Motor mit einem Poti verwendest, Sensordaten damit visualisierst und was es bei der Stromzufuhr zu beachten gilt.

Was ist ein Servo?

Zunächst ein paar Worte darüber, was ein Servo eigentlich ist: Hierbei handelt es sich um einen Motor, der nicht einfach nur anfängt zu laufen, sondern den du auf eine bestimmte Position drehen kannst. Das heißt, du kannst ihm einen Winkel von 0° bis 180° zuweisen und damit z.B. einen am Servo montierten Zeiger im Halbkreis drehen lassen.

Angebot

AZDelivery Micro Servo Motor kompatibel mit SG90 9G für RC Roboter Hubschrauber Flugzeug kompatibel mit Arduino ink. E-Book!

5,79 €

Die Bibliothek Servo.h

Damit die Steuerung für dich so einfach wie möglich ist, gibt es die Bibliothek Servo.h – die in der Regel bereits vorinstalliert ist, sodass du sie ohne Umwege in deinem Sketch einbinden kannst. Mit ihr kannst du bis zu 12 Motoren an einem Arduino verwenden (am Arduino Due sogar 60).

Binde die Bibliothek am Anfang deines Sketchs wie folgt ein:

#include <Servo.h>

Zwei Funktionen der Bibliothek benötigst du immer wieder, wenn du mit Servos arbeitest:

• attach(pin) – Hier legst du einmalig den Pin fest, an dem dein Servo-Motor angeschlossen ist
• write(angle) – Damit “fährst” du den Servo an den gewünschten Winkel (angle)

Im Verlauf dieses Tutorials schauen wir uns diese Funktionen genauer an. Weitere Funktionen dieser Bibliothek lernst du in der Arduino-Referenz kennen.

Die Minimalschaltung

Für die allerersten Gehversuche reicht es, wenn du deinen Servo wie folgt mit deinem Arduino verbindest. Für das Signal (orange) kannst du natürlich einen Digitalpin deiner Wahl verwenden. In den folgenden Sketches verwenden wir jedoch immer Pin 8.

Hinweis: Jeder Servo hat drei Kabel: Strom (5V), Masse (GND) und Signal. Diese haben jedoch je nach Modell eine unterschiedliche Reihenfolge. Vergewissere dich immer, dass du alles richtig angeschlossen hast, bevor du ihn mit Strom versorgst.

Der erste Sketch

Auch hier halten wir alles so einfach wie möglich. Kopiere dir den folgenden Sketch und lade ihn auf deinen Arduino.

#include <Servo.h>

Servo myServo;

void setup() {
  myServo.attach(8);
}

void loop() {
  myServo.write(0);
  delay(2000);
  myServo.write(90);
  delay(2000);
  myServo.write(180);
  delay(2000);
  myServo.write(90);
  delay(2000);
}

Ganz oben im Sketch bindest du die Bibliothek Servo.h ein. Danach erstellst du ein Objekt mit dem Namen myServo.

Im Setup verknüpfst du mithilfe der Funktion attach() den Digitalpin mit diesem Objekt – oder einfacher gesagt, du teilst deinem Arduino mit, dass dein Servo am Pin 8 hängt.

Im Loop steuerst du mit deinem Motor nun verschiedene Winkel mit der Funktion write() an. Du beginnst bei 0° und wartest zwei Sekunden. Danach drehst du weiter auf 90°, dann auf 180°, zurück auf 90° – und wieder von vorne.

Einen Kondensator verwenden

Ein Servo benötigt recht viel Strom, vor allem zu Beginn einer Bewegung. Das kann zu einem Spannungsabfall führen, der zu ungewünschten Ergebnissen bis hin zu einem Reset des Arduinos führen kann.

Um dem vorzubeugen, kannst du einen Kondensator* in die Stromversorgung des Motors einbauen, wie du hier sehen kannst:

Der Kondensator mit einer Kapazität von mindestens 470µF speichert Energie, die der Servo neben jener vom Arduino nutzen kann. Damit kannst du den Spannungsabfall etwas verringern.

Hinweis: Wenn du einen Elektrolytkondensator* (Elko) verwendest, achte unbedingt auf die richtige Polarität: Die Seite mit dem hellen Strich (s. Screenshot oben) muss an Erde (GND). Wenn du die Seiten vertauschst, kann der Kondensator explodieren!

Wenn auch ein Kondensator nicht hilft, kannst du deinen Servo an seinen eigenen Stromkreis anschließen, der vom Arduino (und weiteren dort angeschlossenen Teilen) unabhängig ist.

Den Servo mit einem Poti steuern

Jetzt gehen wir noch einen Schritt weiter: Du steuerst deinen Motor mit einem Poti*. Ziel ist es hierbei, dass er sich analog zu den Bewegungen des Potentiometers dreht.

Füge also deinem Aufbau ein Poti wie folgt hinzu.

Kopiere dir anschließend den folgenden Sketch und lade ihn auf deinen Arduino:

#include <Servo.h>

int servoPosition;
int potiValue;

Servo myServo;

void setup(){
  pinMode(0, INPUT);
  myServo.attach(8);
}

void loop(){
  delay(10);
  potiValue = analogRead(0);
  servoPosition = map(potiValue, 0, 1024, 0, 180);
  myServo.write(servoPosition);
}

Neu in diesem Sketch sind zwei Variablen. In servoPosition speicherst du den Winkel, den der Servo ansteuern soll. In potiValue steht der aktuelle Wert des Potis, den du so ausliest und speicherst:

 potiValue = analogRead(0);

Jetzt wird es interessant: Den Winkel des Servos bestimmst du mit der Funktion map(). Hier “mappst” du den Wert, den dein Poti ausgibt (potiValue) auf den entsprechenden Winkel des Servos (servoPosition). Hierfür benötigst du sowohl für den Poti als auch für den Motor den Minimal- und Maximalwert. Für den Poti sind das 0 und 1024 – für den Servo 0 und 180 (Grad).

 servoPosition = map(potiValue, 0, 1024, 0, 180);

Zuletzt bewegst du den Motor auf die errechnete Position:

 myServo.write(servoPosition);

Steuerung mit einem Sensor

Noch ein letztes Experiment: Diesmal lässt du einem Temperatursensor den Servo steuern. Hier verwenden wir einen einfachen TMP36*, aber du kannst natürlich auch jeden anderen Temperatursensor verwenden.

Du ahnst sicher schon, worauf das Ganze hinausläuft – genau, ein Analogthermometer. Ersetze den Poti zunächst einfach durch den TMP36:

Im Sketch musst du ebenfalls nicht viel verändern. Wir haben nur den Namen der Variablen und die Funktion map() angepasst:

#include <Servo.h>

int servoPosition;
int temp;

Servo myServo;

void setup() {
  pinMode(0, INPUT);
  myServo.attach(8);
  Serial.begin(115200);
}

void loop() {
  delay(10);
  temp = analogRead(0);
  servoPosition = map(temp, 20, 358, 0, 180);
  myServo.write(servoPosition);
}

Wie du in der Funktion siehst, haben wir für den TMP36 einen Bereich von 20 bis 358 angegeben. Achte darauf, dass du hier einen für deinen Sensor passenden Wertebereich angibst. Übrigens, wenn du nicht die volle Bandbreite nutzen möchtest, also z.B. den Sensor nur zwischen 20° und 160° drehen möchtest, kannst du das natürlich in der Funktion anpassen.

Möchtest du ein reales Beispiel? Dann wir feinen Blick in unser Analogthermometer. Oder auf das Code-Schloss mit Folientastatur.

Und das soll es gewesen sein. Du weißt jetzt, wie du einen Servo-Motor am Arduino anschließt und ihn auf verschiedene Arten und Weisen steuern kannst. Viel Spaß bei deinen weiteren Experimenten!