Sonntag, 16. August 2020

Analog Digital Wandler ADS1115 einlesen (Meadow)

Meistens, wenn ich ein Modul finde, das ich noch nicht kenne, dann existiert bereits eine Bibliothek, die in C/C++ geschrieben ist.

Schaut man im .NET Umfeld, dann ist wiederum meistens nichts zu finden. Damit ist mein Interesse geweckt, etwas darüber zu schreiben und natürlich ein Beispiel-Code hier auf meinem Blog zu veröffentlichen.

Seit fast einem Jahr liegt bei mir der Meadow und läuft aktuell mit dem Beispielprogramm. Dieser Controller zielt auf ‚Internet of Things‘- Themen ab und ist der direkte Nachfolger vom Netduino. Im Gegensatz zu dem Netduino, kann mit dem Meadow in der aktuellen C# (8.0) und .NET Framework (4.7.3) Version geschrieben werden. Dies bedeutet auch, dass gegenüber dem veraltetem .NET Micro Framework vieles neu aufgebaut wurde und folglich neue Lösungen geschrieben werden können.

 Benötigt:

  • Meadow
  • Breadboard
  • Jumper Leitungen
  • Potentiometer (oder alternative ein Widerstand und ein Lichtempfindlicher Widerstand)
  • ADS1115

 

Kurzes über den AD Wandler

Bevor ich mit der Zielbeschreibung loslege, müssen einige Details zu dem AD Wandler genannt werden. Beispielsweise, wie hoch darf die Eingangsspannung sein, die auf den vier Eingängen angelegt wird?

Betriebsspannung (VDD)

2V bis 5,5V

Stromaufnahme (Continuous Mode)

150uA

Industrieschnittstelle

I²C

Adresse

0x48 (Kann geändert werden durch Pin Select)

Eingänge

4

Abtastrate

8 bis 860

Eingangsspannung

-0,3V bis +0,3V über der Betriebsspannung (VDD)

Eingangsstrom

10mA bei fortlaufender Messung, 100mA bei einzel Messung

Für manche Anwendung ist auch die Betriebstemperatur wichtig, die hier von -40°C bis +125°C sein darf.


Anforderung

An einem Potitiometer soll die anliegende Teilspannungshöhe geändert werden. Die abgeleitete Teilspannung soll am Eingang A0 eingehen. Über einen Methoden Aufruf soll der Eingang eingelesen und dessen Wert über die Output Konsole ausgegeben werden.

 

Schaltungsaufbau

Im folgendem Bild ist zu sehen, dass ich kein Potitiometer verwende (schlichtweg, weil ich keinen hatte). Alternativ verwende ich einen 10k Ohm Widerstand und einen üblichen Lichtempfindlichen Widerstand (Lichtsensor 30 - 90 KOhm).


Verwenden von bestehenden Informationen

Zuerst wollte ich den bestehenden C++ Code migrieren nach C# und .NET Framework. Das bedeutet im Grunde, dass ich die Methodennamen und die #define Direktiven mit dessen Biteinstellungen (HEX Werte) direkt übernehme. Aber nach und nach stellte ich fest, dass einige Inhalte sich auf andere Module wiederum bezogen und ich immer wieder im Datenblatt nach sehen musste, was eigentlich die einzelne Biteinstellung für das Modul bedeutet. Ein Beispiel ist die Standard Einstellung 128SPS (Samples per second) für den ADS1115 Modul, aber im Adafruit Code steht etwas von 1600SPS.

Das Gute daran ist, man erarbeitet sich selbst eine Lösung, wie die Einstellungen abgebildet werden. Das macht den Aufbau der Klasse einfacher und die Beschreibungen zielgenauer.


Programm code

