Archiv der Kategorie: Programmiersprache

WeMos D1 R32 ESP32

Der WeMos D1 R32 ESP32 ist ein Arduino Board nachbau und besitzt kompatible Anschlüsse zum Arduino Uno.
Die IOs  arbeitet jedoch nur mit 3V anstatt mit den gewohnten 5V, was zu Inkompatibilitäten zu manchen Erweiterungsplatinen (Shields) führen kann. Der Preis liegt bei AliExpress unter 5 Euro.

Das schöne an diesem Board ist der ESP32 Prozessor, wecher über WLan und Bluetooth und noch über ein paar weitere Features verfügt.

In diesem Beitrag wird nur die Inbetriebnahme des Boards behandelt, andere Aspekte wie Funktionsumfang des ESP32 usw. können den ensprechenden Artikeln entnommen werden.

Ansichten

Überblick

Name WeMos D1 R32
ESP32
Anzahl/CPU
1/ESP 32
Takt (MHz)240
Kerne2
Digital IOs / Pins36/28
Analog inputs18
PWM16
SPI4
Flash Speicher
SRam (KB)520
EEPROM (KB)4 KB
WiFi802,11 b/g/N
Bluetooth
VerschlüsselungWEB / WPA2 / TKIP /AES
Bluetooth4.1
UART3
I2C2
Ethernet-
Video-
Sound-
USB1 Micro
Betriebsspannung [V]3,3
Eingangsspannung3,3 - 9
Strom (mA) / Standby (mA)
Größe l x b x h68,6 x 53,3
Gewicht [g]< 25

Pins

Wire: SCL  22 / SDA 21

A0 = 2

A1 = 4

A2 = —

A3 = —

A4 = —

A5 =–

Programmierung

Arduino Programmierumgebung

Wenn der ESP 32 vorher noch nicht benutzt wurde muss die Arduino Gui noch angepasst werden. Infos auch auf GITHUB.

Im Datei Menü den Punkt Einstellungen wählen.

Arduino Gui Menü

Jason Datei eintragen:
https://dl.espressif.com/dl/package_esp32_index.json

Jason eintragen

Danach über den Boardmanager den ESP32 installieren. Menü Tools -> Board: *** -> Boards Manger …

Boardmanager auswählen

ESP 32 in der Suchleiste eingeben und mit Enter bestätigen. Im bestem Fall erscheint nur ein Eintrag, diesen installieren.

ESP32 Auswählen und installieren

Noch das richtige Board auswählen. (Andere Boards funktionieren sicher auch)

Testprogramm

Als Testprogramm habe ich das WiFiClient Beispielprogramm genommen und etwas angepasst. Bitte die WLAN Daten entsprechend anpassen.

Nicht schön aber so sieht es bei mir aus:

Für das Programm braucht ihr eine Gegenstelle. Hierfür könnt ihr das kleine Java Tool nehmen, dass ich bereits in anderen Projekten verwendet habe. Beim Starten den port 88 angeben und/oder im Programm ändern.

Quellen

https://www.wemos.cc/
https://github.com/SmartArduino/SZDOITWiKi/wiki/ESP8266—ESPduino-32
https://github.com/espressif/arduino-esp32/blob/master/docs/arduino-ide/windows.md

Arduino PS2 Controller Platine Grundlagen

Verkaufsname: 2018 Arduino Shield Expansion Board 6-12V with 4 Channels Motors Servos Ports PS2 Joystick Remote Control 

Ich habe die Erweiterungsplatine im Set inclusive PS2 Controller/Empfangsmodul, Arduino Uno und USB Kabel, beim schnellen Ali für unter 26€ gekauft.

!!!Vorab um ein paar Fehler zu vermeiden, ist es sinnvoll eine externe Spannungsquelle an den Arduino anzuschliessen, der Strom über den USB Port reicht leider nicht aus!!!

Aktuelle Status ist noch Draft, bitte meckern 😉

Überblick

