Kurzbeschreibung

Aufbau einer elektrischen Steuerung für ein Einwurfsystem, beispielsweise einer Rückgabeklappe für Bücher. Dabei sollte das System die Klappe nur zu bestimmten Zeitslots (zum Beispiel außerhalb der Öffnungszeiten) freigeben. Außerdem soll ein Display angebunden werden auf dem für den Einwerfenden relevante Informationen (wie zum Beispiel die Öffnungszeiten) angezeigt werden können. Des Weiteren sollen die eingeworfenen Gegenstände gezählt und diese Daten, sowie etwaige Fehlermeldungen, an den Besitzer des Einwurfsystems übermittelt werden. Das ganze System wird in ein Gehäuse verbaut um es flexibel einsetzbar zu machen.

Checkliste

  • Erstellen des Konzepts
  • Hardware Bestellung
  • Programmierung der Software
  • Probeaufbau und Test
  • Fehlerbehebung und Feedback Integration
  • Hardware entwerfen
  • Einbau
  • Abschlusspräsentation


Benötigte Hardware

→ Außerdem benötigt werden natürlich diverse Kleinteile wie Kabel, Schalter, Sensoren, Widerstände, LEDs, ein Steckboard für den Probeaufbau, Lötkolben, Schrumpfschlauch, ...


Dokumentation Hauptprogramm (Arduino UNO + Ethernet Shield)

Um die folgenden Programmcodes ansehen, kompilieren und auf die jeweiligen Mikrocontroller zu übertragen ist die Arduino IDE nötig.

Meine zusätzlich installierten Libraries sind hier zu finden. Ich beschreibe die Installation aber auch in der Dokumentation.

Ein schöner Editor um nur den Code zu betrachten ist Atom.

Der Code ist durchgehend kommentiert und sollte dadurch gut verständlich sein. → Dokumentation zur Arduino Programmiersprache kann hier gefunden werden.

Für die Layouts der Verkabelung habe ich die Software Fritzing verwendet.

Alle Bilder können durch einen Klick vergrößert dargestellt werden.


Programmierung der Software:

Die Software wird schrittweise zusammengebaut. Ich habe Sie in 5 Teilbereiche zerlegt, um die jeweilige Funktion der Komponente genau verstehen zu können: 

  1. Ethernet Funktionalität herstellen (Ethernet_)
  2. WebServer Funktionen testen (WebServer_)
  3. Real Time Clock (RTC_)
  4. Schrittmotor Ansteuerung (Schrittmotor_)
  5. Der sogenannte Master, also das Hauptprogramm, in dem alles zusammen läuft (Master_)

Link zum GitHub Repository: https://github.com/Baule8520/Einwurfsystem-Arduino

1. Ethernet Funktionalität:

Der erste Ethernet Shield den ich bestellt habe war ein günstiges No-Name Produkt von Ebay. Der Shield wird auf den Arduino aufgesteckt. Der Arduino wird per USB-Kabel mit dem PC verbunden, das Shield per Patch Kabel mit dem eigenen Router oder Switch. Wichtig ist dass man dem Arduino entweder in der Konfigurations Oberfläche des Routers eine feste IP-Adresse zuweist oder weiß in welchem Bereich sich freie IP-Adressen befinden die nicht vom DHCP Server belegt werden können. Diese IP-Adresse wird dann im Programmcode eingegeben.

Der nicht originale Shield passt nicht wirklich gut, wenn man ihn zu weit aufsteckt, riskiert man einen Kurzschluss von den oberen Lötstellen des Shields auf die USB Buchse des Arduinos. Deswegen wurde die Unterseite des Shields isoliert (abgeklebt).

Als ersten Test versuche ich das in der Arduino IDE mitgelieferte Beispiel →  Ethernet → WebServer. Nach dem Kompilieren und Uploaden auf den Arduino kommt am seriellen Monitor die Fehlermeldung "Ethernet Shield not found..." 

Ich vermutete dass der Fehler am Beispiel Code lag und da ich das Programm im Detail verstehen wollte, vereinfachte ich das Beispiel und schrieb es neu. → Ethernet_Connection_Check_1.0

Das Shield ließ sich aber nach wie vor nicht ansprechen. Nach genauer Untersuchung des SMD Chips auf dem Shield ist klar, warum das Gerät nicht funktioniert. Zwei mal zwei Beinchen sind miteinander verbunden und haben das Shield zerstört. Eine nachträgliche Trennung der Beinchen per Lötkolben hat das Shield leider nicht mehr retten können.

Erste wichtige Einsicht:Originale Hardware ist auf jeden Fall ihr Geld wert!  (wink)

Der oben verlinkte originale Ethernet Shield Version 2 funktioniert sofort. Nach Upload des Codes (Strg + U) kann man den aktuellen Status im seriellen Monitor mitverfolgen (Strg + Umschalt + M). Wenn man in einem Browser dann die im Programmcode festgelegte IP-Adresse eingibt (in meinem Fall 192.168.188.10) und aufruft sieht man "Ethernet Connection Test Erfolgreich". (Natürlich muss man sich dazu im gleichen Netzwerk befinden!)

Nachdem der Datentransfer vom Arduino in den Browser funktioniert, ist der nächste Schritt eine Interaktionsschnittstelle zu schaffen, über die man von der Website Informationen auf den Arduino übertragen kann. Dazu habe ich in die HTML Daten eine sogenannte href eingebaut, also einen Verweis auf einen Link. Dieser wird dann im "readString" auf dem Arduino gespeichert und kann dort ausgelesen werden. Anbei der Code der eine LED über den Browser an Pin 2 ein- und ausschalten kann. → Ethernet_Interaction_Check_1.1

Außerdem ist bei diesem Code ein Unterschied im Timing, wann die HTML Daten zum Browser abgesendet werden. In Version 1.0, welches ja auf Basis der Arduino Beispielbibliothek basiert wird ein exaktes Timing verwendet. Erst wenn der HTML Request des Browsers zu Ende ist werden die Daten gesendet. In Version 1.1 habe ich diese Funktion deaktiviert, da ich festgestellt habe dass die Daten beim Browser trotzdem ankommen.