Im folgenden Beispiel aus dem ‚SimpleCode‘-Branch wurde nur das übernommen, was den Standard- Einstellungen entsprach. Z.B. Bitstellungen, die mit 0 belegt sind (bzw. in HEX 0x00 Wert) mussten nicht sein, da das Anlegen der Konfiguration immer mit 0 beginnt. Der folgende Code ist aus der Klasse ‚SimpleAds1115‘ und hat für den Abruf eine öffentliche Methode ‚ReadSingleInputValue‘ zum Abruf der anliegenden Spannung. Die Parameter-Eingabe bestimmt, welcher Eingang gelesen wird.

 internal class SimpleAds1115 : App<F7Micro, SimpleAds1115>  
 {  
   private readonly II2cPeripheral _i2CPeripheral;  
   public SimpleAds1115()  
   {  
     var i2CBus = Device.CreateI2cBus();  
     this._i2CPeripheral = new I2cPeripheral(i2CBus, 0x48);  
   }  
   internal ushort ReadSingleInputValue(AdsInput input)  
   {  
     // disable the comparator  
     // Single-shot mode (default)  
     // Operational status/single-shot conversion start  
     // - Begin a single conversion  
     ushort config = 0x8103;  
     config |= (ushort)input;  
     byte[] data = new byte[] { (byte)(config >> 8), (byte)(config & 0xff) };  
     this._i2CPeripheral.WriteRegisters(0x01, data);  
     Thread.Sleep(9);  
     var result = this._i2CPeripheral.ReadRegisters(0x00, 2);  
     return (ushort)((result[0] << 8) | result[1]);  
   }  
 }  

Vollumfänglich wird später die Klasse ‚Ads1115‘, die zu dem jetzigen Zeitpunkt nicht fertig ist.


Auf den Meadow schreiben

Sobald die Anwendung über Deploy auf dem Meadow geschrieben wurde, kann über das Fenster 'Output' das Ergebnis der anliegenden Spannung gelesen werden. Mit der Static Methode ‚GetVoltage‘ wird der gelesene Wert umgerechnet in Volt. Den Wert 22610 entnahm ich bei einem Eingangssignal von 5V. An der Stelle könnt Ihr den zu kalibrierenden Wert ersetzen, wenn bei Euch mit 5V ein anderer Wert gemessen wird.

 


Vorsicht mit der maximalen Eingangsspannung

In Standard Einstellungen sind die Eingänge bis 6,144V. Bei dieser Einstellung sollte nicht mehr als 0,3V anliegen, weil dies zur einer Beschädigung des Moduls führen könnte.


Fazit

Zunächst das Offensichtliche:  wenn das eigene Projekt mehr Analog-Digital Wandler benötigt, dann ist dieses Modul genau richtig. In einem I²C Bus können bis zu vier Module adressiert werden. Doch dieses Modul hat noch weitere Funktionen, um sich auf die Bedingungen eines Projektes besser anzupassen. Die Eingänge können auf gezielte Maximal-Spannungen eingestellt werden. Die Anzahl der Messungen pro Sekunde gehen bis zu 860SPS (Samples per second). Die vier Eingänge werden durch ein Multiplex Funktion angesprochen, so das von vier Eingänge auf zwei Eingänge umgestellt werden kann. Mit dem einstellbaren Komparator kann auf spezifische Bedingung reagiert werden.

 

Meadow Code
Github – ExampleAds1115 (SimpleCode Branch)

Mittwoch, 24. Juni 2020

RC Fahrtenregler für Lego Kettenfahrzeug



 

Auf dem Markt gibt es viele verschiedene Module an Motortreibern. Diesmal verwende ich einen recht einfachen, der zur Ansteuerung bis zu vier PWM Signale verwendet. Der Motorschield für den Arduino hingegen benötigt noch eine Steuerung eines Shiftregister 74HC595. Ich weiß, das geht auch ohne, aber ich beziehe mich diesmal auf fertige Module, die kompakt aufgebaut sind.

Aber nur ansteuern wäre diesmal zu langweilig und daher habe ich hier als Ziel, den Lego Technic Stunt-Racer damit zu betreiben. Wer das Modell kennt, weiß, dass dieser mit einer Infrarot Fernbedienung ausgeliefert wird und das eher nur in der Wohnung funktioniert.

 

Benötigt wird:

