Ich sehe leider sehr oft Blogartikel in denen der HTML Code in der Arduino Datei eingebettet wird. Sowas kann man für eine Mini Demonstration zwar machen, ist aber im Alltag völliger Schwachsinn. Es ist viel zu unübersichtlich und sobald das Projekt wächst nicht mehr nutzbar.

Die ordentliche Alternative ist einen Ordner namens „data“ einzurichten und in diesem die Webseiten als html Dateien abzulegen. Zusätzlich wird das Styling als CSS Datei gespeichert und es können sogar Funktionen per JavaScript Datei ausgeführt werden. Also alles 1:1 wie auf einem gewöhnlichem Webserver!

Das könnte dich auch interessieren: WeMos D1 R2 erste Schritte und Wlan Integration

Liste der Komponenten

• Arduino IDE (Entwicklungsumgebung)
• WeMos D1 R2

Das Einrichten des Dateisystems (offiziell SPIFFS) geschieht einmalig und ist kinderleicht:

(Zunächst sollte man die grundlegende Einrichtung aus dem ersten Teil abgeschlossen haben!)

1. Auf GitHub eine Kopie der Datei „ESP8266FS-0.2.0.zip“ herunterladen und entpacken
2. Die Datei esp8266fs.jar im Arduino-Tool-Verzeichnis ablegen. Der Pfad sieht etwa so aus: [home_dir]\Arduino\tools\ESP8266FS\tool\esp8266fs.jar (Siehe Bild) Ich musste den Pfadteil tools\ESP8266FS\tool\ im Arduino Ordner selbst erstellen.
3. Die Arduino IDE neustarten.

Das wars auch schon! Man kann jetzt in der Arduino DIE unter Tools den neuen Punkt „ESP8266 Sketch Data Upload“ sehen.

Wie kann man das neue Dateisystem jetzt nutzen?

1. Erstellen Sie in ihrem aktuellen WeMos Projekt Ordner einen zusätzlichen Ordner mit dem Namen „data“. So wie in dem nachfolgendem Bild

2. Legen Sie die Dateien, die Sie hochladen möchten, in das ‚data‘-Verzeichnis
3. Wählen Sie in der Arduino IDE im Menü ‚Tools‘ den WeMos aus und wählen Sie eine Größe bei ‚Flash Size‘
4. Das Dialogfeld für den seriellen Monitor schließen!
5. Wählen Sie aus dem Menü ‚Tools‘ die Option ‚ESP8266 Sketch Data Upload‘.

Sobald der Upload abgeschlossen ist zeigt das Nachrichtenfenster der Arduino IDE 100% Upload an.

WeMos Beispielprogramm zum Ein- und Ausschalten der OnBoard LED

Ähnlich wie im ersten Teil wird der Webserver die OnBoard LED steuern. Als Basis dient ebenfalls der Code aus dem ersten Teil. Der überarbeitete Code sieht so aus:

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

ESP8266WebServer server(80);

void setup() {
  Serial.begin(115200); //Baudrate
  Serial.println("ESP starts");

  WiFi.begin("NerdCornerWiFi","NerdCornerPassword");


  Serial.print("Connecting...");

  while(WiFi.status()!=WL_CONNECTED){ //Loop which makes a point every 500ms until the connection process has finished

    delay(500);
    Serial.print(".");
  }
  Serial.println();

  Serial.print("Connected! IP-Address: ");
  Serial.println(WiFi.localIP()); //Displaying the IP Address

  if (MDNS.begin("nerd-corner")) {
    Serial.println("DNS started, available with: ");
    Serial.println("http://nerd-corner.local/");
  }

  server.serveStatic("/", SPIFFS, "/", "max-age=86400");
  SPIFFS.begin();

  server.onNotFound([](){ 
    server.send(404, "text/plain", "Landing page not found! Don't forget to name your landing page 'index.html'!");  
  });
 
  server.on("/led", HTTP_POST, []() {    
     
    const String ledState = server.arg("ledstate");
    if(ledState=="on"){
      switchLedOn();
    }
    else if(ledState=="off"){
      switchLedOff();
    }
    server.send(200, "text/json", "{\"result\":\"ok\"}");
  });

  server.begin();
  // initialize digital pin LED_BUILTIN as an output.
  pinMode(LED_BUILTIN, OUTPUT);
}

void loop() {
  server.handleClient();
  MDNS.update();

}

void switchLedOff(){ 
  digitalWrite(LED_BUILTIN, HIGH);   // turn the D1 LED off 
}

void switchLedOn(){ 
  digitalWrite(LED_BUILTIN, LOW);    // turn the LED on 
}

Auf ein paar Besonderheiten möchte ich dabei hinweisen. Wir haben beispielsweise folgendes hinzugefügt:

server.serveStatic("/", SPIFFS, "/", "max-age=86400"); 
SPIFFS.begin();

Ohne die beiden Zeilen wäre der Zugriff auf die Dateien im „data“ Ordner nicht möglich. Bitte beachten, dass der Name „index.html“ als default für die Landing Page eingestellt ist. Wenn man unbedingt möchte kann man das aber auch ändern.

