Jänner 2021 – van Meel

Eigentlich wollten mein Sohn und ich etwas mit dem Calliope mini auf Open Roberta Lab experimentieren. Aber leider stand der Calliope nicht zur Verfügung.

Daher haben wir uns dazu entschieden auszuprobieren, ob wir einen Arduino mit Scratch programmieren können. Dazu gibt es die besondere Scratch 4 Arduino (S4A) Variante samt einer zugehörigen Firmware für den Arduino. Die genaue Anleitung welche Software man dafür braucht und wie man den Arduino mit der speziellen S4A Firmware bespielt findet man auf der Scratch 4 Arduino Download Seite.

Nachdem wir die Anleitung zur Einrichtung des Arduino für S4A durchgeführt haben, können wir mit unserem ersten Experiment beginnen: eine LED per Scratch ein- und ausschalten. Den Schaltplan dazu sieht wie folgt aus.

Schaltbild 1 – eine LED per Arduino ein- und ausschalten

Genau genommen wollen wir die LED blinken lassen. Dazu verwenden wir eine einfache Endlosschleife, die die D13 Pin abwechseln ein- und ausschalten und dazwischen jeweils 1 Sekunde wartet.

S4A Programmcode zu Experiment 1 – Blinkende LED

Das hat auf Anhieb geklappt. Also haben wir uns gedacht: bohren wir das Ganze noch etwas auf und machen die Blinkfrequenz mit einem Potenziometer einstellbar. Dazu erweitern wir die Schaltung um einen Potenziometer mit nachgeschalteten Widerstand und schließen das Ganze an den Analogeingang A0 an.

Schaltung 2 – Blinkfrequenz per Potentiometer über A0 einstellbar

Entsprechend müssen wir auch den Programmcode anpassen.

S4A Programmcode zu Experiment 2 – Variable Blinkfrequenz

In der Theorie liefert der analoge Eingang A0 Werte zwischen 0 (bei 0 Volt) und 1024 (bei 5 Volt). Falls wir den Potenziometer also auf Maximum (= 5 Volt) stellen, dann sollte die LED zwischen jedem An-Aus-Wechsel ca. 1 Sekunde warten. Drehen wir das Potenziometer auf Minimum (= 0 Volt) stellen, sollte keine Wartezeit zwischen dem Ein-Aus-Wechsel verstreichen, die LED als unendlich schnell blinken.

Wir beobachten aber ein anderes Verhalten. Stellen wir das Potenziometer auf Maximum, blinkt die LED wie erwartet mit ca. 0,5 Hz (ein Ein-Aus-Zyklus dauert 2 Sekunden). Drehen wir das Potenziometer langsam zurück, nimmt die Blinkfrequenz stetig zu. Soweit noch alles in Ordnung. Drehen wir aber weiter, verhält sich die LED ab einem gewissen Punkt sehr komisch, ist manchmal längere Zeit an oder aus und die Zeiten dazwischen verändern sich ständig.

Was geht da vor sich? Kann der Arduino nicht schneller? Nein, der Arduino kann noch sehr viel schneller – er ist immerhin mit 16 MHz getaktet. Liest man aber in der technischen Beschreibung der S4A Applikation nach, so stellt man fest: die S4A Applikation schickt alle 75 ms neue Befehle an den Arduino bzw. liest den Wert der analogen und digitalen Pins aus. Ist die Wartezweit zwischen dem Ein- und Ausschalten der LED kürzer als diese 75 ms, so kommt es zu einem Durcheinander – zumindest nehmen wir dies so wahr.

Eine Wartezeit von 75 ms entspricht einer Frequenz von ca. 13 Hz. Möchte man die LED schneller blinken lassen, so muss man sich etwas anderes einfallen lassen. Aber das werden wir uns heute nicht mehr anschauen.

Abschließend sind wir sehr zufrieden mit dem heutigen Experiment. Es war erstaunlich einfach, den Arduino über S4A anzusteuern und das wird sicher nicht das letzte Mal sein, dass wir hiermit experimentieren.

Für mein Olero Projekt brauche ich einen WebServer auf dem ESP8266, der sich selbst ins WLAN einhängt und innerhalb des LAN über eine lokale Domain (mDNS) erreichbar ist.

Sollte doch eigentlich nicht so schwer sein. Es gibt haufenweise Tutorials dazu im Internet. Aber egal welches Tutorial ich befolgte: mein ESP war nie über mDNS erreichbar – immer nur über seine IP.

Nach ewig langem Suchen bin ich dann über eine Diskussion gestolpert, die mir den notwendigen Hinweis gezeigt hat: bei allen Tutorials fehlten zwei mDNS Aufrufe! Kaum habe ich sie hinzugefügt, klappt alles wie am Schnürchen.

// ---------------------------------------------------------
#include <Arduino.h>
#include <ESP8266WiFi.h>
#include <ESP8266mDNS.h>
#include <WiFiClient.h>

#include <ESPAsyncTCP.h>
#include <ESPAsyncWebServer.h>

// WLAN settings it should try to connect to
const char *ssid = "MyNetworkSSID";
const char *password = "myNetworkPassword";

// Hostname for mDNS - note that .local will be added automatically
const char *hostname = "myeps";

// web server port - 80 is http
const int port = 80;

// Create a async http server
AsyncWebServer server(port);

// ---------------------------------------------------------
// Arduino setup function
// ---------------------------------------------------------
void setup(void) {
  // connect to existing WLAN
  WiFi.mode(WIFI_STA);
  WiFi.begin(ssid, password);

  // wait for connection to be stablished - note: you should do some error handling here
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
  }

  // start HTTP server - note: might need some other setup beforehand
  server.begin();

  // setup mDNS - note: you should do error handling here
  MDNS.begin(hostname);

  // IMPORTANT: add http service to MDNS - this step was always missing
  MDNS.addService("http", "tcp", 80);
}

// ---------------------------------------------------------
// Arduino main loop function
// ---------------------------------------------------------
void loop(void)
{
  // IMPORTANT: this step was always missing, too
  MDNS.update();
}

// end-of-file
// ---------------------------------------------------------

Und damit ist der ESP unter folgenden URLs zu finden:

Windows 10: http://myesp.local
Android: http://myesp.

Auf den Android Trick bin ich zufällig gestoßen. Einfach statt „.local“ nur den Punkt „.“ an die mDNS Domain anhängen und dann wird der ESP gefunden.

Der gesamte Source Code für einen ESP8266 Web Server ist auf Github unter https://github.com/emavok/esp8266-webserver zu finden.

van Meel

Willkommen!

Neueste Beiträge

Kategorien

Archive

MonthJänner 2021

Arduino mit Scratch programmieren

ESP8266 WebServer mit mDNS