Modul MX1508 (DC Motor Treiber)

Arduino Mini Pro (5V Ausführung)

2x Servo Kabel

2x Lego Power Function Verlängerungskabel

Lego Technic Fahrzeug mit Power Function

Zwei Kanal Fernsteuerung und ein Empfänger mit PWM Signal Ausgängen.

 

Betrieb mit Funk-Fernsteuerung

Der Microcontroller soll zwei PWM Signale verarbeiten, so das damit zwei Motoren gesteuert werden können. Als Fernsteuerung soll links der Stick für die Geschwindigkeit sein und rechts der Stick für das Lenken. Also wie bei jedem anderen RC Auto.

 

Pin Belegung Power Function Kabel

Für die Umsetzung reicht es zu wissen, welche Leitung von den vier was ist. Bei der Suche war immer die Beschriftung 9V, 0V, C1 und C2 gegeben, weshalb ich das ebenfalls übernehme.

 

 

Für den nächsten Schritt müssen die beiden Power Function Kabel so abgeschnitten werden, dass die Verbindung für das eigene Projekt passen.

 

Motor Treiber MX1508

Den verwendeten Motor Treiber MX1508 findet man fälschlicherweise auch unter L298N. Der Motor Treiber L298N funktioniert ebenfalls für dieses Vorhaben, ist allerdings etwas übertrieben und ist auch eher was für größere Projekte geeignet.

 

Daten:

Betriebsspannung 2V bis 10V

Signal Spannung für IN1 bis IN4 1,8V bis 5V

Ausgangspannung für Motor-A und Motor-B 2V bis 10V

Betriebsstrom 1,5A

Maximaler Kurzstrom 2,5A

 

 

 

Aufbau der Schaltung

Der folgende Schaltplan zeigt, wie die Power Function Kabeln mit dem Motortreiber verbunden werden. Die Schaltung funktioniert auch mit einem Lipo Akku. Daher kommt neben dem Power Function Stecker noch ein JST Anschluss. Der Arduino Mini Pro wird über die Spannungsversorgung mitbetrieben und über den Pin RAW angeschlossen.

 

 

 

Der fertige Motortreiber

Anders als auf dem Bild zuvor habe ich noch einen weiteren Anschluss für die Spannungsversorgung angebracht. Das Ermöglicht auch zwei Zellen Lipo Akkus zu verwendend, anstatt der Lego Powerfunction Battery Box. Links auf dem Bild sind vier Leitungen mit Steckern, die für den Anschluss eines Empfängers da sind.

 



Programmcode einstellen

Diesmal beschreibe ich nicht den Aufbau des Programmcode, sondern gehe auf einen fertigen Motortreiber von mir ein. Für das Zielprojekt soll die Eingabe der Fernsteuerung links für die Geschwindigkeitsregelung sein und rechts das Lenken. Also ganz klassisch. Natürlich ginge auch eine Steuerung, wie sie bereits von Lego Power Function mit der Infrarot Fernbediendung vorgegeben wird.

 

Einstellung für den Lego Technic Stunt-Racer

 // Set this value true, for show all Value on Serial Monitor.  
 bool mSerialMonitor = false;        
 // 0 = Car, Input 1 for speed and input 2 for steer  
 //  - Alternate: Tracked vehicle, Input 1 for speed motor A and   
 //         Input 2 for speed motor B  
 // 1 = Tracked vehicle, Input 1 for speed and input 2 for steer  
 int mVehicleMode = 1;           
 // invert steering direction, only tracked vehicle   
 boolean mVehicleModeSteerInvert = false;  
 // Tolerance range in which no reaction should take   
 // place when sticks are in the middle position.  
 int mDeathbandPlusMinus = 10;       
 // change direction signal output for motor A  
 boolean mReverseA = true;  
 // middel state of the input signal. Example: stick on neutral position  
 int mInputMiddleA = 1500;  
 // minimum value of input signal. Example: stick is move complete down  
 int mInputMinA = 1000;  
 // minimum value of input signal. Example: stick is move complete up  
 int mInputMaxA = 2000;  
 // change direaction sinal output for motor B  
 boolean mReverseB = false;  
 // middel state of the input signal. Example: stick on neutral position  
 int mInputMiddleB = 1500;  
 // minimum value of input signal. Example: stick is move complete down  
 int mInputMinB = 1000;  
 // minimum value of input signal. Example: stick is move complete up  
 int mInputMaxB = 2000; 

 

 

