Themabewertung:
  • 0 Bewertung(en) - 0 im Durchschnitt
  • 1
  • 2
  • 3
  • 4
  • 5
NodeMCU - eine leistungsfähige Alternative zum (AVR) Arduino
#1
Hallo zusammen, 

ich möchte Euch hier eine neue Microcontroller-Plattform für Bastelzwecke vorstellen.

Für meine weiteren Projekte (Internetradio, Internetradio-/Bluetooth-/FM-Mischerröhre , VoiP mit alten Wählscheibentelefon,...)  sind die bisher genutzten Arduino-Rechner (Nano, Mega2560) nur eingeschränkt brauchbar. Es existieren zwar Portierungen eines TCP/IP-Stacks für AVR Risc Systeme von Atmel, diese bringen den Controller mit wenig Bauteilen in ein Netzwerk, jedoch auf Kosten einer hohen Prozessorauslastung. Es bleibt für den eigenen Code also wenig Freiraum, an Aufgaben der digitalen Signalverarbeitung ist auf Grund von Ressourcenmangel und mit 16 MHz CPU-Takt sowieso nicht oder nur eingeschränkt zu denken.

Auf der anderen Seite gibt es Bastlerhardware die vor Rechenleistung nur so prahlen kann.
Für die Entwicklung eines DAB oder Webradios habe ich bisher Einplatinenrechner aus der Leistungklasse eines Odroid-System genutzt (4 Kerne, 1.5-1.7 GHz, 2GB RAM, Linux als Betriebssystem). Dies ist für viele Bastelprojekte aber mit Kanonen auf Spatzen geschoßen. Was bisher bei mir in der Hobbywerkstatt gefehlt hat, war ein Zwischending aus Arduino und Odroid, sowohl was die Anschaffungskosten, als auch die bereitgestellte Leistung angeht. Gefunden habe ich dieses Zwischending in der NodeMCU-Plattform. 

"Node" als englische Bezeichnung für Knoten oder Netzknoten und MCU als Abkürzung für Microcontroller Unit zeigt schon die Besonderheit dieses Arduino-ähnlichen Entwicklungssystems. Die Entwicklungsboards der NodeMCU-Klasse haben neben der Standardpheripherie eines jeden Microcontrollers, WLAN und Bluetooth an Bord. Mit den beiden Tensilica-Prozessoren Xtensa LX106 und LX6, stehen 32-Bit Rechenwerke mit 1 oder 2 Kernen und Taktfrequenzen zwischen 80 und 240 MHz zu Preisen eines Arduino(!) zur Verfügung. Programmiert werden die MCUs wie Ihre kleineren 8-Bit-Brüder über eine USB-Schnittstelle direkt aus der Entwicklungsumgebung heraus. Neben der Programmiersprache LUA wird auch C/C++ angeboten. Die C/C++ Programme können dabei auch  in der Arduino IDE erstellt und compilert werden. Sketch-Dateien die für die Arduinosysteme geschrieben werden, können sofort oder mit kleinen Anpassungen  auf NodeMCU-Systemen laufen. Weiterhin werden als Programmiersprachen Phyton und BASIC angeboten, auch ein Echtzeitbetriebssystem mit dem Namen FreeRTOS steht dem Bastler zur Verfügung.


Einen kurzen Vergleich der NodeMCU-Module mit den bekannten Arduinos habe ich nachfolgend einmal angefertigt.

   

Fragen zu den Systemen werde ich versuchen zu beantworten. Ansonsten möchte ich in den nächsten Beiträgen das Einrichten des Entwicklungssystems und ein paar kurze Programmierbeispiele geben. Danach geht es an die Entwicklung eines Internetradiomoduls für die Aufrüstung von Röhrenoldies.

Gruß
Bernhard
Ansprechpartner für Umbau oder Modernisierung von Röhrenradios mittels SDR,DAB+,Internetradio,Firmwareentwicklung. 
Unser Open-Source Softwarebaukasten für Internetradios gibt es auf der Github-Seite! Projekt: BM45/iRadio (Google "github BM45/iRadio")
Zitieren
#2
ich werde deinen Beitrag gerne verfolgen