Die Platine (hier in Version 2.1) ist beeindruckend vielfältig. Die wichtigsten Daten hier im Überblick:

  • Playstation 2 Anschluss für einen Controller-Empfänger.
  • 4 Motor Anschlüsse mit Motorbrücke
  • 6 Servoanschlüsse – 2 „Normale“ + 4 Über den PWM Chip
  • I2C Anschluss nach aussen geführt
  • Anschluss für einen HC-SR04 oder kompatiblen Sonarsensor
  • Anschluss für ein HC-06 kompatibles Bluetooth modul
  • Stromanschluss 6-9V
  • Stromanschluss Klemmen für +5V???
  • JMP Jumper zum deaktivieren on Board Spannung
  • JP1 Zur deaktiveren der 5V Spannung???

Ansichten

Beschaltung

Beschriftete Frontansicht

Einsatz

  • Als Morotplatine mit zuätzlichen Erweiterungen
  • Zur Steuerung von Robotern
  • Fernsteuerung diverser Fahrzeuge

Programmierung

Die Einbindung von Bibliotheken im Generellen ist unter folgenden Link beschrieben, hier werde ich nicht mehr näher darauf eingehen.
http://fambach.net/arduino-ide#Bibliotheken

Motorsteuerung

Die Motorbrücke wird über den I2C Bus angesteuert und ist mit der Adafruit Motor V2 Bibliothek kompatibel. Die Adresse ist 0x60.

Diese ist über den folgenden Link erhältlich:

https://github.com/adafruit/Adafruit_Motor_Shield_V2_Library

Deren Verwendung habe ich schon einmal im Artikel zur Motor Platine V2 beschrieben :

Das Programm des Artikels habe ich einfach mal auf den UNO dieses Projektes gespielt und siehe da die Motoren drehen.

Servos

Es gibt 2 direkt mit dem Arduino verbundene Servos und 4 die über die Motorbrücke über den I2C Bus verbunden sind.

2 Direkt ansteuerbare Servos

Pinbelegung

Servo Arduino Pin
15
26

Testprogramm

Die Anschlüsse befinden sich direkt neben dem Stromanschluss. Der Masse Pol des Servos begfindet sich an der Platinenkante. Die beiden Servos hängen an den Ardunio Pins 5 und 6. Sie sind über die, in der Arduino-Bibliothek integrierte Servosteuerung, regelbar. Hier ein Beispiel:

P.S. Sollte die Servos unfug machen, mal eine extene Spannungsquelle anschliessen die USB Spannung reicht für dieses Board nicht aus.

4 über PWM ansteuerbare Servos

Für die Servos gibt es ebenfalls von Adafruit eine Servo-Treiber Bibliothek:

https://github.com/adafruit/Adafruit-PWM-Servo-Driver-Library

Testprogramm

Eingebunden werden kann die Bibliothek sowohl über das GitHub Zip als auch über den Labrary Manager.

Pinbelegung

Servo Nummer Servo PWM Pins
(Nicht Arduino Pins)
10
21
314
415

Das folgende Programm lassen sich alle Servos drehen.

Ich habe noch eine zweite Version bei der die Position des Servos in Grad angegeben werden kann:

Die Adafruit Servo PWM Biliothek ist auch in der Adafruit Motor Bibliothek eingebunden, somit können die Servos auch über diese angesteuert werden. Dies ist im Beispiel des Herstellers der Fall.

PS2 Schnittstelle

Für die PS2 Schnittstelle gibt es eine Bibliothek die sich PS2X nennt und auf Github verfügbar ist hier der Link:

https://github.com/madsci1016/Arduino-PS2X/zipball/5d2be701af64d826d268301d83119a6d2ad04f15

Pinbelegung

Die Pinbelgung für den Controller ist wie folg zu definieren:

PinBeschreibung
12DAT
11CMD
10SEL
13CLK

Testprogramm

Als Testprogramm habe ich das Beispiel aus der Bibliothek verwendet und nur die Pins angepasst:

SR04

Pinbelegung

PinFunktion
7 Echo
8Trigger

Testprogramm

Den HC-SR04 habe ich schon einmal in folgenden Artikel getestet. Das Programm aus dem Artikel habe ich bezüglich der Pinbelegung angepasst und erfolgreich getestet.

http://fambach.net/ardunino-mit-dht10

I2C

Der I2C Bus ist auf der Oberseite der Platine gut beschriftet. Ich war mir unsicher welchen Mehrwehrt ich hier erzeugen könnte. Somit habe ich nur getestet ob die herausgeführte Schnittestelle auch funktioniert. Zum Test habe ich ein HMC5883L am I2C Bus angeschlossen, um einen Verbraucher zu haben.
Zum testen benutzte ich denn einen I2C Scanner den ich im Internet mal gefunden und etwas angepasst habe.