server.on("/led", HTTP_POST, []() {    
     
    const String ledState = server.arg("ledstate");
    if(ledState=="on"){
      switchLedOn();
    }
    else if(ledState=="off"){
      switchLedOff();
      }
      server.send(200, "text/json", "{\"result\":\"ok\"}");
  });

Der „/led“ Endpoint empfängt die Befehle vom Webserver. Lautet der Befehl „on“ wird die LED eingeschaltet und bei „off“ wird die LED ausgeschaltet.

Wemos Webseite zum Ein- und Ausschalten der WeMos OnBoard LED

Die Beispielwebseite ist ganz einfach aufgebaut. Sie besteht in erster Linie aus 2 Buttons zum Ein- und Ausschalten der LED.

Die Ordnerstruktur der Webseite ist sehr übersichtlich gehalten. Es gibt eine Hauptseite mit dem Namen „index.html“ Dieser Name ist weltweit üblich für die Hauptseiten und wird auch automatisch vom WeMos entsprechend erkannt. Darüber hinaus einen „CSS“ Ordner fürs Styling und einen „JS“ Ordner für Funktionen.

Im Header Bereich der Webseite verlinken wir die Styles. Da wäre zum einen ein Standard Bootstrap, der alles automatisch bischen schöner macht und zusätzlich eine custom Styles Datei mit meinen eigenen Anpassungen. Außerdem werden im Header Bereich auch die Funktionen der Webseite verlinkt. Ich benutze den jQuery Standard um von der Webseite Requests an den WeMos zu senden. Meine eigenen custom Funktionen liegen in der „index.js“.

Bitte beachten, dass die jQuery Datei VOR der eigenen Datei eingebunden werden muss, sonst können keine jQuery Befehle im eigenen Code benutzt werden! Die eigenen Funktionen werden anschließend von den Buttons verwendet. Der HTML Code der Seite sieht insgesamt folgendermaßen aus:

<!DOCTYPE html>
<html lang="en"></html>
<html>
  <head>
    <meta charset="utf-8" />
    <meta
      name="viewport"
      content="width=device-width, initial-scale=1, shrink-to-fit=no"
    />
    <script type="text/javascript" src="js/jquery-3.5.1.min.js"></script>
    <script type="text/javascript" src="./js/index.js"></script>
    <link rel="stylesheet" href="css/bootstrap.min.css" />
    <link rel="stylesheet" href="css/custom-style.css" />
    <title>D1 Webserver</title>
  </head>
  <body>
    <h1>D1 Webserver with filesystem</h1>
    <p>
      This is an example for a WeMos Webserver with a filesystem. You can easily
      create webpages with html, css and js!
    </p>

    <h3>Example to turn on and off the built in LED</h3>
    <button class="button-style" onclick="changeLEDState('on')">Turn on</button>
    <button class="button-style" onclick="changeLEDState('off')">
      Turn off
    </button>

    <h3>Example to demo a JS function</h3>
    <button class="button-style" onclick="showAlert()">Show alert</button>
  </body>
</html>

Besonderes Augenmerk gilt der JavaScript Funktion „changeLEDState(value)“

function changeLEDState(value) {
  $.post("/led", { ledstate: value });
}

Dadurch, dass jQuery genutzt wird für die Kommunikation mit dem WeMos, reicht ein einfaches Dollarzeichen mit dem entsprechendem Request Befehl. Bei diesem POST Request wird ebenfalls ein Wert mit geschickt, welcher entweder „on“ oder „off“ ist zum ein- und ausschalten der LED.

Die Webseite kann nachfolgend als zip Datei heruntergeladen werden.

Dateien zum Herunterladen

• Wemos example webserver to control OnBoard LED

The post WeMos D1 R2 – Ganze Webseite mit html, css & js hosten appeared first on Nerd Corner.

Das könnte dich auch interessieren: Wie man einen Lüfter mit einem Arduino steuert!

Liste der Komponenten

• Arduino IDE (Entwicklungsumgebung)
• WeMos D1 R2

Unterschiede zwischen dem WeMos D1 R2 und dem Arduino UNO R3

Ein Arduino UNO R3 ähnelt optisch sehr dem WeMos D1. Der Hauptunterschied ist, dass der D1 ein ESP2866 WIFI Modul auf seiner Platine integriert hat. Dadurch hat man die Möglichkeit den D1 mit dem Internet zu verbinden. Grob gesagt ist der D1 ein wlanfähiger Arduino!

Man sollte allerdings beachten, dass die Taktfrequenz der beiden Prozessoren unterschiedlich sind. Der Arduino besitzt einen 8 bit Atmel Prozessor und der D1 einen Wlan fähigen ESP8266 Prozessor mit 32 bit Taktfrequenz. Die Pins des D1 sind zwar ähnlich angeordnet wie bei einem Arduino UNO, aber unterscheiden sich in der Betriebsspannung. Bei einem Arduino UNO liegt die Spannung der Pins bei 5V und bei dem D1 bei 3,3V. Zusätzlich ist aber auch auf dem D1 ein 5V Ausgang vorhanden. Aufgrund der Spannungsunterschiede an den Pins sollte man nicht blindlings ein Arduino Shield auf einen D1 stecken. Es empfiehlt sich zuerst die Kompatibilität zu prüfen!