Gruß
Wilhelm
Niemandes Herr, Niemandes Knecht,
so ist es gut, so ist es recht

von Fallersleben
Zitieren
#3
die Umstellung vom Arduino zum NodeMCU scheint mir einfacher als die vom Arduino zum ATtiny.
Zitieren
#4
Moin Bernhard,

sehr interessant, ich bin schon auf weitere Beiträge dazu gespannt.

Beste Grüße
Peter
Zitieren
#5
Hallo zusammen,

wer sich mit Hochsprachenprogrammierung schon einmal beschäftig hat, kennt sicherlich den Einstieg. Meist besteht dieser aus einem "Hello world!"-Programm. Also ein Programm was den Satz "Hello world" auf den Bildschirm schreibt. Bei Microcontrollern ist das, soweit kein Display angeschlossen ist, ein "Blink"-Programm, also ein Programm was an einem Ausgang des Microcontrollers eine LED blinken lässt. Genauso möchte ich hier in die Programmierung des ESP32-Controllers (eine leistungsfähigere Variante des ESP8266) einsteigen.

Den ESP32 kann man, wie oben in der Tabelle ersichtlich, in mehreren Sprachen programmieren. Darunter in C/C++ mit der bekannten Arduino IDE (Arduino ESP32 core),in Ruby, Basic oder der Interpretersprache LUA und viele weitere. Für den ESP32-Controller gibt es auch mehrere Echtzeitbetriebssysteme, so auch das "Lua RTOS". 

Die Installation von "Lua RTOS" geht sehr schnell und einfach, entweder wird der Microprozessor direkt mit dem Betriebssystem ausgeliefert oder man lädt sich aus dem Internet eine Image-Datei und schreibt diese mit einem Tool des Entwicklungssystems in den Speicher des ESP32.

Die Programmierung unter diesem Betriebssystem gestaltet sich als sehr elegant und könnte für viele Neulinge hier im Forum ein Zugang zur Microcontroller-Technik bieten. Warum? Nun mit der "Whitecat IDE", einem Entwicklungssystem was vollständig im Webbrowser (vorerst nur Chrome) läuft, ist eine grafische Programmierung des Systems möglich. Dabei werden vorgegeben Funktionsbausteine direkt miteinander auf grafischen Weg verknüpft.

Auf der linken Seite der Entwicklungsumgebung sind fertige Funktionsbausteine typisiert,diese können einfach mit der Maus in den rechten Bereich (das ist unser Programm) gezogen und verknüpft werden.

   
   

Wie würde nun unser Blink-Programm in der Whitecat IDE aussehen? So...

   

Hier der Programmablauf in Worten.



Wenn unser Board startet, dann gehe
    in eine Schleife die solange läuft, wie die Bedingung (wahr=wahr) erfüllt ist  // also eine Endlosschleife
        setze den digitalen Ausgang P6 (also GPIO-Pin26) auf einen High-Pegel   // die LED wird angeschaltet
          warte 500 Millisekunden
      setze den digitalen Ausgang P6 (also GPIO-Pin26) auf einen Low-Pegel   // die LED wird ausgeschaltet
        warte 500 Millisekunden

   Schleifenende, gehe nach oben zum Scheifenanfang



Einfach, oder?
Ansprechpartner für Umbau oder Modernisierung von Röhrenradios mittels SDR,DAB+,Internetradio,Firmwareentwicklung. 
Unser Open-Source Softwarebaukasten für Internetradios gibt es auf der Github-Seite! Projekt: BM45/iRadio (Google "github BM45/iRadio")
Zitieren
#6
Also ich bin dabei! Dank bis dato schon für die gute Einführung!

Besten Dank und lieben Gruß
Zitieren
#7
ich bin überrascht die Anweisungen für den TEA5767-Baustein entdeckt zu haben.
Zitieren
#8
(13.06.2017, 15:22)saarfranzose schrieb: ich bin überrascht die Anweisungen für den TEA5767-Baustein entdeckt zu haben.

Nicht nur die Ansteuerung per I²C steckt dort im Lua-Script. So wie ich es schnell überfolgen habe hängt das Lua-Script den Radiobaustein in Netz, dieser kann dann per Webbrowser bedient werden.