Und siehe da es funktioniert … nicht wirklich überraschend.

HC-06 Bluetooth

Ich habe aktuell weder eine HC-06 kompatibles Board zur Hand noch einen Anwendungszweck hierfür also lasse ich diesen Test mal aus. Schickt mir ein HC kompatibles Modul und ich teste es 😉

Fazit

Ich finde dies Platine toll, sie bietet fast alles um einen kleinen Roboter aufzubauen. Der hohe Stromverbrauch ist sicherlich ein Nachteil, jedoch kommt der nicht zuletzt auch von PS2 Empfänger.

Ich habe mir das Board im set gekauft weil ich eine Fernsteuerung brauchte. Zudem bietet es noch Anschlussmöglichkeiten für 4 Motoren, 6 Servos, einen Entfernungssenors, 1 Bluetooth Modul und diverser I2C Geräte. Mehr kann man für den Paketpreis von unte 25 € nicht erwarten. Wer nur die Platine braucht, kann sie für rund 16€ erwerben.

Probleme

Nichts geht, die Servos Ruckeln, alles ferhält sich doof …

Wenn nichts so richtig Funktioniert kann es an den folgenden Punkten liegen:

  • Die Spannung ist zu gering – Externe Spannungsquelle anschliessen
  • Falsche Version des Boards – Die getestete ist V2.1
  • Anderer Servo Hersteller – Ich verwende Billigware aus Fernost 95G, andere Servos brauchen evtl. andere Frequenzen.

Servo 3-6 gehen nicht

  • Achtung Servos können nicht mit der Standard Arduino Servo implementierung angesprochen werden, bitte die entsprechende Adafruit Bibliothek verwenden (Sieht Beispiel).
  • Anderer Servo Hersteller – Ich verwende Billigware aus Fernost 95G, andere Servos brauchen evtl. andere Frequenzen.

Projekte

Natürlich will ich die hier erworbenen Kenntnisse in einen kleinen Projekt anwenden. Sehr wahrscheinlich kommt ein Ferngesteuertes Auto dabei heraus.

Der Link zum Projekt kommt noch nach Fertigstellung.

Quellen

https://www.google.com/search?q=servo+daten+sc90&oq=servo+daten+sc90&aqs=chrome..69i57.3435j0j7&sourceid=chrome&ie=UTF-8

http://www.7gp.cn/archives/195  (Hersteller Link)
http://www.7gp.cn/archives/409  (Hersteller Link) 
http://www.7gp.cn/archives/475  (Hersteller Link) 

https://github.com/madsci1016/Arduino-PS2X/zipball/5d2be701af64d826d268301d83119a6d2ad04f15

Menü Klassen für LCD Displays

Da ein Menü auf dem Display zu erstellen eine immer wiederkehrende Aufgabe ist, habe ich einige der Funktionalitäten in Klassen gepackt.

Komponenten

Hardware

Software

  • Arduino IDE
  • LiquidChristal Lib (Kann über den Bibliotheksmanager installiert werden, siehe auch hier )
  • Meine Menu Lib (siehe unten)

Ziele

  1. Schritt einfache Header mit Klassen, die in einem Hauptrogramm verwendet werden können (erledigt).
  2. Schritt Verpacken der Klassen  als Arduino Lib welche in die Gui Importiert werden kann. (erledigt)
  3. Weitere Menüpunkt Varianten erstellen. (Kommt vielleicht noch)

Installation

Download

Die Lib kann bei GitHub runter geladen  werden (Hier der Link).

Hier könnt ihr sie direkt als Zip-Datei herunterladen.

Arduino IDE

Das Zip könnt ihr in der Aruino GUI installieren, siehe auch hier.

Testprogramm

Bei der Lib ist ein Testprogramm dabei, welches ihr über die Examples auswählen könnt.

LCD Menu Lib -> LCDSchieldTest

Hier seht ihr wie es geht.

Das Programm kompilieren und auf den Arduino spielen.

Wenn ihr ein andere Board verwendet bzw. nicht die LCD Keypad Platine, müsst ihr die Einstellungen für die Knöpfe und das LCD Display entsprechend euere Konfiguration anpassen.

Erklärung