2. WebServer Funktionen:

Als grundlegende Funktion wollte ich als erstes per Browser einen Servo steuern und Sensordaten (hier ein Schalter, grundsätzlich ist aber jede andere Art von Sensor auch möglich) in aufbereiteter Form im Browser darstellen.

Dazu folgende Verkabelung:

Der Code ist gut kommentiert und daher sind keine weiteren Erklärungen an dieser Stelle nötig → WebServer_1.0_Test.ino

Ein großes Problem in Version 1.0 ist der Sensor, dieser liefert unzuverlässige Daten, da ich vergessen habe einen Pull-Down Widerstand einzubauen. Weitere Informationen zu Pull-Up und Pull-Down Widerständen sind hier nachzulesen.


Also kommt Version 1.1 in der der bestehende Fehler gelöst wird und eine Funktion integriert wird die über einen Sensor ankommende Daten aufsummiert (Zählsystem: Wie viele Bücher wurden eingeworfen). → WebServer_1.1_Speicher

Einen Pull-Down Widerstand habe ich nicht eingebaut, stattdessen kann man den pinMode() softwareseitig auf INPUT_PULLUP setzen. Dabei entfällt der Widerstand und man muss den Sensor anstatt auf +5V mit Gnd verbinden. Außerdem habe ich eine Kontrolllampe integriert um den Status der Klappe auch visuell sichtbar zu machen:

Ein Problem das hierbei gelöst werden muss, ist das Entprellen der Taste für den Einwurf. Da der Arduino ja den Sensor im Millisekunden Takt abfragt, wird es passieren dass ein kleiner Knopfdruck durchaus als einige zehn Knopfdrücke interpretiert werden. Man kann dieses Problem durch entsprechende Hardware Verschaltung lösen, aber dabei ist man unflexibel. Die elegantere Lösung ist eine softwareseitige die sich auf den jeweiligen Sensor, aber auch an die jeweilige Zeitspanne, wie lange der Sensor gedrückt bleibt pro Einwurf, anpassen kann. Dabei habe ich mir eine Anregung auf dieser Seite geholt. 


Version 1.2 ist das Einfügen eines href Links um den Zähler resetten zu können und einen href Link um die Seite zu aktualisieren (der Link an und für sich hat keine Funktion, aber die Seite wird dabei neu geladen) → WebServer_1.2_Speicher_fertig

Zur Überprüfung ob alles korrekt funktioniert, die Ausgabe am seriellen Monitor:

Da jetzt alle Anforderungen und Funktionen an den WebServer und die manuelle Steuerung erfüllt sind, kommt im nächsten Kapitel die automatische Steuerung. Dafür braucht man die genaue Uhrzeit, eine Real Time Clock, kurz RTC.


3. Real Time Clock:

Der Standard Arduino hat keine RTC. Es gibt eine Funktion um die Zeit zu messen, diese heißt millis(), allerdings zeigt diese nur die Zeit seit dem letzten Boot des Boards an und ist damit für unseren Zweck völlig ungeeignet. Das Board soll ja beispielsweise auch nach einem Strom Ausfall sofort wieder funktionieren. Es gibt einen Typ Board, den Arduino Zero, welcher eine RTC eingebaut hat. Das Board muss dabei mit AA Batterien immer mit Spannung versorgt sein. Für das Projekt scheidet dieses Board aber aus, da es mit 3,3 Volt betrieben wird. Dementsprechend funktioniert der Ethernet Shield nicht, da dieser 5 Volt benötigt.

Um dennoch eine RTC zu implementieren gibt es Bausteine wie den DS1307 oder den besseren DS3231 (dieser hat einen eingebauten Temperatursensor der die temperaturabhängige Schwingungsfrequenz des Quarz ausgleichen kann und damit noch präziser arbeitet) der über die I2C Schnittstelle des Arduino (Arduino Pins SCL und SDA) angesprochen werden kann. Von der Arduino Community gibt es leider keine offizielle Library. Ich habe mich daher für die RTCLib von Adafruit entschieden, Sie bringt alle benötigten Funktionen mit und ist einfach einzusetzen. Man kann Sie direkt in der Arduino IDE über die Bibliotheksverwaltung (Strg + Umschalt + I) installieren. 

Der Aufbauplan:

Um die Funktionsweise zu verstehen habe ich das Beispiel → RTCLib → DS3231 von Adafruit betrachtet.

Daraus habe ich zwei Programme abgeleitet: Uhrzeit neu einstellen und anschließend am seriellen Monitor ausgeben (RTC_Einstellen) und nur die Uhrzeit betrachten (RTC_Auslesen).


4. Schrittmotor Ansteuerung:

Die Schrittmotor Ansteuerungsplatine wird folgendermaßen mit dem Board verbunden:

Das hier dargestellte Schrittmotor Board ist nur eine Skizze, das Erstellen von Fritzing Bauteilen ist leider sehr schwierig... (genauere Informationen auf der Hersteller Seite)

Die Analog In Pins des Arduino lassen sich auch als Digital Output nutzen. Daher der Anschluss auf den noch nicht belegten Pins A2 bis A5. Außerdem natürlich noch GND und Versorgungsspannung VCC + VM.

Zur Ansteuerung des Motors nutzen wir die Stepper.h Library.

Hier der Programmcode für ein einfaches Beispiel → Schrittmotor_1.0_Test

Probleme hat das richtige Verkabeln des Motors gemacht. Allerdings hat das Stepper Driver Board LED's welche genau anzeigen welcher Ausgang beziehungsweise Phase gerade geschalten wird. Wenn man die Motor Geschwindigkeit entsprechend langsam einstellt erkennt man die Reihenfolge. Daher bin ich darauf gekommen, dass erst A5, dann A3, A4, A2 der Reihe nach geschalten werden muss.