Unser Beispiel oben sieht direkt in LUA geschrieben dann so aus:

   
Ansprechpartner für Umbau oder Modernisierung von Röhrenradios mittels SDR,DAB+,Internetradio,Firmwareentwicklung. 
Unser Open-Source Softwarebaukasten für Internetradios gibt es auf der Github-Seite! Projekt: BM45/iRadio (Google "github BM45/iRadio")
Zitieren
#9
Hallo Bernhard,
ich glaube, da wird einiges Interesse im Forum bestehen.

Da aber viele mit Microelektronik noch wenig Befassung hatten, könnte Dein
Projekt der Einstieg sein.

Dafür wäre notwendig, daß sich die Interessierten mit der WhiteCat IDE befassen und mit ihr
üben können.

Daher bitte ich Dich, nochmal einen kurzen Umweg zu machen und für uns "Dummies"
Schritt für Schritt die Beschaffung und die Installation der WhiteCat IDE zu beschreiben.
Wenn die dann der Lernwillige zur Verfügung hat, wird sich der Lernerfolg schnell einstellen
und man kann Deinen Projektschritten besser folgen.

Danke im Voraus.

Gruß
Wilhelm
Niemandes Herr, Niemandes Knecht,
so ist es gut, so ist es recht

von Fallersleben
Zitieren
#10
(14.06.2017, 10:28)Wilhelm schrieb: Daher bitte ich Dich, nochmal einen kurzen Umweg zu machen und für uns "Dummies"
Schritt für Schritt die Beschaffung und die Installation der WhiteCat IDE zu beschreiben.

Hallo Wilhelm, 

der einfachste Weg ist mit einem Chrome-Browser die Seite https://ide.whitecatboard.org/ aufzurufen. Dort sich mit einem Google-Konto anmelden (oder ersteinmal ein kostenloses Google-Konto erstellen) und danach läuft die Entwicklungsumgebung direkt im Browser und kann getestet werden.