Das Menü wird in der Funktion buildMenu() aufgebaut. Hier wird ein Haupmenüknoten erstellt, an den dann der Rest angehängt wird.

Folgende Knoten stehen aktuell zur Verfügung:

ItemMenu – Menü  -> Kann alle anderen Menüpunkte als Kind bekommen. Kann auch als Untermenüpunkt verwendet werden.

ItemBool – Schalter -> Dieser Menüpunkt kann ein und ausgeschaltet werden.

ItemInt – Ganzzahlenwert -> Hier können integer Werte erhöht oder vermindert werden. Min und Max geben die Schranken an.

Die Callbacks werden im Beispiel nicht benutz, diese könne dazu verwendet werden eine Funktion in eurem Programm aufzurufen wenn sich der Wert eines Menüpunktes ändert.

Navigation im Menü

Oben steht am Anfang das Hauptmenü.

Unten steht der 1. Menüpunkt. Mit den rechts/links Tasten könn ihr den ensprechenden Menüpunkt auswählen. Mit runter springt ihr in den Menüpunkt, mit hoch springt ihr wieder raus.

Die Menüs können beliebig verschachtelt werde, wie ihr an Submenue 1 und 2 seht.

Ausblick

Für mich reicht die Bibliothek erst mal, ich habe aber noch ein Paar Ideen vielleich werde ich die bei Gelegenheit nochmal umsetzen:

  • Gleitkomma Menüeintrag
  • Balken  Menüeintrag, für kleine Intwerte wird ein Balken angezeigt der die Einstellung symbolisiert.
  • Auswahlliste Menüpunkt (.. Wähle A, B oder C …)
  • zusätzlichen Beispiel für Callbacks

Probleme

Aktuell klappt das entprellen der Tasten im Beispiel nur bedingt. Den Fehler muss ich noch finden und beheben.

Quellen

Arduino LCD Keypad Shield

 

Den ESP8266 schlafen legen

Sensorknoten sollen möglichst lange und unabhängig arbeiten können. Dennoch benötigen sie Strom, um mit der vorhandenen Energie möglichst effizient umgehen zu können, hat der ESP8266 und andere Controller die Möglichkeit in den Tiefschlaf zu gehen. Das schöne ist er kann sich nach fast beliebiger Zeit selbst wieder aufwecken. Ein Nachteil beim ESP8266 ist das er maximal 71 Minuten schlafen kann.

In diesem Beitrag wird gezeigt wie der ESP einschafen kann und auch wieder aufwacht.

Bauteile

1x ESP8266 Node Lua V2
1x Pinheaderkabel (Buchse : Buchse)

Schaltungsaufbau

(Von Quelle geklaut)nodemcu-deep-sleep.png

Der Reset wird hierbei mit dem GPIO 16 (Pin D0) verbunden.

So sieht es bei mir in der Realität aus

Testprogramm

 


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

  // Wait for serial to initialize.
  while(!Serial) { }
  
  Serial.println("I'm awake.");

  Serial.println("Schlafe 20 Sekunden ");
  ESP.deepSleep(20e6); // 20e6 = 20 microseconds

}

void loop() {
  // nichts zu tun

}

Der ganze Spuk passiert durch eine Zeile Code (hier rot makiert).

… und das kommt bei mir auf der Konsole an:

Man kann gut am Textschrummel erkennen, dass der ESP alle 20 Sekunden neu startet.

Weiterführende Projekte

Quellen

https://www.losant.com/blog/making-the-esp8266-low-powered-with-deep-sleep

MQTT Protokoll + Versuchsaufbau

Ich bin im Netz auf den Begriff MQTT gestossen und fand den Ansatz dahinter richtig gut. Deshalb habe ich mir mal einen kleinen Versuchsaufbau gegönnt, den ich im folgenden beschieben habe.

Vorab ein paar Details zu MQTT

Infos zu MQTT

Allgemeines

MQTT regelt die Kommunikation zwischen Datenquellen und Datensenken mittels eines Brokers.

Datenquelle

Quellen für Daten können ganz unterschiedliche Geräte sein, eines haben sie jedoch alle gemeinsam, sie können Netzwerkverbindungen aufbauen um Ihre Daten weiter zu geben und sie haben was, was sie mitteilen wollen.