Als ich mich an die Arbeit mache den Schrittmotor in das Hauptprogramm einzubauen → Master_1.6_SchrittmotorVersion (nicht funktionsfähig), stelle ich fest dass es einige Dinge verkompliziert und nicht so leicht umzusetzen ist wie Anfangs gedacht. Daher eine Vor- und Nachteil Liste um das weitere Vorgehen zu überdenken und anzupassen:

ServomotorSchrittmotor

+ Ist leichter zu steuern, da der Servo eine integrierte Positionsüberwachung hat. servo.write() stellt den Servo auf eine fest definierte Position.

+ Es ist theoretisch kein Endschalter nötig, aufgrund des oben genannten Vorteil, dass die Position fest definiert werden kann.


+ Nach einem Stromausfall oder Reboot kann das Programm direkt weiterlaufen, ohne dass man Gefahr läuft dass der Servo etwas zerstört.


+ Der Programmiertechnische Aufwand zur Steuerung ist sehr gering: servo.write(Auf) und servo.write(Zu)

+ Der Servo hat eine sehr hohe Beschleunigung und wird im Stillstand praktisch nicht warm.

+ Das Drehmoment ist nicht so hoch wie vergleichbar große Schrittmotoren, allerdings hat allein dieser mit 5 Volt betriebene Servo 20 Kilogramm auf einen Zentimeter und ist dadurch für unsere Anforderungen mehr als ausreichend. Damit lassen sich auch schwerere Mechanismen durchaus bedienen.

- Braucht eine Absicherung gegen Blockierung, ansonsten besteht Gefahr des Durchbrennens. → Ein Endschalter in Schließrichtung, falls es zu einer Verklemmung kommt. (Konstruktion ist so gebaut, dass man immer aufsperren kann.)

- Positionseinstellung komplizierter, da man nur Anweisungen geben kann in der Form: "Gehe 1000 Schritte nach links oder gehe 500 Schritte nach rechts"

- Man braucht mindestens einen, eher 2 Endschalter um die Position nach einem Reset wieder definieren zu können und um sicher zu stellen, dass der Motor nicht überdreht und dabei etwas zerstört.

- Das Programm muss abgesichert werden, indem nach einem Stromausfall der Schrittmotor erst wieder zu einer definierten Position (Endschalter) gefahren wird, ansonsten läuft man Gefahr dass der Motor etwas zerstört. Dabei kann die Klappe unkontrolliert auf- und zugesperrt werden.

- Aufgrund den oben genannten Faktoren muss man Endschalter Abfragen in jede Steuerungsmaßnahme mit einbauen

- Der Schrittmotor hat eine schlechtere Beschleunigung und wird wegen dem dauerhaft fließenden Strom in den Spulen im Stillstand warm (ohne Leerlaufstromabsenkung sogar durchaus heiß).

+ Höheres Drehmoment als vergleichbar große Servomotoren.

+ / - Schrittmotoren bleiben bei Blockierung, das heißt Überschreitung des maximal möglichen Drehmoments einfach stehen und können nicht durchbrennen. Allerdings reicht selbst kleineres Drehmoment aus, um viel an einem Schließmechanismus zerstören zu können bevor er blockiert, daher nur bedingt ein Vorteil.

Der Servomotor ist also ganz klar der geeignete Motor für das Projekt. Den Programmcode für die Schrittmotor Version werde ich auf Eis legen. Falls wirklich das Drehmoment des Servos nicht ausreicht, kann die Entwicklung weiter vorangetrieben werden.


5. Das Hauptprogramm:

  • Version 1.0: Die void setup() der Unterprogramme werden zusammengeführt und getestet ob es zu Problemen kommt, → Master_1.0_WS_RTC


  • Version 1.1: Hier wird die Auswahlmöglichkeit manuelle oder automatische Steuerung eingefügt und ein erster Test für den Wochentag Sonntag und Montag eingefügt. → Master_1.1_Timing