Lego Technic Stunt-Racer Umbau

Damit der Empfänger und der Motor Treiber nicht einfach so rum hängen, sollte der Aufbau etwas geändert werden. Der Lego Technic Infrarot Empfänger wird entfernt. Wie nun der Umbau aussieht, ist zweitrangig, Hauptsache die Elektronik ist gut verstaut. Der folgende Umbau ist ein Beispiel.

 


   
 
   
   
   
   

 

Wort zum Schluss

Die Motoren lassen sich noch mit einer höheren Spannung betreiben. Allerdings steigt dann auch die Belastung der Lego Teile in Form von Verschleiß, wegen der fehlenden Kugellager.

Dann noch der hier verwendete Motor Treiber MX1508: Wegen einer falsch ausgewiesenen Information zu L298N, dachte ich zunächst, dass eine höhere Spannung möglich sei. Nach dem ich später für den Blog Eintrag mehr Informationen über den verwendete Komponente suchte, stieß ich auf die richtigen Werte. Zugegeben, ich hatte bereits mit der Fehlinformation den Aufbau mit einem 3S Akku betrieben. Allerdings nur kurz. Für den Betrieb mit einer hören Spannung würde dann der Motor Treiber L293D gehen, aber dann könnten Probleme mit dem maximalen Strom geben, wenn XL-Motoren verwendet werden.

 

Arduino Code - Motortreiber für MX1508

Github - Powerfunction-MotorDriver

 


Montag, 8. Juni 2020

Mit Remote-Atom auf Raspberry pi entwickeln

 

Visual Studio Code läuft auf dem Raspberry Pi nicht sonderlich gut, geschweige denn stabil. Auf dem Betriebssystem Raspbian sind noch die vorinstallierten Interpreter, aber die reichen nur für kleine Sachen.

Bei der Suche im Internet stieß ich auf die Möglichkeit, dass man per Remote den Code entwickeln kann, also am PC schreibt und die Ziel Codedatei auf dem Raspberry Pi bearbeitet.

 

Benötigt:

 

Ziel "Run my edit code"

Am PC soll eine Code Datei bearbeitet werden, die sich auf dem Raspberry Pi befindet. Der Programmcode soll traditionell ein "Hello World" werden und soll dann auch auf dem Raspberry Pi ein "Hello World!" über die Konsole anzeigen.

 

Installation Atom

Herunterladen und installieren. Im Anschluss wird das Paket "Remote-Atom" benötigt.

 


 


SSH Remote und Tunnel einstellen

Bevor auf den Raspberry die Code Remote Verbindung eingerichtet wird, muss die Verbindung per SSH hergestellt werden. Allerdings reicht die einfache SSH Verbindung mit Putty nicht aus, denn für die Verbindung ist die Einstellung eines Tunnels erforderlich. Hier muss der Port 52698 hinzugefügt werden, damit auf dem Raspberry Pi wiederum von der Code Datei eine Verbindung zum Server Remote-Atom hergestellt werden kann.


Adresse einrichten


Port für Tunnel eintragen und...


... hinzufügen



Zurück auf Session und Speichern

 

Ist die Einstellung gespeichert, kann dann auch gleich die SSH Verbindung zum Raspberry Pi hergestellt und mit dem nächsten Schritt fortgesetzt werden.

 

Installation von rmate auf Raspbian

Auf der Packages Seite zu Remote-Atom ist bereits beschrieben, wie man die Verbindung startet. Jedoch der Vollständigkeit halber füge ich die Befehle hinzu, mit dem die Vorbereitung funktioniert.


 sudo curl -o /usr/local/bin/rmate https://raw.githubusercontent.com/aurora/rmate/master/rmate  

 

 sudo chmod +x /usr/local/bin/rmate 

 