In der IoT können dies Sensor-Knoten sein, welche ihre Daten an einen oder mehrere Empfänger senden wollen.  Die Liste der möglichen Daten ist hierbei nahe unendlich. Beispiele sind Temperaturwerte, Schaltzustände,  Helligkeitswerte usw.

Die Quelle meldet sich an einem (oder mehreren Brokern?) an. Ihre Daten sendet sie so lange bis diese vom Broker quittiert wurden.

Datensenken (Interessenten)

Senken für Daten sind bei MQTT die sog. Interessenten. Diese möchten bestimmte Informationen von Quellen erhalten und diese dann Auswerten (Berechnung) oder einfach nur Präsentieren (Bildschirmanzeige). Beispiele sind Handy Apps, eine Lampe die wissen will wann sie eingeschaltet wird usw.

Broker

Der Broker dient als Bindeglied zwischen den Quellen und den Senken. Er hat die Aufgabe, Daten von Quellen zu sammeln und diese an die Interessenten weiter zu reichen.  Eine Auswertung/ Aufbereitung der Daten ist ihm nicht gestattet, jedoch darf er die Daten zwischenspeichern, um zum Beispiel neuen Interessenten mit dem zuletzt empfangenen oder auch mit historischen Werten zu versorgen.

Die Idee hinter dem Protokoll ist, dass Leistungsschwache Sensorknoten nur eine Verbindung mit einem Broker (Empfänger Server) aufbauen und nur an diesen senden sie ihre Daten. Der leistungstärkere Broker verteilt die Informationen dann an die Interessenten.

Ein kleines Projekt

Ich habe ein kleines Projekt aufgesetzt, mit einem Sensorknoten als Quelle, einem Broker auf einem Raspberry Pi und meinem Handy als Senke.

Quelle

  • Board Node MCU ESP8266
  • Temperatursensor DHT11
  • Bibliothek pubsubclient

Der genaue Aufbau ist in einem anderen Beitrag bereits beschrieben, weshalb ich mich hier nur auf die MQTT basierten Fakten stürze.

http://fambach.net/dht10-mit-esp8266/

Die Bibliothek installieren:

Hier ist der nach MQTT angepasste Quellcode:

ESP8266TempSensorMQTT

Bitte die Netzwerkdaten und die Brokerdaten an eure Topologie anpassen. Achtung der DHT Sensor benötigt auch eine Bibliothek wie im gelinkten Beitrag beschrieben.

Broker

Raspberry nach belieben aufsetzten oder so wie hier:

http://fambach.net/raspberry-pi-zero-w-headless-installation/

Auf dem Pi dann die Mosquitto software installieren.

Software Download

Link: http://mosquitto.org/download

Die letzte Version holen, der Link kann von der obigen Seite kopiert werden. Die aktuelle Version kann mit wget direkt auf den PI geholt werden:

sudo wget <direkter link zum paket>

in meinem Fall war das

sudo wget http://mosquitto.org/files/source/mosquitto-1.5.tar.gz

Installation

Benötigte libs installieren mit

sudo apt-get install libwrap0-dev libcurl4-openssl-dev libmysqlclient-dev libssl-dev apt-get install uuid-dev 

Paket auspacken:

tar zxf ./mosquitto-1.5.tar.gz

In den ausgepackten Ordner springen und mosquitto …

cd mosquitto-1.5/

… bauen und Installieren …

make
sudo make install
sudo ldconfig

… noch starten

Den ESP8266 starten und die erste Verbindung sollte klappen:

Senke

Ich verwende mein Handy als Senke und einen MQTT Empfänger APP. Ich habe ein paar probiert, bin dann aber erstmal mal bei „IoT MQTT Panel“ hängen geblieben, weil sie auf Anhieb funtkionierte und auch Platzhalter unterstüzt.

Hier der Link

Folgende Einstellungen habe ich vorgenommen, ihr müsst diese natürlich an eure Applikation und Netzwerktopoligie anpassen.

Erstmal eine neue Verbindung erstellen mit den Verbindungsdaten des Mosquitto Servers.

Die Neue Verbindung öffnen

Fazit

Solch ein MQTT Projekt ist in wenigen Stunden aufgebaut und macht Spaß. Dabei hat es noch großes Potential, denn man kann leicht mehrere Knoten mit einem standard Server verbinden und sich die Daten z.B. auf dem Handy anzeigen lassen.