Außerdem sollte man beachten, dass der D1 im Gegensatz zum Arduino nur einen analog Pin besitzt und zusätzlich die Anzahl der digitalen Pins unterschiedlich ist. Der Arduino besitzt 20 digitale Pins und der D1 nur 16 digitale Pins. Allerdings haben die digitalen Pins des D1 mehr nützliche Zusatzfunktionen.

Bitte beachten: Auch die Bezeichnung der digitalen D1 Pins unterscheidet sich von denen des Arduino und müssen daher softwaretechnisch angepasst werden.

Als letztes noch der Hinweis, dass sich der USB Anschluss ebenfalls unterscheidet. Im Gegensatz zum Arduino besitzt der D1 den deutlich verbreiteteren Micro USB Standard.

Einrichtung des D1

Die Arduino IDE öffnen und den D1 mit dem Computer verbinden. Unter Tools > Port den entsprechenden COM Port des D1 auswählen. Sollte der D1 hier nicht erkannt werden liegt das vermutlich an einem fehlenden Treiber.

Wenn nun der passende COM Port ausgewählt wurde und man einen Beispiel sketch auf den D1 lädt wird vorraussichtlich folgende Fehlermeldung auftauchen: „An error occurred while uploading the sketch avrdude: stk500_getsync() attempt 1 of 10: not in sync: resp=0x2e“. Der Grund für diesen Fehler ist, dass das falsche Board ausgewählt wurde. Der Name des ausgewählten Boards taucht rechts unten in der IDE auf:

Um den D1 auswählen zu können muss der Boardmanager für den ESP8266 noch hinzugefügt werden. Hier folgenden Link in Preferences > Board Manager einfügen: http://arduino.esp8266.com/stable/package_esp8266com_index.json

Anschließend in Tools > Board > Board Manager nach ESP8266 suchen und die neuste Version installieren:

Jetzt in Tools > Board > ESP8266 Boards > LOLIN (WEMOS D1 R2 &mini) auswählen:

Nun kann man wieder ein Beispielprojekt unter File > Examples > 01.Basics > Blink auswählen und mit einem Klick auf Upload funktioniert das Ganze. Das Beispielprojekt lässt jetzt die blaue LED auf dem ESP8266 Modul blinken.

Achtung: Dieses Setup war einmalig für die erstmalige Benutzung und muss nicht erneut wiederholt werden!

WeMos D1 mit dem Internet verbinden

Der Programmaufbau entspricht dem eines regulären Microcontrollers wie man es auch vom Arduino kennt. Es gibt eine setup() Funktion, welche nur einmal direkt zum Programmstart aufgerufen wird und eine loop() Funktion, welche nach dem setup() in Dauerschleife läuft.

Als erstes wird die ESP WiFi Bibliothek benötigt. Diese wird mittels #include <ESP8266WiFi.h> eingebunden. Sobald der ESP mit Strom versorgt wird, soll eine WLAN-Verbindung hergestellt werden. Daher wird der Code in die setup() Funktion geschrieben.

Wir brauchen den Seriellen Monitor um uns den aktuellen Stand des Verbindungsaufbaus anzeigen zu lassen. Die Baudrate kann selbst festgelegt werden. Für den D1 nehme ich 115200. Den Seriellen Monitor findet man unter Tools > Serial Monitor. Im Fenster des Seriellen Monitors kann rechts unten die Baudrate eingestellt werden. Bitte hier ebenfalls 115200 auswählen. Wählt man nicht die gleiche Baudrate wie im setup() definiert, werden einem nur unleserliche Sonderzeichen angezeigt.

Um sich mit dem Wlan zu verbinden reicht der einfache Befehl WiFi.beginn(„WlanName“, „WlanPasswort“). Es kann sehr hilfreich sein wenn man sich hier gleich die IP Adresse des D1 anzeigen lässt. Dazu nutzt man den Befehl WiFi.localIP()

#include <ESP8266WiFi.h>

void setup() {
  Serial.begin(115200); //Baudrate
  Serial.println("ESP starts");

  WiFi.begin("NerdCornerWiFi","NerdCornerPassword");

  Serial.print("Connecting...");

  while(WiFi.status()!=WL_CONNECTED){ //Loop which makes a point every 500ms until the connection process has finished

    delay(500);
    Serial.print(".");
  }
  Serial.println();

  Serial.print("Connected! IP-Address: ");
  Serial.println(WiFi.localIP()); //Displaying the IP Address

}

void loop() {
  // put your main code here, to run repeatedly:

}

Der D1 als Webserver und DNS-Server

Nach den bisherigen Schritten ist der D1 zwar mit dem WiFi verbunden, aber selbst noch nicht über einen Browser erreichbar. Damit der D1 bequem über den Browser angesteuert werden kann braucht man die #include <ESP8266WebServer.h> Bibliothek. Anschließend wird mit dem Befehl ESP8266WebServer server(80) ein Webserver Objekt erstellt und der Port 80 festgelegt. Der Server lässt sich nun mit dem Befehl server.begin() starten. Damit der D1 zu jederzeit prüfen kann, ob Anfragen zu bearbeiten sind, wird der server.handleClient() in die loop() Funktion geschrieben.