Problem an dieser Stelle: Durch die immer mehr werdenden serial.print() wird sehr viel SRAM verschwendet, dieser kann mit serial.print(F()) in den Flash Speicher geschrieben werden. Das hat keine Nachteile und spart SRAM, welcher sehr wichtig für die korrekte Ausführung des Programms ist. (Quelle: https://www.arduino.cc/en/tutorial/memory)


  • Version 1.3: Hier wird eine Statusüberwachung eingebaut, die den aktuellen Zustand welchen die Automatik schalten würde anzeigt, da ich im Langzeittest feststelle, dass die Automatik nicht richtig funktioniert. Außerdem ist diese Funktion natürlich auch für den Nutzer praktisch, da er weiß was passiert wenn er die Automatik aktiviert.

Die Web Oberfläche sieht nun so aus (ganz normales HTML):


  • Version 1.4: Hier wird eine Sicherheitsfunktion implementiert, die ich zwar schon geplant hatte aber dann übersehen habe. Es ist natürlich notwendig, dass der Servo nur schließen darf, wenn die Klappe auch wirklich zu ist. Dafür kommt noch ein neuer Sensor dazu, der "SensorServo", welcher den geschlossenen Endzustand des Servos überwacht. Dieser "SensorServo" übernimmt nun die Aufgabe des ehemaligen "SensorKlappe". Er gibt aus, ob die Klappe wirklich abgeschlossen ist und zeigt dies am WebServer an. Der neue "SensorKlappe" überprüft ob die Klappe geschlossen ist und wird als if-Bedingung vor jede Servoaktion geschaltet. Das heißt der Servo schließt die Klappe nur ab, wenn die Klappe geschlossen ist. → Master_1.4_Troubleshoot


  • Version 1.5: Hier wird ein Problem behoben: Seit Version 1.4 wird der Zustand der Klappe (geschlossen) nicht mehr richtig angezeigt. Ich überprüfe alle Bestandteile des Programms und da ich den Fehler nicht finden kann, baue ich einen serial.println(SensorKlappe); ein. Dieser verrät mir, dass der Eingang nicht auf äußere Beschaltung, egal welcher Art, reagiert. Bei Überprüfung des Pins stelle ich fest, dass Pin 4 vom Ethernet Shield (zu finden unter Tech Specs) benötigt wird und daher belegt ist. Ich ändere den Anschluss auf Pin 8. → Master_1.5_Troubleshoot

Außerdem steckt in dieser Version ein Fehler der sich bis Version 2.1 durchzieht. Durch die doppelte Verwendung der Variable "Zu" funktioniert der Servo nicht mehr. Ein "Zu" wird daher am 06.02.2020 durch "Safe" ersetzt und damit funktioniert der Servo wieder einwandfrei. → Siehe Troubleshot vom 06.02.2020


  • Version 1.6: Hier sollte eigentlich eine Schrittmotor Version entwickelt werden, dieses Vorhaben wurde auf Eis gelegt, aufgrund in obiger Tabelle (siehe Kapitel 4. Schrittmotor Ansteuerung) genannter Nachteile. → Master_1.6_SchrittmotorVersion (nicht funktionsfähig, keine Weiterentwicklung!)


  • Langzeittest mit Version 1.5: Ich stelle fest, dass die Automatik nicht vernünftig funktioniert. Wenn man von dem manuellen in den automatischen Modus wechselt wird zu bestimmten Uhrzeiten die Klappe nicht mehr geöffnet. Das liegt daran dass in Version 1.5 nur die Öffnungs- und Schließzeit definiert sind, nicht aber alle Uhrzeiten die dazwischen liegen. Daher muss der Automatik Modus umgebaut werden.


  • Version 2.0: Ich habe die Automatik nun wie folgt umgebaut: Da die Klappe die meiste Zeit offen steht, wird eine if-else Logik verwendet. If in den Stunden in denen die Klappe geschlossen sein soll, else ist die Klappe offen. → Master_2.0_Langzeittest


  • Version 2.1: Hier wird noch ein Feature integriert, dass alle Einwürfe seit dem letzten Neustart des Systems zählt. → Master_2.1_Z_hlerneu


  • Version 2.2: Hier werden diverse Features hinzugefügt, Optimierungen durchgeführt und Probleme behoben, genauere Informationen im Programmcode. → Master_2.2_Verbesserungen


  • Version 2.3: Hier wird der große Servomotor angesteuert. Dazu ist ein externes Netzteil notwendig, welches direkt mit dem Servo verbunden wird. Ich habe mich für ein 5 Volt Netzteil entschieden, welches mit 3 Ampere auf jeden Fall ausreichend Leistung liefert. Mit dem im Netzteil integrierten Potentiometer kann man die Spannung um +- 10 % verstellen. Ich habe diese auf 5,2 Volt eingestellt und ist damit optimal für den Servo und noch in der Toleranz für den Eingang des Arduino. Die minimale und maximale Ansteuerungsfrequenz des Servo muss ebenfalls im Programmcode eingetragen werden. Außerdem werden noch einige Abläufe verbessert, um beispielsweise den aktuellen Zustand der Klappe in Echtzeit an der LED sehen zu können. → Master_2.3_newServo

Der dazugehörige Aufbauplan:

  • Version 2.4: Diese Version ist nach dem designen der Platine entstanden (siehe weiter unten Dokumentation Hardware und Einbau unter Arduino Shield). Es werden Änderungen an der Pin-Belegung vorgenommen und es kommen ein Sensor und eine LED hinzu. Damit sind alle In- und Outputs des Arduino bis auf eine Reserve belegt. Außerdem wird ein kleiner Fehler im Entprell Mechanismus des Einwurfs im Code behoben. → Master_2.4_AnpassungHardware


  • Version 2.5: Hier wird nun das Servo auf- und zufahren als eigene Methode implementiert. Dies hat den großen Vorteil dass man sich einiges an doppeltem Code spart und nur eine Methode zum öffnen und schließen der Klappe aufrufen muss. In dieser wird dann auch gleich die Fehlerüberwachung integriert. Diese überprüft ob der Servo auch wirklich richtig auf und zugefahren ist und speichert eventuell auftretende Fehler ab. Dieser Fehlerspeicher wird erst nach einem Reset des Systems direkt am Einwurfkasten per Schalter gelöscht. → Master_2.5_Methoden

Der dazugehörige Aufbauplan:

  • Version 2.6: Die finale Version. Die Methoden welche in Version 2.5 implementiert wurden, werden ständig aufgerufen und verzögern dadurch den Programm Ablauf. Daher wird eine Abfrage eingebaut, ob die Methode ausgeführt werden muss. Die Methode wird dann nur ausgeführt wenn notwendig. Außerdem wurden diverse kleine Fehler ausgebessert die sich beim Abschlusstest im eingebauten Zustand ergeben haben. → Master_2.6_Final


Dokumentation ESP32 (optionale Information)

Der ESP32 wäre eine alternative zum Arduino UNO.

Vorteile:

  • Kleiner 
  • Günstiger in Anschaffung und Stromverbrauch
  • WLAN an Board (im Vergleich zum Standard UNO)
  • Wesentlich mehr Speicher und schnellere CPU
  • Lässt sich auch mit der Arduino IDE programmieren

Nachteile:

  • Viel komplexeres Board
  • Nicht so robust wie der Arduino
  • Schwerer zu Programmieren und Einzurichten
  • Keine vollständige Dokumentation


Ich wollte den ESP32 auf jeden Fall auf Grund oben genannter Vorteile testen.

Dazu muss man die Boardverwalter Library des Herstellers einbinden. Ich bin dabei dieser Anleitung gefolgt.

Man öffnet die Arduino IDE und drückt "Strg + Komma", anschließend kopiert man folgenden Link in die "Zusätzliche Boardverwalter-URLs": https://dl.espressif.com/dl/package_esp32_index.json

Anschließend öffnet man die Boardverwaltung:


Dort sucht man am Besten in der Suchleiste nach "ESP" und findet das "esp32" by "Espressif Systems". Das wird installiert um den ESP32 betreiben zu können.

Dann kann der ESP32 mit dem PC verbunden werden, unter Werkzeuge Board wird der ESP32 Dev Module ausgewählt und der entsprechende Port auf dem das Gerät angeschlossen ist.

Ich beginne rein interessehalber mit dem Beispiel → ESP32 → HallSensor, welches den integrierten Hall Sensor des ESP32 ausliest.

Falls der Upload nicht startet, muss man die Boot Taste des ESP32 gedrückt halten. → Funktionierte dann einwandfrei.

Der zweite Sketch den ich ausprobieren wollte war das Beispiel → WiFi → WiFiScan, welches die verfügbaren WLAN Netzwerke scannt. 

Hier kommt die Ernüchterung, der Upload war nicht mehr erfolgreich, da auf den gewählten Port kein Zugriff möglich ist. (Auch nach einem Neustart von PC und / oder ESP32 kein Erfolg)

Getestet habe ich mit 2 verschiedenen PC´s, bei beiden kam der gleiche Fehler. Auch ein Umstellen der Upload Parameter brachte keine Besserung.

Mein Entschluss: Der Arduino als der robuste und zuverlässige Mikrocontroller wird das Einwurfsystem steuern. Der ESP32 kann wenn noch Zeit bleibt ein weiteres mal getestet werden.


Dokumentation Raspberry Pi als Informationsdisplay

Die einfachste Möglichkeit aus dem Raspberry Pi ein Informationsdisplay zu machen ist es, den Chromium Browser mit einer fest definierten Startseite im Vollbildmodus zu starten. Möchte man den angezeigten Inhalt ändern, muss man die eingestellte Webseite ändern. Ein Beispiel dazu wäre folgendes Projekt. → Raspberry-Pi-3-Kiosk-Chromium-Autostart-im-Vollbildmodus-einrichten

Problem hierbei ist, dass immer nur eine Webseite angezeigt werden kann. Außerdem ist es nicht sehr anwenderfreundlich wenn man nur schnell eine Kleinigkeit ändern will, oder zu definierten Zeitpunkten gewisse Meldungen schalten will. Ich überlege mir Anforderungen an den Infoscreen:

  • Abwechselbare Darstellung von Webseiten, Bildern oder Videos.
  • Einfache Konfigurationsoberfläche auf der die Inhalte verwaltet werden können.
  • Zeitsteuerung, so dass gewisser Inhalt nur zu gewissen Zeiten angezeigt wird.
  • Autostart Funktion

Nach einiger Recherche finde ich diese Open-Source Software: Screenly OSE und das zugehörige GitHub Verzeichnis. Die Software bietet alle Anforderungen an den Infoscreen und ist dabei bis jetzt konkurrenzlos. Alternativen basieren alle überwiegend auf dem oben vorgestellten Prinzip, dass nur eine Webseite angezeigt werden kann, wie zum Beispiel FullPageOS. Eine Eigenentwicklung kommt aufgrund der erfüllten Anforderungen und der einfachen Konfiguration erst einmal nicht in Frage. Eventuell kann man sich, da die Software Open Source ist an der Entwicklung auf GitHub beteiligen oder gewisse Eigenschaften der Software bei Bedarf ändern.

Die Installation von Screenly OSE kann man sich sehr leicht machen, es ist nicht mehr nötig erst Raspbian zu installieren und anschließend Screenly OSE manuell einzurichten. Der automatische Installationsassistent NOOBS von der Raspberry Pi Foundation hat Screenly OSE auch im Angebot. Als ersten Schritt lädt man sich NOOBS Lite herunter und entzippt die Daten, welche man anschließend auf die Micro SD-Karte überträgt. Diese steckt man in den Raspberry Pi und verbindet ihn mit Maus, Tastatur, Bildschirm und einer USB Stromversorgung (5 Volt und für stabilen Betrieb mindestens 2 Ampere). 

Nach dem booten öffnet sich obiges Fenster in dem man den Raspberry mit einem W-Lan Netzwerk verbinden muss. Wichtig ist, dass man unten im Fenster das Tastaturlayout auf "de" umstellt, ansonsten kann es zu Fehlern beim Eingeben des W-Lan Schlüssels mit einer deutschen Tastatur kommen! Anschließend wählt man Screenly OSE an und bestätigt die Installation indem man oben auf "Installieren" klickt. Nachdem die Installation fertig gestellt wurde, bootet der Raspberry neu und zeigt die nächsten Anweisungen zum Einrichten des Netzwerks in Screenly OSE. Abschließend empfiehlt es sich einen Blick in die Router-Einstellungen Ihres Netzwerks zu werfen, um die IP-Adresse der Konfigurationsoberfläche herauszufinden und gegebenenfalls auf einen statischen Wert festzulegen. In meinem Fall 192.168.188.100.

Auf der zuvor festgelegten IP-Adresse kann man nun im Browser die Inhalte (Assets) des Infoscreens verwalten:

Genauere Informationen zur Bedienung des Programms sind hier zu finden.


Dokumentation Hardware und Einbau

Die Hardware To-Do's:

  • Demo Einwurfkasten
  • Gehäuse für die Hardware
  • Anschluss Shield (Platine) für den Arduino
  • Bestücken der Platine
  • Einbau


Verwendete Software: 


Demo Einwurfkasten:

Zusammenfassung: Der Demo Einwurfkasten soll die Funktionsfähigkeit des Projekts demonstrieren und wird in Autodesk Fusion 360 designed. Anschließend wird die Projektdatei mithilfe von Estlcam in G-Code umgewandelt und auf einer selbst konstruierten maschinengesteuerten Holzfräse ausgefräst. Der Aufbau wird verzahnt erfolgen, so dass es reicht die fertigen Teile nur noch mit Holzleim zusammenzukleben und trotzdem eine ausreichend stabile Konstruktion zu haben.

Als ersten Schritt wird mit Bleistift und Papier der Grundaufbau und die Funktionsweise skizziert, sowie eine etwaige Bemaßung des Ganzen aufgestellt, hier ein Teil der Skizzen:

Anschließend wird das ganze in Fusion360 in 2D umgesetzt. Als erstes ist hierbei der Kasten selbst entstanden, anschließend die Scharniere, dann das Gewicht für den Deckel + Führung des Verschlussmechanismus und zuletzt der Deckel:

            

Die Skizzen werden als .stl exportiert und in Estlcam geladen. Dort habe ich dann auch die Schriftzüge eingestellt und noch fehlende Löcher, wie zum Beispiel für die LEDs hinzugefügt. Außerdem wird das verwendete Werkzeug und die Dicke der Platte eingestellt. Man kann sich das ausfräsen nun simulieren lassen und wenn alles passt als G-Code exportieren. → Die Dateien: Demo-Kasten

Der G-Code wird dann in die Software der Fräse importiert und nachdem eine Holzplatte eingespannt und die Achsen auf Null gesetzt werden geht es los:

        Kurzes Fräs Video.mp4                

Die ausgefrästen Teile werden mit Holzleim verklebt. Der Deckel wird ein wenig abgeschliffen um ihn passend zu machen. Im Kasten selbst habe ich vierkant Holzleisten angeschraubt, auf denen der Deckel aufliegen und festgeschraubt werden kann.

Um ihn länger haltbar zu machen, habe ich den Kasten mit Klarlack lackiert (2 Teile Lack, 1 Teil Härter und ein kleines bisschen Verdünnung). Der Einbau der Hardware wird weiter unten unter "Einbau" beschrieben.


Gehäuse für die Hardware:

Zusammenfassung: Es sollen zwei Gehäuse entstehen: Eines für den Raspberry Pi und eines für den Arduino samt Ethernet- und Anschluss-Shield (aktuell nicht benötigt, da im Demo Kasten geschützt verbaut). Das ganze wird in Fusion 360 designed und mit Ultimaker Cura in 3D-Druckbaren G-Code umgewandelt. Der Code soll dann auf einem  modifizierten JG Aurora A5 Drucker ausgedruckt werden.

  • Das Gehäuse für den Raspberry Pi wird nicht selbst designed, da es keine speziellen Anpassungen erfordert. Daher habe ich habe mich für dieses Modell von Thingiverse entschieden. Es ist robust und kommt ohne Schrauben aus. Nach dem Download wird der Ordner entzippt und die Bottom.stl und Top.stl wird in die Ultimaker Cura Software geladen. Den Top Teil des Modells musste ich um 180 Grad rotieren, damit dieser richtig herum auf dem Druckbett liegt. Die anderen vorgenommenen Parameter sind eingeblendet.

Mit einem Klick auf "Sclice it" und anschließend "Save to file" kann der G-Code für den Drucker gespeichert werden. Dieser wird dann im Drucker gestartet.

  • Das Gehäuse für den Arduino habe ich aktuell noch nicht designet, da dieser im Demo Kasten optimal geschützt wird. Wenn der Bedarf besteht kann hier noch ein Gehäuse designet werden...


Anschluss Shield für den Arduino:

Zusammenfassung: Es soll ein Anschluss Shield (Platine) entstehen welches direkt auf das Ethernet Shield aufgesteckt werden kann. An diesem wird dann das Netzteil und alle In- und Outputs angeschlossen. Der erste Entwurf wird in Fritzing erfolgen. Um die Platine dann auch in G-Code exportieren zu können wird diese mit Target 3001! designed und auf einer selbstgebauten CNC Fräse ausgefräst. Die Platine wird abschließend bestückt.

Als erstes habe ich in Fritzing einen Schaltplan erstellt und auf Basis des Schaltplans dann das Platinenlayout erstellt. Dies sieht dann folgendermaßen aus:

          

Nachteil an Fritzing ist die fehlende Export Möglichkeit um einen Maschinencode (G-Code) zu erzeugen. Außerdem hat mich die noch nicht ausgereifte Bedienung des Programms nicht überzeugt. Es war nicht möglich die Platine exakt an meine Bedürfnisse anzupassen. Auch das Erzeugen der Massefläche hat nicht funktioniert, wie man am Platinenlayout oben sehen kann. 

Bei der Recherche nach einer professionellen Software stoße ich auf TARGET 3001!, diese ist für nicht kommerzielle Nutzung kostenfrei und vereinbart einfache Bedienung mit hohem Funktionsumfang. Außerdem kann man direkt G-Code erzeugen. Die Fritzing Vorlage wird überarbeitet: Die Anschluss Pins und Klemmen werden neu angeordnet. Alle vorhandenen Ein- und Ausgänge werden mit Schraubklemmen verbunden, um gegebenenfalls noch erweitern zu können.

           

Der Schaltplan, dann der erste Entwurf ohne Massefläche, dann mit Massefläche und als letztes die überarbeitete Version mit funktionierender Massefläche (das RTC Modul war nicht mit Masse verbunden) und kleineren Veränderungen. → Die Dateien: Platine

Der oberhalb verlinkte G-Code (.cnc) wird dann in die Fräsmaschine eingespielt, ein Platinenrohling eingespannt und die Nullpunkte der Achsen definiert. Das richtige Werkzeug muss dann zum richtigen Zeitpunkt, wie in der .txt Datei beschrieben, eingespannt werden.

                    Platinenherstellung.MOV

Die Steuerungssoftware der Maschine, die Fertigung, die fertige Platine und die mit der Flex abgeschliffene Rückseite der Platine.Außerdem noch ein Video der Maschine wie die Löcher der Platine gebohrt werden.

Die fertige Platine wird anschließend bestückt. Für die Verbindung zum Arduino habe ich diese speziellen Anschlusspins verwendet. Alle anderen Bauteile sind Standardbauteile.

         

Der Lötarbeitsplatz und die fertig bestückte Platine von oben, unten und von der Seite.

Die Löcher müssen bei Bedarf noch etwas aufgebohrt werden. Das Shield passt optimal auf den Arduino und auch die Befestigungslöcher können ganz normal verwendet werden. Für den RTC32 wurde noch ein Gewinde in die Platine geschnitten, um diesen zu befestigen, siehe letztes Bild. Festgestelltes Manko ist der überflüssige Sensor VCC, dieser wird nicht benötigt und an seiner Stelle wäre eine zweite Masse wesentlich sinnvoller gewesen.


Einbau:

Zusammenfassung: Die gesamte Hardware wird in den Demo Kasten eingebaut und verkabelt. Abschließend findet eine genaue Funktionsüberprüfung statt.

Es müssen einige Vorüberlegungen getroffen werden, bevor man den Kasten plant und die Hardware einbaut.

Der Schließmechanismus war zu erst auf der linken Seite direkt neben der Klappe geplant, der Servo hätte dann einfach mit einem länglichen Aufsatz die Klappe blockiert. Diese Idee wurde aber verworfen, da an dieser Position zu wenig Platz ist und der Endanschlag nicht überwacht werden kann. Es war auch ursprünglich nur ein Endanschlag geplant, welcher den Schließvorgang überwacht. Um die Sicherheit zu erhöhen habe ich mich für zwei Lichtschranken entschieden, die genau so groß sind, dass der Servoaufsatz in die Gabel der Lichtschranke einfahren kann.

Der Servoarm wurde aufgebohrt um einen Gabelkopf (aus dem Modellbau) daran befestigen zu können, an diesem wird eine Stange (Fischertechnik) angeschraubt. Die Verbindungs Gewindestange ist eine normale Schraube, bei der der Kopf abgesägt wurde. Die Stange wird am oberen Ende mit der Flex vorsichtig aufgeschnitten, um ein Blech mit X60 Klebstoff einzukleben. Dieses wird aufgebohrt, um den oberen Kabelkopf befestigen zu können. Der obere Kabelkopf ist ein in Schraubstock umgebogenes Blech, welcher in die obere Stange eingeschraubt ist. Die obere Stange verschließt die Klappe. Um das Risiko einer fehlerhaften Schließung zu minimieren wurde das obere Holzstück konisch gebohrt (siehe Bild 3). Die Gewinde sind M3 und die verwendeten Schrauben in den Gelenken haben in der Mitte kein Gewinde, um das Gelenk nicht zu beschädigen. Außerdem kann man deshalb die Schrauben auch gut festziehen, ohne dass das Gelenk seine Funktion verliert. Als Muttern kommen Stoppmuttern zum Einsatz, damit die Gelenke nicht aufgehen mit der Zeit. Die Blechplatten wurden zum Schutz gegen Rost mit Felgenlack lackiert. Die Kugel welche als Gewicht montiert ist, um die Klappe auch wirklich vollständig zufallen zu lassen, ist aus einem homokinetischen Gleichlaufgelenk.

         


Die Schalter im Deckel habe ich mit Drähten parallel verbunden und anschließend zwei ausreichend lange Kabel angelötet. Alle LED`s und Taster wurden mit Kabel verbunden und anschließend mit Schrumpfschläuchen isoliert. Der Arduino wurde in der linken Seite am Boden festgeschraubt, das Netzteil wurde von rechts außen mit einer Schraube angeschraubt.

Eine Herausforderung waren die Lichtschranken, da hier die Belegung der Kabel nicht bekannt war. (Die Lichtschranken habe ich vor einiger Zeit aus einer Medikamentendosiermaschine ausgebaut.) Ich bin nach der Anleitung aus diesem Video vorgegangen, um die richtige Anschlussweise herauszufinden. Dabei habe ich herausgefunden: Schwarz ist Masse für beide Seiten, Braun die LED und Weiß die Photodiode. Als Widerstand zur Vorschaltung für beide Lichtschranken habe ich 165 Ohm verwendet. Beim Ausmessen des richtigen Vorwiderstand benötigt eine Lichtschranke 330 Ohm. Da nun beide Lichtschranken parallel geschaltet sind, halbiert sich das auf 165 Ohm. Den Widerstand habe ich unter einen Schrumpfschlauch direkt in das Kabel eingelötet. Bei der Planung der Platine war die Verwendung der Lichtschranken noch nicht klar, sonst hätte man den Widerstand auf dieser noch hinzufügen können.

         


Nachdem 230 Volt am Netzteil angeschlossen das Netzwerkkabel verbunden ist muss die Software noch angepasst werden. Die "Auf" und "Zu" Positionen des Servo werden eingestellt und die letzten Bugs die sich bei der Funktionsprüfung ergeben haben gefixt, siehe Master Version 2.6.


Kurze Funktionserklärung und Bedienungsanleitung

Um das Gerät in Betrieb zu nehmen, muss das Stromkabel und das Netzwerkkabel verbunden werden. 

Gegebenenfalls muss die IP-Adresse im Programmcode auf das Netzwerk angepasst und neu hochgeladen werden (dazu muss der Deckel abgeschraubt und ein USB Kabel angeschlossen werden). Die Web Oberfläche kann dann unter der zuvor festgelegten IP-Adresse gefunden werden:



         

Bild 1 zeigt die Grundeinstellung des Programms: Der Automatikmodus. Bild 2 zeigt die manuelle Steuerung: Klappe manuell zu. Und Bild 3 illustriert die Funktion des Einwurfzählers und der dazugehörigen Reset Schaltfläche. Bild 4 zeigt die Seite des Geräts.


  • Ganz oben wird die Zeit der letzten Aktualisierung der Webseite ausgegeben.
  • Den aktuellen Status kann man über die Schaltfäche "Aktualisieren" erfahren. Diese muss auch nach jeder Aktion geklickt werden, beispielsweise nach dem Wechsel auf manuelle Steuerung oder dem Reset des Zählers.
  • Falls ein Fehler auftritt wird dieser unterhalb des aktuellen Status eingeblendet ("Es ist ein Fehler im Schliessmechanismus aufgetreten, bitte ueberpruefen und das System anschliessend am Geraet per Schalter resetten!") → siehe Reset System weiter unten
  • Im Automatikmodus wird die Klappe selbstständig zu den im Programmcode festgelegten Zeiten geöffnet und geschlossen. (Öffnen oder Schließen erfolgt erst dann wenn die Klappe nicht aufgeklappt ist.)
  • Wechselt man in den manuellen Modus (1 x Aktualisieren nicht vergessen) kann man die Klappe manuell öffnen oder schließen, diese öffnet und schließt aber nur wenn die Klappe gerade nicht aufgeklappt ist.
  • Der Status Automatikmodus gibt aus in welchem Zustand die Klappe wäre, wenn der Automatische Modus aktiv ist. Dies hilft um im manuellen Modus entscheiden zu können ob die Automatik schon wieder aktiviert werden soll.
  • Der Status aktuell gibt den aktuellen Zustand der Klappe basierend auf den beiden Lichtschranken Sensoren aus. (Aktualisieren nicht vergessen)
  • Eingeworfene Gegenstände gibt die Anzahl der eingeworfenen Gegenstände seit dem letzten Reset über die Schaltfläche Reset oder dem Taster an der Seite des Geräts aus.
  • Letzter Systemneustart zeigt einem die Laufzeit des Geräts und dadurch eventuelle Abstürze an und gibt die Anzahl der insgesamt eingeworfenen Gegenstände aus.
  • Systemtemperatur zeigt die Temperatur im inneren des Geräts an (gemessen vom RTC Baustein).


  • Reset System lässt den Programmcode auf dem Arduino neu starten, die LED links daneben leuchtet sollte ein schwerer Fehler im Schließmechanismus aufgetreten sein (Servo nach einer Sekunde nicht in der richtigen Position). In diesem Fall das Gehäuse aufschrauben und genau überprüfen ob alles in Ordnung ist.)
  • Reset Einwurf hat die gleiche Funktion wie "Reset des Zählers" in der Web Oberfläche. Sie dient dazu beim Ausleeren des Kastens vor Ort den Einwurfzähler zurück zu setzen.
  • Auto Zustand: Leuchtet orange wenn die automatische Steuerung die Klappe öffnen würde
  • Auto I/O: Leuchtet orange wenn die Automatische Steuerung aktiv ist
  • Die LED auf der Vorderseite des Geräts leuchtet rot wenn die Klappe geschlossen ist


Verbesserungen für die Zukunft

  • Automatisches Aktualisieren der Web Oberfläche
  • Schöneres Design für die Web Oberfläche
  • Zusammenführen der Web Oberflächen von Raspberry Pi und Arduino
  • Platine mit einem Masseanschluss mehr, dafür ein VCC weniger


Konzept

Als Hardware zur Realisierung der grundlegenden Funktionalität werde ich einerseits den Microcontroller Arduino UNO einsetzen. Dieser ist vorteilhaft da die Software Quelloffen und das System vollständig dokumentiert ist. Außerdem ist dieser günstig in der Anschaffung.

Dieser soll:

  • Die Sensoren / Schalter auslesen
    • Manuelles Entriegeln, Zustand der Einwurf Klappe (offen, geschlossen), Anzahl eingeworfener Objekte, … --> Liste soll je nach Anforderung nach Möglichkeit erweiterbar sein
    • Bei den Sensoren wäre je nach Anforderung ein induktiver- oder kapazitiver Sensor oder eine Lichtschranke denkbar.
  • Einen Servomotor / Schrittmotor zum Verschluss der Klappe ansteuern
  • Über ein Netzwerk Modul einen Webserver bereitstellen auf welchem die Klappe geöffnet und verriegelt werden kann, sowie die gesammelten Informationen / Fehlermeldungen eingesehen werden können.

Leider kann man mit dem Arduino UNO nur ein LCD mit 2 Zeilen und jeweils 16 Zeichen ansteuern. Für ein 7 Zoll LCD (was immer noch nicht sehr groß ist) bräuchte man einen Arduino Mega, welcher mehr Ein- und Ausgänge bereitstellt.


Daher mein Entschluss das Informationsdisplay als optionale Komponente mithilfe eines Raspberry Pi umzusetzen. Der Raspberry ist ein Einplatinencomputer in Kreditkartengröße und soll auf einer angepassten Linux Distribution laufen. Im Gegensatz zum Arduino haben wir mit diesem die Möglichkeit komplexere graphische Darstellungen in HD-Auflösung auf einem beliebigem (TFT) Display darzustellen.


  • Nachteil an dieser Art des Aufbaus ist, dass der Besitzer des Einwurfsystems zwei getrennte Webinterfaces hat. (Steuerung und Status, Informationsdisplay) Eine zukünftige Verbesserung könnte hier das Zusammenführen beider Systeme sein.


Als Aktor wird entweder ein Servomotor oder um das ganze universell und in verschiedenen Größenordnungen zu realisieren ein Schrittmotor mit Ansteuerungsplatine verwendet. Kombiniert mit einem Sensor (eventuell Lichtschranke) werden die Endanschläge überwacht und bei eventuellem Fehler (Klappe konnte nicht geschlossen werden) der Besitzer benachrichtigt.


Um das ganze System gegen Umwelteinflüsse zu schützen und den Einbau universal möglich sowie einfach zu gestalten, werde ich ein Gehäuse oder ggf. mehrere Gehäuse designen, in denen die Hardware Platz findet. Diese sollen mit einem 3D-Drucker druckbar sein. Außerdem, wenn die Zeit reicht, möchte ich eine Anschlussplatine designen, an der die Sensoren und Aktoren mit Schraubklemmblöcken anschließbar sind.


Dateien

Konzept:


Arbeitsplan der Ingenieurspraxis:


Abschlusspräsentation:


  • No labels