Quellen

https://de.wikipedia.org/wiki/MQTT

Java Client Phao

MQTT Git-hub Community Wiki
https://github.com/mqtt/mqtt.github.io/wiki

Github Seite mit MQTT libs
https://github.com/mqtt/mqtt.github.io/wiki/libraries

Lib für ESP8266 und Andere
https://github.com/knolleary/pubsubclient

Mosquitto Broker Konfigurationhilfe

Quick Guide to The Mosquitto.conf File With Examples

MQTT best practice

MQTT Essentials Part 5: MQTT Topics & Best Practices

 

ESP32 Arduino Gui einrichten mit Git

Wie immer gibt es im Netz zahlreiche Informationen, wie die Arduino Gui zu konfigurieren ist. Deshalb fasse ich mich an dieser Stelle sehr kurz, für detailiertere Informationen sei auf die unten verlinkten Quellen verwiesen.

Repository Clonen

Es gibt ein Git Paket zur Einrichtung der GUI für den ESP 32. (Link zu GIT GUI)

Git Gui starten und „Clone Existing Repositiory“ wählen.

Die Quelle für die ESP 32 Sources ist:

https://github.com/Heltec-Aaron-Lee/WiFi_Kit_series.git

dort gibt es auch zusätzliche Infos.

Das Ziel ist das Arduino Projektverzeichnis, in meinem Fall unter MyDocuments/Arduino.

Mit Bestätigung der Eingabe über den Clone Button, erscheint das folgende Bild und alle Dateien werden aus Git extrahiert.

Danach muss man im Verzeichnis ..\Arduino\hardware\heltec\esp32\tools noch das Programm get.exe ausführen und in der Console mit Enter starten.

Erfolgsbestätigung

Arduino Gui neu starten,  tauchen die ESP 32 Einträge in der Board-Liste auf war die Installation erstmal erfolgreich.

Ob auch alles wirklich funktioniert kann mit einen der Beispielprogramme verifiziert werden. Einfach auswählen, übersetzen und auf den ESP 32 übertragen. (Vorher das richtige Board auswählen)

Probleme

Arduino Gui – falsches Installationsverzeichnis gewählt

Ich hatte das falsche Verzeichnis für meine Arduino Gui angegeben .

Zur Lösung des Problems kann der komplette esp32 Ordner in das richtige Verzeichnis unter hardware kopieren werden.

Keine Beispielprogramme für den ESP32 ?!

Zuerst muss das ESP32 Board ausgewählt werden, dann sind auch die entsprechenden Beispielprogramme vorhanden.

Projekte

ESP32 WiFi Lora 433

Quellen

https://github.com/espressif/arduino-esp32/blob/master/docs/arduino-ide/windows.md

https://github.com/Heltec-Aaron-Lee/WiFi_Kit_series#instructions

Arduino Uno + WiFi

Hier geht es um einen Chinaimport und nicht um den offiziellen Uno WiFi. Die Platine hat einen vollständigen Ardunio Uno mit Atmega Prozessor und einen ESP8266 Chip on board. Über Dipschalter, kann jeweils der Uno mit dem USB, der ESP mit dem USB oder der ESP mit dem UNO verbunden werden.

Für den Betrieb kann eine externe Wlan-Antenne angeschlossen werden. Es sind zusätzlich ESP-Pins herausgeführt, die Beschaltung steht auf der Rückseite.

Daten

Name Uno + Wifi
Anzahl/CPU
2 / ATmega328P + ESP 8266
Takt (MHz)16 / 80
Kerne1
Digital IOs / Pins14 / 4
Analog inputs6 / ?
PWM6 / ?
SPI1
Flash Speicher 32 KB / 8 MB
SRam (KB)2 / 128
EEPROM (KB)1 / -
WiFi- /2,4 GHz 802.11 b/g/n
Verschlüsselung- / WEB / WPA2 / TKIP /AES
Bluetooth-
UART1 / 1
I2C1 / 1
Ethernet- / -
Video-
Sound-
USB1 Micro
Betriebsspannung [V]5
Eingangsspannung7 - 12
Strom (mA) / Standby (mA)< 500
Größe l x b x h68,6 x 53,3
Gewicht [g]>25

Ansichten