Gibt man nun die IP Adresse des D1 in einem Browser ein, von einem Gerät, dass sich im selben WiFi befindet, ist der D1 bereits erreichbar. Es wurde nur noch nicht spezifiziert was bei einem Aufruf des D1 passieren soll.

Man kann sich hier auch vorgefertigte Funktionen anzeigen lassen. Für den Anfang beispielsweise einen Satz, wenn der Link nicht definiert wurde, oder einen Text für einen custom Link. Es können auch eigene Funktionen für bestimmte Links ausgeführt werden.

server.onNotFound([](){ 
  server.send(404, "text/plain", "Link was not found!");  
});
 
server.on("/", []() {
  server.send(200, "text/plain", "Landing page!");
});
 
server.on("/custom", []() {
  server.send(200, "text/plain", "Just a custom route!");
  ownFunction();
});

Die Webserver Einrichtung ist jetzt abgeschlossen. Da es aber meist sehr nervig ist jedesmal die IP-Adresse des D1 in den Browser einzutippen bzw. die sich auch ändern kann, macht es Sinn dem DNS des D1 einen Namen zuzuweisen. Dafür wird wieder eine Bibliothek verwendet, welche mittels #include <ESP8266mDNS.h> eingebunden wird. Der DNS wird einmalig definiert und daher in die setup() Funktion geschrieben. Um den DNS Namen festzulegen, nutzt man die Methode MDNS.begin(DNS Name), beispielsweise MDNS.begin(nerd-corner). Zusätzlich muss noch MDNS.update() in die loop Funktion geschrieben werden.

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

ESP8266WebServer server(80);

void setup() {
  Serial.begin(115200); //Baudrate
  Serial.println("ESP starts");

  WiFi.begin("NerdCornerWiFi","NerdCornerPassword");

  Serial.print("Connecting...");

  while(WiFi.status()!=WL_CONNECTED){ //Loop which makes a point every 500ms until the connection process has finished

    delay(500);
    Serial.print(".");
  }
  Serial.println();

  Serial.print("Connected! IP-Address: ");
  Serial.println(WiFi.localIP()); //Displaying the IP Address

  if (MDNS.begin("nerd-corner")) {
    Serial.println("DNS started, available with: ");
    Serial.println("http://nerd-corner.local/");
  }

  server.onNotFound([](){ 
    server.send(404, "text/plain", "Link was not found!");  
  });
 
  server.on("/", []() {
    server.send(200, "text/plain", "Landing page!");
  });
 
  server.on("/custom", []() {
    server.send(200, "text/plain", "Just a custom route!");
    ownFunction();
  });

  server.begin();

}

void loop() {
  server.handleClient();
  MDNS.update();

}

void ownFunction(){ //go to "IP-Adress/custom" to call this function
  Serial.println("Own function was called");

}

Anschließend kann man im Browser http://nerd-corner.local eingeben und man erreicht den D1. Bitte beachten, dass die Endung immer „.local“ sein muss! Manche Android Geräte unterstützen mDNS nicht, dann muss weiterhin die tatsächliche IP Adresse angegeben werden. Jetzt steht der Verwendung für eigene Projekte eigentlich nichts mehr im Weg! Hier findet Ihr ein paar spannende Anwendungsbeispiele: https://makesmart.net/tag/d1-mini/

Beispielprogramm zum Ein- und Ausschalten der OnBoard LED

Zum Abschluss des Blogposts noch ein simples Beispielprogramm bei dem wir das bisher gelernte anwenden. Wir schreiben zwei zusätzliche Funktionen. Eine um die fest verbaute BuiltIn Led einzuschalten und eine Funkton zum Ausschalten. Ein kleiner Hinweis, im Gegensatz zum Arduino wird die LED mit digitalWrite(LED_BUILTIN, LOW) eingeschalten statt ausgeschalten, also genau invertiert!

Die Funktionen können über http://nerd-corner.local/on und http://nerd-corner.local/off aufgerufen werden. Anbei der vollständige Programmcode:

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

ESP8266WebServer server(80);

void setup() {
  Serial.begin(115200); //Baudrate
  Serial.println("ESP starts");

  WiFi.begin("NerdCornerWiFi","NerdCornerPassword");

  Serial.print("Connecting...");

  while(WiFi.status()!=WL_CONNECTED){ //Loop which makes a point every 500ms until the connection process has finished

    delay(500);
    Serial.print(".");
  }
  Serial.println();

  Serial.print("Connected! IP-Address: ");
  Serial.println(WiFi.localIP()); //Displaying the IP Address

  if (MDNS.begin("nerd-corner")) {
    Serial.println("DNS started, available with: ");
    Serial.println("http://nerd-corner.local/");
  }

  server.onNotFound([](){ 
    server.send(404, "text/plain", "Link was not found!");  
  });
 
  server.on("/", []() {
    server.send(200, "text/plain", "Landing page!");
  });
 
  server.on("/on", []() {
    server.send(200, "text/plain", "Switching LED on!");
    switchLedOn();
  });

  server.on("/off", []() {
    server.send(200, "text/plain", "Switching LED off!");
    switchLedOff();
  });

  server.begin();


  // initialize digital pin LED_BUILTIN as an output.
  pinMode(LED_BUILTIN, OUTPUT);
}