Falls der Name rmate nicht zusagt, kann rmate umbenannt werden in ratom.

 

 sudo mv /usr/local/bin/rmate /usr/local/bin/ratom 

 

Code Datei erstellen

Falls keine Code Datei vorliegt, kann in einem Zielordner eine Datei erstellt werden.

 

 touch myHelloWorld.go  

... oder wie im folgenden Beispiel




Remote Verbindung starten

Auf dem PC kann nun in der Anwendung ‚Atom‘, das installierte Remote-Atom unter 'Packages > Remote Atom > Start Server' gestartet werden.

Über Putty kann nun auf dem Raspberry die Verbindung zur einer Datei hergestellt werden.
Am besten zum Pfad wechseln, wo sich die Zieldatei befindet und dann folgenden Befehl eingeben:

 

ratom myHelloWorld.go

 

... oder wie im folgenden Beispiel





Anschließend auf dem PC mit dem Programm ‚Atom‘ das installierte Package starten. Hier sollte sich kurz danach ein neuer Tab öffnen, welcher den Inhalt der Code Datei enthält.



Let's GO

Da aktuell mein Thema die Programmiersprache GO ist, ist der auszuführende Beispiel auch in Code Go geschrieben.

 


Nun können wir mit Putty den Code auf dem Raspberry starten. Dazu folgenden Befehl eingeben und mit Enter ausführen.

go run myHelloWorld.go

Wenn der Code ausgeführt wurde, sollte in der Konsole nun das 'Hello World!' zu lesen sein.


 

Praktisch

Die Installation eines Code Editor ist auf dem Raspberry Pi mit Raspbian nicht nötigt. Vielleicht nur dann, wenn nicht immer ein PC oder Notebook mit Netzwerkverbindung vorliegt. Die Verbindung geht praktisch mit jeder textbasierten Datei und man braucht weniger eine Desktop Version von Raspbian.

Sonntag, 24. Mai 2020

Angular auf dem Raspberry Pi


Zuvor hatte ich den Raspberry Pi nur für Windows 10 IoT mit UWP Entwicklung gesehen. Das lag mit unter daran, dass ich nicht viel Zeit hatte, um mir anderes technologisches Wissen anzueignen. Doch gerade habe ich auf Grund der aktuelle Lage  um Corona und in Kurzarbeit habe ich  Zeit mich mit anderen Technologien zu beschäftigen. Darunter fiel auch das Front-End Webapplikationsframework Angular.

Bei Windows 10 IoT auf dem Raspberry Pi beschränkte es sich leider nur auf eine aktiv laufende Anwendung, was dazu führte eine monolithische Anwendungen zu schreiben. Und zum derzeitigen Zeitpunkt  gibt's auf Windows 10 IoT und Docker nur für x86/x64 Systemen, also leider noch ein Grund, diese Kombination aufzugeben.

 

Mit etwas Weitblick, fand ich heraus, dass Angular auch in einem Docker Container laufen kann und somit dann auch auf einem Raspberry Pi.

 

Voraussetzung

  • Raspberry Pi 2, 3 oder 4
  • Betriebssystem Raspbian (geht auch mit anderen Linux Betriebssystem für Raspberry Pi)
  • Docker Account

 

Anforderung

Eine Angular Hello World Anwendung in einem Docker Container starten auf einem Raspberry Pi.

 

Hello Angular Image

Zunächst brauchen wir eine Angular Projekt. Wenn ihr bereits eins habt, verwendet es einfach. Das Einzige, was hinzugefügt wird, ist die Datei ‚Dockerfile‘ im Root Verzeichnis des Projektes. In meinem Beispiel hat das Projekt den Namen (das auch der Namen, den das Root-Verzeichnis trägt) "ExampleHelloDocker", der in der Dockerfile auch so stehen sollte.

 

 FROM arm32v7/alpine  
 COPY /dist/ExampleHelloDocker /usr/share/nginx/html  
 EXPOSE 80  

 