Frontansicht mit den Verbindern für Erweiterungsplatinen, dem Stromanschluss, USB-Anschluss und einem  Resettaster. Zusätzlich zu den normalen Achlüssen befindet sich noch weitere für den ESP8266,  ein Antennenanschluss und ein Dip-Schalter zur Einstellung der seriellen Schnittstelle an Bord.

Hier ein paar technische Daten und die Pinbelegung der nach aussen geführten ESP Pins.

 

Jumper Einstellungen

DIP

Programmierumgebung

UNO

Dipschalter 3,4 auf ON Rest auf OFF

ESP8266

Dipschalter 5,6,7 auf ON Rest auf OFF. Sollte das programmieren nicht beginne ist ein Reset  des Boards nötig. Das spielen mit der Reset Methode im Menü brachte hier leider keine Besserung.

Test Programme

ESP8266 Durchreiche

Das folgende Programm reicht alles was auf dem seriellen Port eingeht an den verbundenen Server weiter und alles was über das  Netz rein kommt wieder auf den seriellen Port. Das Listing ist etwas lang weil ich die Netzwerkkommunikation aus einem anderen Projekt übernommen habe, deshalb hier nur die gelinkte Datei.

UARTEcho.ino

Alles Wichtige passiert in der loop Funktion. Die Daten für den Accesspoint und den Server müssen entsprechend angepasst werden.

Nachträglich habe ich auch Code von Arduino in den Beispielen der GUI gefunden. Die Datei heisst Wifi2Serial.ino.

Uno Echo

Das Testprogramm des Uno’s ist gleichfalls trivial. Es schreibt alles was er über den seriellen Port empfängt wieder auf diesen zurück.

String buf = "";

void setup(){
  Serial.begin(9600);
  while(!Serial){ delay(1);}
  buf.reserve(200);
  Serial.println("UNO started");
}

int ib = 0;
void loop(){
  while (Serial.available()){
    delay(4); // allow buffer to fill
    ib = Serial.read();
    buf += ((char)ib);

    if(((char)ib)== '\n' || buf.length()== 200){
        Serial.print("Echo: ");
        Serial.print(buf);
        buf = "";
    }
  }
}

SerialEcho.ino

Testen

Zum testen kann mein Socket-Tool verwendet werden.

Java Socket Konsolen Server

Dipschalter1,2 auf ON, der Rest auf OFF.

Die Socket Console starten.

Im Feld neben den „send“ Knopf kann ein Text eingegeben werden. Mit Betätigung des „send“ Knopfes, wird der Text an den Client geschickt. Wenn alles geklappt hat, kommt der Text mit einem „Echo: “ davor zurück.

Durch die Testausgaben des ESP auf den seriellen Port, kommen ein paar mehr Echos zurück als eingegeben wurden. Auch fehlt nach der Serververbindung der „New Line“- Befehl. Weshalb erst der 2. eingegeben Text gut sichtbar ist. Für einen ersten Test des Boards reicht es jedoch aus.

Quellen

https://github.com/jandrassy/UnoWiFiDevEdSerial1#writing-sketches-for-esp8266

https://github.com/esp8266/Arduino/issues/3004

https://community.blynk.cc/t/uno-wifi-r3-atmega328p-esp8266-board-32mb-memory-usb-ttl-ch340g-compatible-for/21564

https://github.com/gmag11/FirmataMaster

https://www.arduino.cc/reference/en/language/functions/communication/serial/

Arduino – HC-SR04 Entfernungsmesser

Ansteuerung des HC-SR04 Ultraschall-Entfernungsmesser mit Hilfe des Arduino UNO.

Grundlagen

Aufbau

Schaltung

(Ich habe nachträglich noch die Pins von 0/1 auf 2/3 geändert weil an 0/1 noch der ISP hängt).

Testprogramm

Hier ein kleines Testprogramm. Es filtert zu kleine und zu große Werte heraus und ermöglicht die Mittelwertbildung über ein definiertes intervall.

// *************************************************
// SR04 Ultrasonic Distance Sensor
// time to distance conversion is
// divide by 2 (both ways to the obstical and back)
// divide by sonic constant 29.1
#define TRIGGER_PIN   3
#define ECHO_PIN      2    
#define SC_MM         5.82
#define SC_CM         58.2