void loop() {
  server.handleClient();
  MDNS.update();

}

void switchLedOff(){ 
  digitalWrite(LED_BUILTIN, HIGH);   // turn the D1 LED off 
}

void switchLedOn(){ 
  digitalWrite(LED_BUILTIN, LOW);    // turn the LED on 
}

The post WeMos D1 R2 erste Schritte und Wlan integration appeared first on Nerd Corner.

Das könnte dich auch interessieren: Textnachrichten mittels Lichtsignale senden

Eng mit diesem Artikel verbunden: Fehlererkennung bei der Datenübertragung

Ebenfalls relevant: Taktgeschwindigkeit für eine Datenübertragung festlegen in C

Liste der Bauteile

• 2x Raspberry Pi 4
• 2x 5V Solarzelle
• 2x 5V Laserdiode
• Jumper Kabel
• 3D Drucker
• Filament
• 2x 5V Lüfter
• NPN Transistor
• 2x ADC Board mit einem LM393

Verkabelung

Anders als bei der Verkabelung im letzten Artikel, in dem Textnachrichten mittels Lichtsignale von einem Pi zu einem Arduino gesendet wurden ( Link: https://nerd-corner.com/de/textnachrichten-mittels-lichtsignale-senden-pi-zu-arduino/ ), gibt es jetzt keinen definierten Empfänger und keinen definierten Sender. Es werden stattdessen zwei baugleiche Stationen aufgebaut, die sowohl Daten senden und empfangen können.

Aus diesem Grund werden die Raspberry Pi’s sowohl mit einem 5V Laser als auch mit einer 5V Solarzelle verbunden. Für den Laser wurde der GPIO18 Pin gewählt, welcher in der „wiringPi“ Library Pin 1 entspricht. Die „wiringPi“ Library wird im Programmcode verwendet. Direkt unter GPIO18 befindet sich ein Ground, welcher mit dem Minus Pol des Lasers verbunden wird.

Die Solarzelle liefert je nach Lichtintensität einen entsprechenden Spannungswert. Da die digitalen Pins des Raspberry Pi aber nur 1 und 0 erkennen können, muss mit Hilfe eines Komparators der analoge Wert der Solarzelle in einen digitalen Wert gewandelt werden. Der Vorgang wird genauer im Abschnitt „ADC Board mit einem LM393 Komparator“ erläutert. Für die Verkabelung wird der Plus und Minus Pol der Solarzelle mit den Plus und Minus Kontakten des ADC Boards verbunden. Anschließend wird der Ground des ADC Boards an einen Raspberry Pi Ground verbunden und für die Spannungsversorgung der Plus Pol des ADC Boards mit 5V des Pi verbunden. Der D0 Pin des ADC Boards liefert den digitalen Wert 0 oder 1, abhängig von der Lichtintensität der Solarzelle. Diesen Pin habe ich mit GPIO17, welcher in der „wiringPi“ Library Pin 0 entspricht, verbunden.

Da mir aufgefallen ist, dass der Pi im Betrieb sehr heiß wird, habe ich noch einen Lüfter angeschlossen. Damit der Lüfter sich nicht dauerhaft im Betrieb befindet, was sich negativ auf die Leistung des Lasers auswirken würde, kann der Lüfter durch einen NPN Transistor geschalten werden. Hierfür verbindet man den Plus Pol des Lüfters direkt mit einem 5V Pin des Raspberry Pi und den Minus Pol des Lüfters mit dem Emitter des NPN Transistors. Der Collector des Transistors wird mit einem Ground des Pi verbunden. Um nun den Lüfter über den Transistor ein- und ausschalten zu können wird die Transistor Basis mit einem GPIO Pin verbunden. Ich habe beispielsweise GPIO27 (entspricht in der „wiringPi“ Library Pin 2) gewählt. In der Nachfolgenden Tabelle werden die Pins des Pi der Nummerierung der „wiringPi“ Library gegenüber gestellt.

ADC Board mit einem LM393 Komparator

Die Solarzelle gibt abhängig von der Lichtintensität einen Spannungswert zurück. Leider hat der Raspberry Pi aber keine analogen Pins um diesen Spannungswert auszulesen. Daher muss das analoge Signal in ein digitales Signal umgewandelt werden. Mit Hilfe des LM393 Komparators ist das möglich. Dieser ist häufig auf ADC Boards verbaut. Hier habe ich einfach den ursprünglichen Sensor (es war ein Fotowiderstand) durch die Solarzelle ersetzt. Mit Hilfe eines Potentiometers kann der Komparator eingestellt werden. Das bedeutet, sobald der Spannungswert der Solarzelle, welcher von der Lichtintensität abhängt, den eingestellten Wert des Potentiometers übersteigt, wird eine digitale 1 gemessen, anderenfalls eine digitale 0.

Aufbau des Datenframes

Der Datenframe für das Versenden der Textnachrichten mittels visueller Lichtkommunikation (Link: https://nerd-corner.com/de/textnachrichten-mittels-lichtsignale-senden-pi-zu-arduino/ ) bestand aus einer Preamble, der Länge der Textnachricht, dem Textinhalt und der zyklischen Redundanzprüfung. Um aber statt Textnachrichten alle möglichen Arten von Daten verschicken zu können muss anstelle der Länge der Textnachricht der Dateiname, die Dateiendung, die Gesamtzahl der Pakete und die Nummer des aktuellen Pakets angegeben werden. Anschließend kann der Dateninhalt und der Code der zyklischen Redundanzprüfung angefügt werden.

Softwarecode für Datentransfer mittels VLC

Im Grunde wurden die Empfänger- und Senderskripte aus dem vorherigen Projekt zum Senden von Textnachrichten mittels visueller Lichtkommunikation (Link: https://nerd-corner.com/de/textnachrichten-mittels-lichtsignale-senden-pi-zu-arduino/ ) weiterentwickelt und zu einem gemeinsamen Skript zusammengefasst. Welches auf beiden Raspberry Pi’s Anwendung findet. Es wurde beispielsweise eine „ReadFile“ und „WriteFile“ Funktion ergänzt, welche Dateien einlesen und empfangene Datenpakete zu einer Datei zusammenfassen und abspeichern können. Das Programm wurde wieder in C geschrieben, da eine hohe Geschwindigkeit bei der Datenübertragung erreicht werden soll. Details zur präzisen Programmierung in C für eine schnelle Datenübertragung in diesem Beitrag: https://nerd-corner.com/de/wie-programmiert-man-einen-praezisen-timer-in-c-fuer-linux/

Der gesamte Softwarecode zum Datentransfer mittels VLC kann am Ende des Artikels heruntergeladen werden. Der Kern des Programms ist wieder eine State Maschine mit Hilfe derer ausgewählt werden kann, ob Daten gesendet oder empfangen werden sollen. Außerdem schaltet das Programm automatisch den Lüfter an, wenn keine Datenübertragung stattfindet. Wichtig: Beim Kompilieren bitte nicht die „wiringPi“ Bibliothek und die „math.h“ Bibliothek vergessen! Der Befehl lautet: „gcc -o transceiver transceiver.c -lwiringPi -lm“

while(1)
    {
        digitalWrite (2, HIGH);
        printf("Press the R button for Receiver Mode or any other key for Sender Mode\n");
        scanf(" %c",&mode);
        
        if (mode=='R'||mode=='r')
        {
            digitalWrite(2,LOW);
            modeReceiver=true;
        }
        
        if (mode!='R'&&mode!='r')
        {
            digitalWrite(2,LOW);
            modeReceiver=false;
            
            char dataName[NAME_MAX];
            char dataExtension[NAME_MAX];
            
               
            printf("\n Name of file WITHOUT extension: ");
            scanf("%s",dataName);

            printf("\n Extension: ");
            scanf("%s",dataExtension);

            if (read_file(dataName, dataExtension, file_content) != OK)
            {
                printf("File read error, size exceeds array size\n");
                return -1;
            }
            BuildDataFrame(dataName, dataExtension, file_content);
        }
        
        
        
        while(modeReceiver)
        {
            gettimeofday(&tval_after, NULL);
            timersub(&tval_after, &tval_before, &tval_result);
            double time_elapsed = (double)tval_result.tv_sec + ((double)tval_result.tv_usec/1000000.0f);
            
            while(time_elapsed < 0.001)
            {
                gettimeofday(&tval_after, NULL);
                timersub(&tval_after, &tval_before, &tval_result);
                time_elapsed = (double)tval_result.tv_sec + ((double)tval_result.tv_usec/1000000.0f);
            }
            gettimeofday(&tval_before, NULL);
            
            int data = digitalRead(0);
            
            
            switch (state)
            {
                case 0:
                    //looking for preamble pattern
                    synchro_Done=false;
                    LookForSynchro(data);
                    
                    if (synchro_Done==true)
                    {
                        state=1;
                    }
                    break;
                    
                case 1:
                    //receive the actual data
                    receiveData_Done=false;
                    senderState=false;
                    ReceiveData(data);
                    
                    if(receiveData_Done&&senderState==false)
                    {
                        state=0;
                    }
                    if(senderState==true){
                        senderState=false;
                        state=0;
                        modeReceiver=false;
                        }
                    break;
                  
            }
            
        }
    }

Gehäuse

Um die Komponenten an Ort und Stelle fixieren zu können, wurde im CAD ein Gehäuse konstruiert. Dies hat auch den Vorteil, dass keine komplizierte Ausrichtung der Laser und der Solarzellen für die Datenübertragung notwendig ist. Für Anfänger eignet sich TinkerCAD zum Gehäuse design. TinkerCAD ist kostenlos und kann direkt im Browser benutzt werden. Alternativ können die STL Files für den 3D Drucker auch hier heruntergeladen werden.

Das Gehäuse zum Datentransfer mittels VLC besitzt eine Öffnung für die Solarzelle und den Laser. Außerdem wurde ein Abluftschacht für den Lüfter konstruiert und zusätzlich Platz für ein Raspberry Pi Gehäuse frei gelassen. Im nachfolgenden Bild wird der Einbau der Komponenten dargestellt.

Fazit zum Datentransfer mittels VLC

Es wurde das bereits bestehende System zum Senden von Textnachrichten mittels visueller Lichtsignale weiterentwickelt, sodass jetzt alle Arten von Daten gesendet und empfangen werden können. Das System funktioniert erstaunlich erfolgreich. Es ist sehr robust und erreicht eine Datenrate von 1 kBit/s bis 10 kBit/s. Alle ankommenden Datenpakete können durch den intelligenten Aufbau des Datenframes direkt zugeordnet werden. Lediglich ein Acknowledgement Signal wäre noch eine sinnvolle Ergänzung. Ein solches Signal wäre eine Rückmeldung vom Empfänger an den Sender um dem Sender mitzuteilen, dass alle Pakete angekommen sind, oder eventuell ein bestimmtes Paket fehlerhaft war und erneut gesendet werden muss.

Ebenfalls interessant für die Zukunft wäre andere Modulationsarten auszuprobieren. Besonders das speziell für visuelle Lichtkommunikation erdachte Colour Shift Keying würde ich gerne näher untersuchen und die daraus resultierenden Datenraten vergleichen.

Dateien herunterladen:

• Softwarecode Transceiver
• STL files housing
• Pi Case with free pins (Creative Common License from Thingiverse)

The post Upgrade: Datentransfer mittels VLC und LiFi – Pi zu Pi Übertragung appeared first on Nerd Corner.

Zunächst möchte ich nur einzelne Textnachrichten in eine Richtung übertragen. In einem nächsten Schritt kann dies dann ausgeweitet werden um ganze Dateien bidirektional zu übertragen. Zum Empfangen der Nachrichten habe ich einen Ardunio ausgewählt, da dieser im Gegensatz zum Raspberry Pi analoge Eingänge besitzt und somit leicht mit analogen Sensoren verbunden werden kann. Zum Senden eignet sich ein Raspberry Pi, da hier nur digitale Pins benötigt werden und ein Pi allgemein leistungsfähiger bzw. schneller Daten übertragen kann. Das wurde bereits in den vorrangegangenen Posts zum Definieren einer Taktfrequenz beim Arduino und beim Raspberry Pi getestet. Alle Skripte zum Betrieb der VLC Kommunikation können am Ende des Artikels heruntergeladen werden. Die folgenden drei Blogposts stehen in direktem Zusammenhang zu diesem Projekt:

UPGRADE: ALLE ARTEN VON DATEN MITTELS VISUELLER LICHTKUMMUNIKATION ÜBERTRAGEN

So programmiert man die Taktfrequenz des Arduino: Timer Interrupts nutzen als Taktfrequenz.

So programmiert man die Taktfrequenz des Pi: Präzise Timer Funktion in C für den Pi.

So verhinderst man Fehler in der Datenübertragung: Mit CRC fehlerhafte Pakete erkennen.

Liste der Bauteile

• Arduino Uno
• Raspberry Pi 4
• 5V Solarzelle
• 5V Laserdiode
• Jumper Kabel

Verkabelung für die Visuelle Lichtkommunikation

Die Verkabelung gestaltet sich eher simpel. Die 5V Solarzelle ist sehr gut geeignet um Lichtsignale zu detektieren. Daher wird die Solarzelle mit dem Empfänger, also dem Arduino verbunden. Der Ground der Solarzelle wird mit einem Ground des Arduinos verbunden. Die Plusleitung der Solarzelle wird mit einem analogen Pin des Arduinos verbunden. Hier eignet sich beispielsweise A0.

Vom Raspberry Pi aus werden die Nachrichten über Lichtsignale des Lasers an den Arduino übermittelt. Hierfür wird der Ground einer Laserdiode (5V) mit einen Ground Pin des Pi verbunden (siehe Grafik). Anschließend wird die Plusleitung der Laserdiode mit einer der digitalen Pins des Raspberry Pis verbunden. Hier habe ich den GPIO17 Pin gewählt, welcher in der „wiringPi“ Library Pin 0 entspricht (siehe Grafik).

Als Alternative zu dem Laser und der Solarzellen Kombination kann auch eine LED und ein Photowiderstand genutzt werden. Allerdings eignet sich ein Laser besser für schnellere und präzisere Datenübertragung. Dazu bietet eine Solarzelle eine große Fläche um die Laserstrahlen zu detektieren.

Modulationsmethode On-Off-Keying

Die Textnachrichten werden im Binärcode als „1“ oder „0“ übertragen. Es gibt verschiedene Möglichkeiten diese Daten zu modulieren. Eine der einfachsten Möglichkeiten ist es eine identische Taktfrequenz für den Sender und Empfänger festzulegen. Dann wird in jedem Takt entweder eine „1“ oder eine „0“ übertragen.

Die Vorgehensweise nennt sich Aplituden-Shift-Keying. Wenn die Laserdiode besonders stark die Solarplatte anleuchtet wird das vom Empfänger als binäre „1“ detektiert. Wenn aber die Laserdiode nur schwach leuchtet wird das als binäre „0“ detektiert.

Tatsächlich macht es aber Sinn die Laserdiode gar nicht leuchten zu lassen für eine binäre „0“. Dann spricht man von On-Off-Keying. Das ist sozusagen eine Vereinfachung des Amplituden-Shift-Keyings. Die nachfolgende Grafik verdeutlicht den Unterschied zwischen Amplituden-Shift-Keying und On-Off-Keying.

Das bedeutet, immer wenn die Solarzelle Licht detektiert, wird ein entsprechender Spannungswert an den analogen Pin des Arduino übergeben. Wenn dieser Spannungswert einen vordefinierten Wert übersteigt, registriert der Arduino es als eine binäre „1“, ansonsten als binäre „0“. Es macht durchaus Sinn den vordefinierten Wert an das Tageslicht anzupassen. Eventuell mit Hilfe eines zusätzlichen Lichtsensors.

Arduino Code zum Nachrichten empfangen

//This is the "real" loop function
  switch (state)
  {
    case 0:
      //looking for synchronization sequence
      synchro_Done=false;
      lookForSynchro(data);

      if (synchro_Done== true)
      {
        state=1;
      }
      break;
    case 1:
      //receive Data
      receiveData_Done =false;
      receiveData(data);

      if (receiveData_Done==true)
      {
        state=0; 
      }
      break;
  }

Die Software des Arduino ist im Prinzip als State Machine aufgebaut. Es gibt zwei States. Ein State für die Synchronisierung und einer für das Auslesen der Textnachricht. Im State Synchronisierung wartet der Empfänger auf eine festgelegte Bitsequenz (Preambel) beispielsweise „10101010101111111111“. Diese Sequenz bedeutet, dass der Empfänger jetzt zuhören muss, weil eine Textnachricht folgt. Der vollständige Arduino Code kann am Ende des Artikels heruntergeladen werden. Die nachfolgende Grafik zeigt den genauen Aufbau der Datenpakete.

Sobald die Preambel erkannt wurde, wechselt der Empfänger automatisch in den zweiten State und empfangt die eigentliche Nachricht. Wobei jedoch die ersten 16 Bits der Textnachricht einer Dezimalzahl entsprechen, die dem Empfänger mitteilt, wie viele Zeichen die ankommende Textnachricht umfasst. Sobald diese Zahl erreicht wurde, wird der Text im Serial Monitor des Arduino ausgegeben und der State wechselt wieder zurück. Jetzt wird erneut auf die Synchronisierungsequenz gewartet. Der vollständige Softwarecode kann am Ende des Blog Artikels heruntergeladen werden. Zur Verbesserung der Übertragungsqualität kann noch eine zyklische Redundanzprüfung durchgeführt werden wie in der nachfolgenden Grafik.

Raspberry Pi Code zum Nachrichten senden

//Read message
        char msg[3000]; 
        int len, k, length;
       
        printf("\n Enter the Message: ");
        scanf("%[^'\n']",msg);
        
        len=strlen(msg);
        
        
        int2bin(len*8, 16); //len*8, because 8 bits are one byte
        
        for(k=0;k<len;k++)
        {
                chartobin(msg[k]);            
        }

Der Programmcode des Raspberry Pi muss in C geschrieben werden. Python wäre zu langsam und würde keine stabile Taktfrequenz zum Senden der Daten erreichen. Der vollständige Programmcode kann am Ende der Artikels heruntergeladen werden. Damit der Pi die Laserdiode steuern kann wird die „wiringPi.h“ library benötigt. Über „digitalWrite(0, HIGH)“ kann so die Diode eingeschalten werden und mittels „digitalWrite(0, LOW)“ wieder aus. Wichtig: Beim Kompilieren bitte nicht die „wiringPi“ library vergessen! Der Befehl lautet: „gcc -o simpleLaser simpleLaser.c -lwiringPi“

Am Anfang fordert das Programm mittels printf Funktion eine Textnachricht einzugeben. Diese wird mittels scanf Funktion eingelesen und gespeichert. Anschließend wird jeder Buchstabe in Binärcode umgewandelt und in einem Array abgespeichert. Die Umwandlung wird in der nachfolgenden Grafik gezeigt. Am Ende wird in einem festgelegten Takt der Binärcode aus dem Array übermittelt. Für eine binäre „1“ wird die Laserdiode eingeschaltet und für eine binäre „0“ wieder aus.

Fazit zum Projekt Visuelle Lichtkommunikation

Die Übertragung der Textnachrichten mittels Visuelle Lichtkommunikation funktioniert hervorragend. Dank der zyklischen Redundanzprüfung auch absolut fehlerfrei. Allerdings ist der Nutzen einer eindimensionalen Nachrichtenkommunikation eher gering. Es wäre besser, wenn jegliche Art von Dateien übertragen werden könnte und das in beiden Richtungen. Hier wird wohl bald ein Update folgen.

Dateien zum Herunterladen

• Arduino Code VLC to receive text messages
• Raspberry Pi code to send text messages with VLC

The post Textnachrichten mittels Lichtsignale senden – Pi zu Arduino appeared first on Nerd Corner.