Nun brauchen wir die Eingabeaufforderung oder das Terminal aus Visual Studio Code. Wechselt dazu in das Projekt Root Verzeichnis und erstellt ein Angular Build.

 

 ng build --prod  

 

Und im Anschluss das Docker Image erstellen. Da hier keine Großbuchstaben verwendet werden, habe ich für die Lesbarkeit Bindestriche eingesetzt.

 

 docker build -t example-hello-docker .  

 

Taggen und pushen

Im nächsten Schritt wird vor dem Pushen auf Docker-Hub, das Image getagt. Dazu braucht ihr euren Benutzernamen von Docker.   

 

docker tag example-hello-docker:latest <username>/example-hello-docker:latest

 

Anschließend kann es nun auf Docker-Hub hochgeladen werden.

 

 docker push <username>/example-hello-docker:latest  

 

Fertig. Nun sollte euer Image auf Docker-Hub zu sehen sein. Falls ihr euer Image nicht öffentlich bereit stellen wollt, sollte ihr auf Docker-Hub das Image im Repositories auf private umstellen.

 


 

Image ziehen und starten

Ab hier sollte das ziehen und starten wie bei jeder anderen Docker Image laufen.

 

 docker pull <username>/example-hello-docker:latest  


Um die Docker Image ID zu erhalten, schauen wir, ob das Image nun vorliegt.

 

 docker image ls  

 

 

Und nun heißt es endlich starten!!
Portnummer 5000 ist die, unter der die Angular Anwendung vom Netzwerk aus zu erreichbar ist.
Hier könnt ihr auch eine andere Portnummer festlegen.

 

 docker run --publish 5000:80 -t <image id>  

 

Oder besser, wenn man den Raspberry pi wieder einschaltet, auch der Container weiter läuft.

 

 docker run --publish 5000:80 -t --restart always <image id>  

 

Lokal auf dem Raspberry Pi sollte nun die Angular Webanwendung im Browser mit der Adresse http://localhost:5000 erreichbar sein. Und natürlich über das Netzwerk von einem anderen Rechner mit der IP Adresse und dem gesetzten Port.



 

HINWEIS: Seit Januar 2021 musste ich feststellen, dass das erstellen des Docker Image von einem Windows System in der Form wie beschrieben nicht funktionieren könnte. Alternativ kann die gebaute Angular Anwendung auf Rasbian kopiert werden und dort mit dem Docker Build Befehle das Image erstellt werden.


Das Thema ist bereits mehrmals auf Stackoverflow vorhanden, aber wenig detailiert. Deshalb habe ich selbst einen Eintrag geschrieben, dass praktisch die Beschreibung dieses Blog-Post in Kurzform und auf Englisch wiedergibt. 

Can't create docker image for raspberry pi with angular app

Sonntag, 19. April 2020

GO(lang) on Raspberry Pi


Kleine Anwendungen können ganz gut auch auf kleinen Systemen laufen. Da ich mich in letzter Zeit öfter mit GO (Golang) auseinandersetze, wende ich mich ein wenig von Windows ab und schaue seit längerer Zeit mal wieder über den Tellerrand. Hängen geblieben bin ich in den verfügbaren Linux Betriebssysteme für Raspberry PI und dem Einsatz von Docker.

Mit Docker kann man alles machen. Naja, nicht alles alles. Mein Kaffee muss ich immer noch selber kochen, außer ich schreibe eine Anwendung und baue einen Treiber mit Sensoren und Aktoren, um die Kaffeemaschine zu kontrollieren. Dann sollte das auch mit Docker gehen. Oder ich schicke der Frau eine Nachricht und bitte um Kaffeenachschub. Aber fangen wir mit etwas einfacherem an.

Wir brauchen dazu:

Anforderung
Am Ende soll auf dem Raspberry Pi ein Webservice laufen, der in einem Docker Container gestartet wird. Der Dienst soll von einem anderen PC mit einem Browser im lokalen Netzwerk aufrufbar sein und schließlich eine Testwebseite wiedergeben.

Webservice entwickeln in GO
Einen Webservice in GO zu schreiben ist sehr übersichtlich. In C# mit .NET Framework habe ich deutlich mehr Codes geschrieben, bis endlich ein Webservice lief. Zudem fällt mir das Wegdenken von Programmiergewohnheiten schwer, die eigentlich nicht sein müssen. Man spricht auch oft von Boilerplate-Code.

Kommen wir zu dem GO Code mit dem geschriebenen Webservice. Nachdem wir im Projektordner eine neue Datei angelegt haben mit dem Namen 'main.go', geht das Schreiben mit dem Code los, bzw. einfach den folgenden Code nach dem Absatz kopieren.
Im Detail zu der Sprache GO kann ich die Seite von Golang 'A Tour of Go' empfehlen. Dort lernt ihr alle Grundlagen zu der Sprache und könnt die Eingaben direkt im Browser prüfen.
In der 'main()'-Funktion startet die Anwendung den Webservice. Kommt ein URL Request rein, wird durch die Handler Function ‚http.handleFunc‘ der Delegat ‚webserviceHandler‘ ausgeführt. Dieser kann den eingehenden Request verarbeiten. Doch für dieses Beispiel kommen wir ohne Parameter aus. Stattdessen wird eine HTML Seite eingelesen und als Response zurückgegeben.

 package main  
 import (  
      "fmt"  
      "io/ioutil"  
      "net/http"  
 )  
 func main() {  
      fmt.Println("start webservice")  
      http.HandleFunc("/", webserviceHandler)  
      http.ListenAndServe(":5000", nil)  
 }  
 func webserviceHandler(w http.ResponseWriter, r *http.Request) {  
      webside, err := ioutil.ReadFile("index.html")  
      if err != nil {  
           fmt.Println(err)  
           return  
      }  
      fmt.Fprintf(w, string(webside))  
 } 




Lokal den Service ausprobieren
An der Stelle sollte der Code bereits ausführbar sein. Wenn jetzt F5 zum Ausführen gedrückt wird, dann sollte Lokal mit einem Browser der Webservice mit der Adresse 'http://localhost:5000' aufrufbar und das ‚Hello World Webseite‘ zu lesen sein.

Dockerfile anlegen
Damit der Webservice auch im Docker Container funktioniert, ist relativ wenig zu tun. Relativ, an der Stelle habe ich lange gesucht und mich lange mit Docker auseinandergesetzt, um am Ende die einfach aussehende Dockerfile zu schreiben. An der Stelle kann ich nur empfehlen, die einzelnen Befehle nach zu lesen, die für die Dockerfile verwendet werden können. Dockerfile Preference https://docs.docker.com/engine/reference/builder/
Die Dockerfile kommt in dasselbe Verzeichnis, wie die Datei mit dem GO Code. Die Einträge mit 'LABEL' sind optional und können auch weggelassen werden.

 # Initialisiert die Bereitstellung und   
 # legt das Basis Image mit nachfolgenden Anweisungen an  
 FROM golang:onbuild  
 # label of maintainer  
 LABEL maintainer="Codexzier"  
 LABEL version="1.0"  
 LABEL description="A mini messenger server with based user."  
 # legt das Verzeichnis an für die Ausführung  
 WORKDIR /app  
 # kopiert die neuen dateien in den container  
 COPY . .  
 # Führt das Image aus und übergibt das Ergebnis für die Zielumgebung  
 RUN env GOOS=linux GOARCH=arm GOARM=5 go build -o main .  
 # Freigabe der Portnummer auf das der docker container zuhört  
 EXPOSE 8002  
 # Anweisung für den Ausführenden Container  
 CMD ["./main"]  

Docker Image erstellen
Ab dieser Stelle sollte Docker installiert und gestartet sein. Ihr solltet auch einen Account haben, damit das Image anschließend auf Dockerhub geladen werden kann.
In Visual Studio Code öffnen wir zunächst ein Terminal. Hier sollte aktuell das Verzeichnis aufgerufen sein, worin sich der Programmcode, Webseite und die Dockerfile befinden. Hier gibt ihr folgenden Command ein und am Ende den Punkt nicht vergessen:

docker build -t <image name> .




Nun sollte eine Folge von Arbeitsschritten erfolgen bis dann am Ende Successfully build mit einer kryptischen ID steht und ggf. mit einigen Warnhinweisen.





Bevor auf Dockerhub geladen werden kann, muss noch das Image tagged gesetzt werden (Image tagged, da bin ich nicht sicher ob man das so beschreiben kann). Statt wie bei mir mit Codexzier, müsst ihr euren Docker Username verwenden.

docker tag <tag name>:latest <docker username>/<ziel name>:latest





Nun kann das Image auf Dockerhub hochgeladen werden. Auch hier verwendet ihr euren Username von Docker.

docker push < docker username >/< ziel name >:latest




Nach ein paar Sekunden sollte der Upload abgeschlossen sein. Wenn ihr euch auf Dockerhub https://hub.docker.com/ eingeloggt habt, sollte euer Image in euren Repositories zu finden sein.




Das Image steht bereit und kann vom Zielsystem abgeholt werden. Auf Dockerhub könnt ihr weitere Informationen zu eurem Image hinterlegen. Zum Beispiel, was der Inhalt ist und welche Aufgabe die Anwendung erfüllt. Wenn ihr wollt, dass nur ihr das Image sieht, dann kann hier auch auf Private umgestellt werden. Interessant dürfte auch das Automated Builds sein, aber das wäre wieder ein eigenes Thema.

Docker auf dem Raspberry Pi
Das Beispiel zeigt den Einsatz von Docker mit dem Betriebssystem Raspbian. Von Haus aus ist Docker nicht installiert, ebenso wenig wie Docker-Compose. Im Netz finden sich einige Beschreibungen, daher habe ich den Part hier ausgelassen.

Hinweis: Bei mir muss ich kein "sudo" vor jeden command eingeben.

Um nun das Image herunter zu laden, muss folgender Command ausgeführt werden:

docker pull <docker username>/<image name>




Nach dem Download wird das Image mit einer Image-ID angelegt. Die brauchen wir, um die Anwendung zu starten. Mit folgendem Befehl bekommt ihr alle vorhandenen Images ausgeben.

docker image ls

In der Spalte zu IMAGE ID steht, die ID zu eurem heruntergeladenen Image. Die hier angezeigte ID wird Lokal erzeugt und sollte eine andere ID abbilden.
Mit dem nächsten Command, setzt ihr die entsprechende ID am Ende ein:

docker run --publish < port number to pulish >:< internal port number > -t < image id >



Die gewählte Port 8003 im Beispiel kann frei gewählt werden, wenn die Portnummer nicht von einer anderen Anwendung bereits verwendet wird. Die IP Adresse von Raspberry könnte ihr unter Raspbian auslesen, in dem ihr mit der Maus über das Netzwerk Symbol fährt. Mit der von eurem Raspberry Pi IP Adresse und der gesetzten Portnummer, solltet ihr auf eurem PC, Notebook und Smartphone auf den Raspberry zugreifen können und die Webseite 'Hello World!' erhalten.


Langer Weg für die Bereitstellung
Die Bereitstellung ist etwas lang, aber durch die Docker-Umgebung auf eine einheitliche Ebene gebracht. Das Gleiche sollte nicht nur mit GO funktionieren, sondern auch mit anderen Sprachen. Und Dank Docker können wir einen Service schreiben, der praktisch auf allen Systemen bereitgestellt werden kann.

Wie immer ist der fertige Code auf meinem Repository verfügbar

Ameisen Simulation und andere Dinge

Wer lange sich schon mit C# beschäftig, hat sicherlich schon mal was von AntMe gelesen oder gehört. Diese Idee hatte ich aufgegriffen und mi...