#define MAX_DUR       300 * 58.2 // ~3m in dur 
#define MIN_DUR       2 * 58.2 // ~2cm in dur
#define TO_SMALL      -1
#define TO_BIG        -2
#define INT_TO_SMALL  -3


/** get duration */
long getDur(int interval){
  if(interval < 1) return -3;
  long dur=0;
  
  for(int i = 0; i < interval; i++ ){
    // init sensor
    digitalWrite(TRIGGER_PIN, LOW);
    delayMicroseconds(3);
    noInterrupts();  
  
    // start 10 us pulse
    digitalWrite(TRIGGER_PIN, HIGH); 
    delayMicroseconds(10);
    digitalWrite(TRIGGER_PIN, LOW);
    
    dur += pulseIn(ECHO_PIN, HIGH); // determine the time
    interrupts();
    
  }

  dur /= interval;
  if(dur > MAX_DUR ) { return TO_BIG;}
 // else if (dur < MIN_DUR){ return TO_SMALL;}
  return dur;
}
 
void initDist(){ pinMode(TRIGGER_PIN, OUTPUT); pinMode(ECHO_PIN, INPUT);}

/** get the distance in centi meter*/
double getDistCM(long dur){ return (dur / SC_CM);}

/** get the distance in milli meter*/
long getDistMM(long dur) { return (dur / SC_MM);}
// *************************************************

void setup(){
  Serial.begin(9600); 
  while(!Serial){delay(1);} // wait until the serial is ok (only for Leonardo)
  initDist();
}

void loop (){
  
  Serial.print("Current distance is: "); 
  long dur = getDur(5);
  if(dur > 0) Serial.println(getDistCM(dur));
  else if( dur == TO_BIG) Serial.println("TO FAR");
  else if( dur == TO_SMALL) Serial.println("TO NEAR");
  delay(1000); // wait a second
}

SR04Test.ino

Hier könnte jetzt noch der Median angewendet werden um Ausreisser heraus zu nehmen.

In der Praxis bietet es sich wahrscheinlich an die Millimeter weg zu kürzen und nur den Zentimeterwerte, die wesentlich geringeren Schwankungen unterliegen, zu verwenden.

Output

Quellen

Java – IP Fernbedienung

Zweck des Ganzen ist eine Fernbedienung für meine Roboter.

Da alle Roboter (zumindest die fortschrittlicheren) über eine Netzwerkverbindung verfügen, möchte ich eine kleine App entwickeln, die per Konfiguration Telegramme an einen bestimmten Empfänger versenden kann.

Erster Wurf

Im ersten Schritt soll die Fernbedienung nur aus einem Tastenfeld bestehen. Der Benutzer kann die Anzahl Zeilen und Spalten bestimmen und die Knöpfe einzeln konfigurieren. Dies sollte ausreichen eine einfache Fernsteuerung zu erstellen.

Std. Layout 3 x 3 Felder

Konfigurierte Version des 3×3 Std. Layouts.

 

 

Java Socket Konsolen Server

Die Java Socket Konsole öffnet einen Server auf einem definierten Port. Der Port kann beim Start mit übergeben werden. Wird kein Port angegeben ist der standard Port 2021.  Alles was an diesen Port gesendet wird, erscheint als zeilenbasierte Ausgabe in einem Fenster.

Das Programm ermöglicht genau eine Verbindung.  Über die Textbox am Fuß des Dialogs und den „send“ Knopf kann Text an den verbundenen Client gesendet werden.

Vorausetzung

Java Version >= 7 muss installiert sein
Wurde bis jetzt nur unter Win 10 getestet

Starten

Die Datei kann einfach per Mouse-Doppelkick gestartet werde.

Ein starten über die die Konsole, um den Port mit zu geben, sieht wie folgt aus.

Der Port kann direkt hinter dem Dateinamen angegeben werden.

Ausgabe

Dateien

Jar Archiv

SocketConsole

Sourcen (Eclipse Projekt)

net.fambach.net.socket.console.zip

Probleme

Bei Problemen Mail an mich anfrage(at)fambach.net

Quellen

http://openbook.rheinwerk-verlag.de/javainsel9/javainsel_21_006.htm
https://docs.oracle.com/javase/7/docs/api/java/net/Socket.html
https://docs.oracle.com/javase/tutorial/networking/sockets/index.html
https://javabeginners.de/Netzwerk/Socketverbindung.php