Für die Programmierung eines LuaRTOS-Controllers:
Zusätzlich muß noch der Whitecat-create-agent (https://github.com/whitecatboard/whitecat-create-agent) installiert werden, das ist das Bindeglied zwischen Browser und Controllerboard. Die fertiggebaute Windowsversion findet man in "whitecat-create-agent/installer/windows/" des Github-Verzeichnisses oder man folgt dieser Anleitung: https://whitecatboard.org/git/wiki/white...ws-install

Danach einen ESP32-Controller mit installierem LuaRTOS anschließen und das Programm kann in den Prozessor geladen werden.
Ansprechpartner für Umbau oder Modernisierung von Röhrenradios mittels SDR,DAB+,Internetradio,Firmwareentwicklung. 
Unser Open-Source Softwarebaukasten für Internetradios gibt es auf der Github-Seite! Projekt: BM45/iRadio (Google "github BM45/iRadio")
Zitieren
#11
Das ganze hört sich sehr interessant an! Ich habe momentan nämlich auch ein Projekt, für das mein PIC18F.... möglicherweise bald zu klein wird.
Grüße
Christoph
Zitieren
#12
vielen Dank Bernhard, das verkürzt uns "Dummies" die Eimstiegszeit

Gruß
Wilhelm
Niemandes Herr, Niemandes Knecht,
so ist es gut, so ist es recht

von Fallersleben
Zitieren
#13
Nachdem ich oben bereits die Entwicklungsumgebung für die Sprache Lua und die grafische Programmierung eines ESP32 unter LuaRTOS gezeigt habe, möchte ich jetzt noch die Installation des beliebten C/C++-Sprachenpaketes unter der Arduino IDE für den ESP8266-Microcontroller zeigen.

1. Im ersten Schritt lädt man ganz normal die Arduio IDE von der Seite https://www.arduino.cc/en/main/software runter und installiert diese auf dem Computer.

2. Nach dem Start der Arduino IDE, wählt man den Menüpunkt <Datei>,<Voreinstellungen> aus.  Danach öffnet sich folgendes Fenster:

   

In das Eingabefeld "Zusätzliche Boardverwalter-URLs" gibt man folgenden Link ein:
http://arduino.esp8266.com/stable/packag...index.json

Nachdem man die Voreinstellungen mit OK wieder verlassen hat, könnt Ihr im Menü <Werkzeuge> den Menüpunkt <Board......> und danach <Boardverwaltung> auswählen.

   

In das Suchfeld gibt man für das ESP8266-Microcontrollersystem den Begriff "ESP8266" ein.
 
   

Danach wählt man die oben gezeigte Boardverwaltung aus und klickt auf  "Installieren"

   

Nach einem Neustart der Arduino IDE kann diese jetzt auch die ESP8266-Systeme programmieren. Wollen wir unser Blink-Programm von oben in die Sprache C umsetzen gehen wir wie folgt vor.

Zunächst schließt man sein ESP8266-Board (hier ja ein NodeMCU) per USB an den Entwicklungsrechner an.
Unter Windows und Linuxsystemen wird dieser NodeMCU als serielle COM-Schnittstelle (in meinem Fall "COM4") erkannt.


Um Programme zu entwickeln und auf den Microcontroller laden zu können, sind jetzt noch ein paar Einstellungen nötig.

Zunächst geht man unter dem Menüpunkt <Werkzeuge> auf <Port>. In meinem Fall ist der Microcontroller ja COM 4.

   

Anschließend wählt man das genaue Entwicklungsboard, in meinem Fall ein NanoMCU 1.0 aus.
   

Weiterhin sind Einstellungen zur Taktfrequenz, auf dem Entwicklungsboard installierten Flashspeicher, die Geschwindigkeit der Datenverbindung zum Flashen in den Controller usw. möglich. Ich belasse alles bei den Default-Werten.

   

Code:
#define LED D0 // LED ist an Pin D0 angeschlossen

void setup() {
pinMode(LED, OUTPUT); // Pin DO als Ausgang schalten
}

void loop() {
digitalWrite(LED, LOW); // LED aus
delay(500);             // warte 500ms
digitalWrite(LED, HIGH); //LED an
delay(500);             // warte 500ms
}


Jetzt endlich kann man das oben gezeigte Blinkprogramm in der Programmiersprache C in den Editor eintippen. Ist der Programmsyntax fehlerfrei, kann man den Compiler mit Klick auf das Pfeilsymbol starten, anschließend wird das Programm direkt auf das Entwicklungsboard geflashed und gestartet. Und wie sieht das Ergebnis aus?





Die Einbindung eines ESP32-Systems in die Arduino IDE ist etwas umfangreicher, man findet den Weg hier beschrieben:
https://github.com/espressif/arduino-esp32
und für Windows: https://github.com/espressif/arduino-esp...windows.md

Das war doch alles gar nicht so schwer!

Viele Bastlergrüße
Bernhard.
Ansprechpartner für Umbau oder Modernisierung von Röhrenradios mittels SDR,DAB+,Internetradio,Firmwareentwicklung. 
Unser Open-Source Softwarebaukasten für Internetradios gibt es auf der Github-Seite! Projekt: BM45/iRadio (Google "github BM45/iRadio")
Zitieren
#14
Hallo zusammen,

nach dem Blink-Programm kommen wir jetzt zu der Sache, für die der ESP8266 und der ESP32 besonders geeignet ist - WLAN!

Nachfolgender Code bringt den Controller in ein WLAN hinein, dort stellt er einen Webserver (ein bisschen kleiner als der Webserver fürs Radio-Bastler-Forum) bereit. Über die Webseiten des Webservers kann man zwei Ausgänge des Controllers
umschalten. Meine Zugangsdaten habe ich natürlich "zensiert"


Code:
#include <ESP8266WiFi.h>
#include <ESP8266WebServer.h>
#include <ESP8266mDNS.h>

// LAN Verbindungsdaten
const char* ssid = "xxxxx";
const char* password = "xxxxx";

// Hostname
const char* host = "webcontrol";

// GPIO pins:
const int output1 = D0; //D0
const int output2 = D1; //D1

boolean output1_state = false;
boolean output2_state = false;

// Webserver lauscht an Port 80:
ESP8266WebServer server(80);

String getContent()
{
 // Jetzt die Webseite zusammenbasteln
 String content = "<html><head><title>ESP8266 Webserver</title></head><body>";
 content += "<center><FONT SIZE=\"14\">ESP8266 - Webserver zum Schalten von GPIOs<br /><br />";

 if (output1_state)
 {
   content += "Ausgang1: <a href=\"output1\"><button>AN</button></a><br />";
 }
 else
 {
   content += "Ausgang1: <a href=\"output1\"><button>AUS</button></a><br />";
 }

 if (output2_state)
 {
   content += "Ausgang2: <a href=\"output2\"><button>AN</button></a><br />";
 }
 else
 {
   content += "Ausgang2: <a href=\"output2\"><button>AUS</button></a><br />";
 }

 content += "</FONT></center></body></html>";

 return content;
}

void setup()
{
 // Boardpins GPIO 0 and GPIO 2 als Ausgang:
 pinMode(output1, OUTPUT);
 pinMode(output2, OUTPUT);

 // Alle Ausgänge LOW
 digitalWrite(output1, LOW);
 digitalWrite(output2, LOW);

 //  Serialer Ausgang für Fehlersuche:
 Serial.begin(115200);

 // Verbinde WLAN
 WiFi.begin(ssid, password);

 // Warte bis WLAN-Verbindung steht und gibt die Verbindungsdaten auf der seriellen Konsole aus
 Serial.println("");
 while (WiFi.status() != WL_CONNECTED)
 {
   Serial.print(".");
   delay(500);
 }
 Serial.println("");
 Serial.println("WLAN Verbindung hergestellt.");
 Serial.print("SSID: ");
 Serial.println(ssid);
 Serial.print("IP Adresse des ESP8266-Controllers: ");
 Serial.println(WiFi.localIP());

 // initialize mDNS:
 if (MDNS.begin(host))
 {
   Serial.println("mDNS responder started");
 }
 MDNS.addService("http", "tcp", 80);
 
 // starte HTTP-Webserver server auf Port 80:
 server.begin();
 Serial.println("HTTP-Webserver gestartet");

 // Ausgabe Webseite
 server.on("/", [](){
   server.send(200, "text/html", getContent());
 });

 server.on("/output1", [](){
   if (output1_state)
   {
     digitalWrite(output1, LOW);
     output1_state = false;
   }
   else
   {
     digitalWrite(output1, HIGH);
     output1_state = true;
   }
   server.send(200, "text/html", getContent());
   delay(1000);
 });

 server.on("/output2", [](){
   if (output2_state)
   {
     digitalWrite(output2, LOW);
     output2_state = false;
   }
   else
   {
     digitalWrite(output2, HIGH);
     output2_state = true;
   }
   server.send(200, "text/html", getContent());
   delay(1000);
 });
}

void loop()
{
 // In einer Endlosschleife, beantworte HTTP-Anfragen von außen
 server.handleClient();
}


Startet man den Controller, gibt dieser auf seiner seriellen Console die zugewiese IP vom Router aus.

   

Mit einem Mobiltelefon kann man nun die Webseite des Controllers aufrufen und die beiden Ausgangspins praktisch überall auf der Welt umschalten.

   




So ich denke das sollte als Einstieg in die Welt der WLAN-Microcontroller reichen. Wahrscheinlich bin ich der Einzige der mit solchen Dingern arbeiten wird. Thumbs_up

Viele Bastlergrüße aus FFM
Bernhard
Ansprechpartner für Umbau oder Modernisierung von Röhrenradios mittels SDR,DAB+,Internetradio,Firmwareentwicklung. 
Unser Open-Source Softwarebaukasten für Internetradios gibt es auf der Github-Seite! Projekt: BM45/iRadio (Google "github BM45/iRadio")
Zitieren
#15
(15.06.2017, 16:59)Bernhard45 schrieb: ..Wahrscheinlich bin ich der Einzige der mit solchen Dingern arbeiten wird. Thumbs_up

Viele Bastlergrüße aus FFM
Bernhard

ganz bestimmt nicht. Aber ich komme mit dem Tempo nicht mit. Ich hänge noch an ganz rudimentären Problemen fest (in der arduino- und attiny-Welt). Hätte ich gleich mit NodeMCU's angefangen hätte sich das vielleicht anders entwickelt.
Zitieren
#16
Hallo Bernhard,
vielen Dank für Deine Erklärungen und Einführungen in die Welt der Microcontroller.
Wir freuen uns darüber, daß uns ein Könner hilft, auch mal über den Tellerrand der
Röhren- und Transistorradios hinaus zu schauen und ich glaube, daß das ein spannendes
Thema ist. Wir brauchen aber Zeit, die Neuigkeiten aufzunehmen und zu verinnerlichen.
Daher bitten wir Dich, Geduld mit uns zu haben.

Gruß
Wilhelm
Niemandes Herr, Niemandes Knecht,
so ist es gut, so ist es recht

von Fallersleben
Zitieren
#17
Hallo Jupp, hallo Wilhelm,

wenn es Fragen gibt, auch zu den Problemen in der AVR-Welt, immer raus damit. Wir können das bestimmt gemeinsam lösen.
Ansprechpartner für Umbau oder Modernisierung von Röhrenradios mittels SDR,DAB+,Internetradio,Firmwareentwicklung. 
Unser Open-Source Softwarebaukasten für Internetradios gibt es auf der Github-Seite! Projekt: BM45/iRadio (Google "github BM45/iRadio")
Zitieren
#18
Der Vollständigkeit halber hier noch ein Verweis auf die umfangreichen Dokumentationen zum ESP8266 und ESP32.

https://espressif.com/en/support/download/documents

Hier die ständig aktualisierten SDKs des Herstellers:

https://espressif.com/en/support/download/sdks-demos
Ansprechpartner für Umbau oder Modernisierung von Röhrenradios mittels SDR,DAB+,Internetradio,Firmwareentwicklung. 
Unser Open-Source Softwarebaukasten für Internetradios gibt es auf der Github-Seite! Projekt: BM45/iRadio (Google "github BM45/iRadio")
Zitieren
#19
Nachfolgend zwei Artikel aus dem diesjährigen Elektor zum ESP32, dem großen Bruder des ESP8266. 

Einstieg mit der Arduino IDE

.pdf   1.pdf (Größe: 818,9 KB / Downloads: 12)

Einstieg in das Hersteller SDK

.pdf   2.pdf (Größe: 382,12 KB / Downloads: 11)

Die Monatsausgaben und auch den kompletten Jahrgang 2017 des Elektor kann man mittlerweile über bekannte Magazinseiten kostenlos zum Nachlesen downloaden.
Ansprechpartner für Umbau oder Modernisierung von Röhrenradios mittels SDR,DAB+,Internetradio,Firmwareentwicklung. 
Unser Open-Source Softwarebaukasten für Internetradios gibt es auf der Github-Seite! Projekt: BM45/iRadio (Google "github BM45/iRadio")
Zitieren
#20
Die NodeMCUs sind was ganz Tolles und fur Radio-Bastler dann z.B. sowas

https://hackaday.io/project/12887-wlan-sinus-generator

besonders interessant. Wenn die ADCs des ESP32 nicht so schlecht wären (Offset, Nichtlinearität u.a.), könnte man vielleicht sogar einen UKW-Stereo Messsender (neue deutsche Rechtschreibung mit drei S sieht hilflos aus) mit den zwei Modulen realisieren.
Zitieren


Möglicherweise verwandte Themen…
Thema Verfasser Antworten Ansichten Letzter Beitrag
  Arduino KW Funke Atze1967 6 854 19.11.2023, 19:22
Letzter Beitrag: Atze1967
  Arduino Nano-SI4703-IC2 Platine Revision 2 saarfranzose 3 2.715 07.07.2020, 20:51
Letzter Beitrag: navi
  DDS Wobbelsender mit AD9850 und Arduino Bernhard45 12 6.397 03.03.2020, 02:09
Letzter Beitrag: Bernhard45
  Arduino Baugruppen Daniel 0 1.412 09.03.2019, 13:19
Letzter Beitrag: Daniel
Lightbulb Arduino UNO R3 als Programmieradapter für PIC-Controller norbert_w 2 2.771 22.02.2018, 07:53
Letzter Beitrag: norbert_w

Gehe zu: