Windows 10 Iot Core Dashboard Installation geblockt

Da will man wieder über das Dashboard seinen Raspberry Pi erreichen, erscheint eine Meldung, dass die Anwendung blockiert wurde. Für mich verwunderlich, dass etwas von Microsoft nicht mehr ausgeführt oder installiert werden konnte.

Ursache

Nach einem Größeren Update für Windows 10 im Mai, wurde die Sicherheitseinstellung für das Installieren über URL ausgeschaltet. Um das wieder frei zu geben, muss lediglich eine Einstellung in der Registrie geändert werden.

Computer\HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\.NETFramework\Security\TrustManager\PromptingLevel\Internet = Enable

Die Änderung funktioniert akut, so dass die Installation des Windows 10 IoT Dashboard im Anschluss gestartet werden kann. Statt einer Meldung, dass die Installation geblockt wird, sollte nun die Option Installieren wieder verfügbar sein.

Zuletzt

Hier sollte man sich Bewusst machen, dass mit der Freigabe eine mögliche Sicherheitslücke für "Man in the middle attack" geöffnet wird. Unschön aber offensichtlich notwendig.

Wetterstation / Gewächshaus mit Webzugriff

Mit der Zeit kommen für das Beispiel Programm einer Wetterstation neue Funktionen hinzu. Somit lässt sich mit dem aktuellen Stand, den Wemos mit dem WLAN verbinden und über einem Browser können die Messdaten abgelesen werden.

Momentan wird das Programm mit dem Wemos in meinem Gewächshaus verwendet. Natürlich ist mir bewusst, dass die Elektronik durch die hohe Luftfeuchtigkeit beschädigt werden kann und ist auch nicht zu empfehlen. Ansonsten müsse die Elektronik mit Plastikspray oder ähnlichen eingesprüht werden.

Webzugriff

Die Implementierung einer Webseite war ein Muss. Für die Realisierung muss man nur wissen, wie man auf eingehende Anfragen reagiert und wie die Webseite zurück gegeben wird. Die Webseite erfüllt ihren Zweck und Zeigt die aktuellen Messdaten. Das Aktualisieren der Messdaten erfolgt durch den erneuten Aufruf des Wemos, bzw. die Seite neu laden.

WLAN

Damit sich der Wemos mit WLAN verbinden kann, muss die SSID (Euer WLAN Name) und das Passwort eingetragen werden. Von den Sicherheitsoptionen sollte mindestens WPA-PSK funktionieren. Die IP Adresse und Gateway müssen bei Bedarf ebenfalls angepasst werden.

Zuletzt

Auf dem Bild mit der Webseite ist ein Vierter Wert aufgeführt. Der Vierte Wert ist der Grund für meinen Test im Gewächshaus und Zeigt einen Messwert von einem Bodensensor an. Aber dazu komme ich dann zu meinem nächsten Blogpost.

[Github - Wetterstation]

SQLite oder CSV auf Raspberry Pi 2/3 mit Win 10 IoT

Irgendwann kommt der Punkt, da möchte man seine Daten auch speichern. Bei dem Einsatz von vielen Daten kann auf die Klassische Art in einer CSV im IsolatedStorage gespeichert werden. Ist einfach zu lesen führt aber zu redundante Dateninhalte. Mit SQLite lassen sich relationale Dateninhalte zusammenstellen. Aber man muss zusätzliche Referenzen hinzufügen und sich mit SQL auseinandersetzen (allerdings nur ein wenig). Beide Varianten funktionieren auf PC, Tablet, Windows Phone und natürlich auf Raspberry Pi 2 und 3.

Was nehme ich?

Vorweg sollte man sich fragen, was wird mein Ziel. Das hängt immer von der eigenen Anwendung ab. Soll in der Stunde ein Durchschnittswert errechnet werden der dann angezeigt werden soll, dann reicht sicherlich ein Array.

Möchte ich Benutzereinstellungen Speichern? Dann könnte der folgende Programmschnipsel reichen der den IsolatedStorage verwendet.

ApplicationData.Current.LocalSettings.Values["MyKey"] = MyValue; if (ApplicationData.Current.LocalSettings.Values.ContainsKey("MyKey"))     MyValue = ApplicationData.Current.LocalSettings.Values["MyKey"]; Aus <https://stackoverflow.com/questions/42750736/uwp-how-to-use-isolated-storage>

Für diesen Bleiben wir zunächst bei einfachen Datensätzen, die einfach hintereinander gespeichert und in einer Tabelle abgebildet werden können. Der Teil für Relationale Datenhaltung wird auf den nächsten Post eingegangen.

Datenabruf

Der Vorteil einer Datenbank Abfrage ergibt sich dann beim Abrufen der Daten. Wurden z.B. so viele Daten gespeichert, dass es in Summe ca. 20 Megabyte groß ist, dann könnte sich das Öffnen der CSV Datei etwas lang werden. Und wenn man nur zu einem Bestimmten Zeitraum oder einen Bereich haben möchte, dann ist das gesamte einlesen einer Datei und das Parsen der Inhalte relative Zeitintensiv.

Performance Vergleich?

Hierzu muss man sagen, dass der IsolatedStorage nicht gedacht ist, schnell einzelne Daten zu speichern. In der Demo Anwendung sind zwei provisorische Klasse mit IsolatedStorage angelegt. Diese sind nur soweit geschrieben, das damit Lesen, Speichern und zurück setzen ermöglicht. (siehe am Ende Link zum Github Repository). Letzten Endes sollte anhand der Ergebnisse zeigen, was für den einen oder anderen die bessere Entscheidung sein könnte und unabhängig von weiteren Kriterien betrachtet werden sollte.

Test Vorgang

Als erstes wird festgelegt, wie viele Daten geschrieben werden. Vorbelegt als Default Anzahl sind zehn Datensätze zu erstellen. Die Werte sind in allen Datensätzen dieselben, außer der letzte wird abwechselnd zu gewiesen (hier Wohnzimmer und Flur).

Jeder Vorgang wird zehnmal ausgeführt und gemessen. Daraus ergibt sich dann die Durschnittszeit.

• Bestehende Daten löschen
• Zehn Mal die Anzahl Daten schreiben. Bei jeden neu lauf, werden die Daten wieder gelöscht.
• Die Zehn Daten, zehnmal lesen. Daten werden immer neu geladen.
• Datenabrufen und auf "Wohnzimmer" filtern. Auch hier werden die Daten immer neu geladen

 Nach dem Durchlauf werden die Ergebnisse der einzelnen Durchläufe sowie der Durchschnittswert angezeigt.

Beispiel Anwendung

Die Beispiel UWP Anwendung ist nur Zweckmäßig für den Test aufgebaut. Oben Links kann über die Textbox ein Wert ab 1 eingetragen werden und setzt damit die Anzahl Daten, die geschrieben werden sollen. Mit dem Button "Run" wird der Test Ausgeführt. Sobald dieser durchlaufen ist, steht unter dem Button "Finish".

Rechts sind zwei Textboxen die wiederum zwei Beispiele zu SQLite und IsolateStorage abbilden, die im Programmcode im Einzelnen betrachtet werden können. (Die Ergebnisse im Bild können von PC zu PC abweichen)

Ergebnisse

Ziel Systeme sind natürlich der Raspberry Pi 2 und 3. Warum das Schreiben mit SQLite auf dem Raspberry Pi3 langsamer ist, konnte ich mit dem Testaufbau noch nicht ermittelt. Zudem kommt, dass nach dem Aufräumen der Methoden Inhalte, sich die Zeiten verschlechtert haben. Warum dies ist, werde ich auf einen späteren Post eingehen.

Ergebnisse in dem der Programmcode einfach runter geschrieben wurde

Ergebnisse nach dem Aufräumen

Fazit

Der Aufbau der Methoden kann sicherlich besser gelöst werden. Die Methoden Inhalte in 'Func<T>' auszulagern ließ die Ergebnisse deutlich mehr schwanken. Die Gemessene Zeit stieg um das Sieben- bis Zehnfache an beim Lesen mit 'Where' Abfragen. Der Test mit Schreiben in die SQLite Datenbank ist dahingegen weniger abweichend, dafür aber beim IsolatedStorage ist die Durschnittszeit auf ca. das zwanzigfache angestiegen.

Beide haben Vor- und Nachteile. Mit diesen Beispiel Test wäre IsolatedStorage gut fürs schnelle Speichern und für das schnelle Lesen die SQLite Datenbank.

Die Auslegung der Tests ist sehr spärlich und behandelt noch nicht das Verwenden von Relationalen Daten. Das kommt dann mit den nächsten Posts.

Offene Punkte:

• Speichern von Relationalen Daten
• Abruf von Relationalen Daten
• Probleme mit Code Optimierung

Github - ExampleSQLiteAndIsolatedStorage

Referenzen

https://stackoverflow.com/questions/42750736/uwp-how-to-use-isolated-storage

https://docs.microsoft.com/de-de/windows/uwp/files/quickstart-reading-and-writing-files

http://blog.chrisbriggsy.com/Using-SQLITE-in-Windows-10-IoT-Core-Insider-Preview/

Gamepad per UWP

Hätte ich ein wenig mehr Recherchiert, dann hätte ich gleich eine UWP Anwendung geschrieben. Mit Visual Studio kann man schon seit Windows 8.1 UWP Anwendungen schreiben, die für PC, Tablet und Windows Phone funktionieren. Klar, Windows Phone ist vielleicht nicht mehr interessant, aber man kann das Smartphone immer noch zum Basteln verwenden.

Suche nach bestehenden Lösungen

Vor einigen Wochen suchte ich eine Lösung, wie man andere GameController einlesen kann und stieß auf einen anderen Blog Namens "Sander van de Velde", der über die Klasse Gamepad in UWP Anwendung schrieb. Kurz gelesen und gleich probiert und siehe da, es geht. Man kann sogar mit dem Xbox Controller die eigene Anwendung Teilweise sogar Bedienen. Egal ob auf PC, Tablet oder Raspberry Pi. 

Sander van de Velde: Using your Xbox One controller in a UWP app

Für den Einstieg

Als Beispiel wird ein Punkt auf der Anwendung bewegt. Der Aufbau zeigt, welche Grundlegende Programmcodezeilen Notwendig sind, um die Eingabe vom Xbox Controller zu nutzen.

Gamepad erkennen

Wenn der Xbox Controller mit dem Ziel Gerät verbunden wird, dann wird das GamepadAdded Event gesendet. Das gleiche gilt auch wenn der Controller getrennt wird (GamepadRemoved). Hinweis: MainViewModel habe ich nicht aufgeführt (siehe ggf. Github).

 // ist eigentlich bei einem so kleinen Beispiel nicht Notwendig ein ViewModel zu verwenden 
 private MainViewModel _viewModel = new MainViewModel();  
 // Ermöglicht eine Schleife Asynchron zum Haupteil der Anwendung auszuführen.  
 private Task _run;  
 // Hauptklasse für das einlesen des Xbox Controllers.  
 private Gamepad _gamePad;  
 // Wird nur für den zufälligen Farbwechsel verwendet.  
 private Random _random = new Random();  
 public MainPage()  
 {  
   this.InitializeComponent();  
   this.DataContext = this._viewModel;  
   Gamepad.GamepadAdded += this.Gamepad_GamepadAdded;  
   Gamepad.GamepadRemoved += this.Gamepad_GamepadRemoved;  
   this.MovingPoint.Fill = new SolidColorBrush(Colors.Black);  
 }  
 // Wenn der Xbox Controller getrennt wird.  
 private void Gamepad_GamepadRemoved(object sender, Gamepad e) => this._gamePad = null;  
 // Wird ausgeführt, wenn ein Xbox Controller verbunden wurde.  
 private void Gamepad_GamepadAdded(object sender, Gamepad e)  
 {  
   this._gamePad = e;  
   // … Ab hier kann der Controller ausgelesen werden.  
 }  

Gamepad einlesen und Eingabe Werte verwenden

Das Auslesen gibt ein Typ von GamepadReading zurück. Dieser enthält alle Eingaben, die zu diesen Zeitpunkt des Auslesen getätigt wurden.

Die UI und das Auslesen befinden sich in zwei Ebenen und laufen somit Asynchrone zu einander. Damit die umgerechneten Werten an die UI Elemente zugewiesen werden können, wird der Dispatcher verwendet.

 // Liest die den Xbox Controller aus. Für den Vorgang wird eine Schleife verwendet.  
 private async void ReadingGamepad()  
 {  
   while (true)  
   {  
     if(this._gamePad == null) { break; }  
     // Aktuelle Eingabe erfassen.  
     GamepadReading gp = this._gamePad.GetCurrentReading();  
     // UI und der Task laufen in verschiedenen Ebenen.   
     // Daher muss über den Dispatcher die Eingabe Daten   
     // und die Daten aus dem ViewModel Bindung Async behandelt werden.  
     await this.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.High, () =>  
     {  
       // Linken Stick einlesen  
       var left = gp.LeftThumbstickX;  
       var top = gp.LeftThumbstickY * -1;  
       // Abstand zum Rand  
       var distanceToBorder = 30;  
       // Eingabe zu einer Position auf der Anwendung umrechnen.  
       var halfLeft = (this.ActualWidth - (distanceToBorder * 2)) / 2d;  
       left = halfLeft + (left * halfLeft);  
       var halfTop = (this.ActualHeight - distanceToBorder * 2) / 2d;  
       top = halfTop + (top * halfTop);  
       // verhindern, dass der Punkt den Rand nicht erreicht.  
       if (left < distanceToBorder) { left = distanceToBorder; }  
       if (left > this.ActualWidth) { left = this.ActualWidth; }  
       if (top < distanceToBorder) { top = distanceToBorder; }  
       if (top > this.ActualHeight - distanceToBorder) { top = this.ActualHeight - distanceToBorder; }  
       // Position als Text Ausgeben mit bis zu zwei Stellen hinter dem Komma.  
       this._viewModel.TextPosition = $"LEFT: {left:N2}, TOP: {top:N2}";  
       // leider kein Binding, daher die simple zuweisung der Ziel Position und Farbe  
       this.MovingPoint.Margin = new Thickness(left, top, 0, 0);  
       // Farbe wechseln  
       if (gp.Buttons == GamepadButtons.A)  
       {  
         // verkürzte die schreibweise  
         byte f() => (byte)this._random.Next(0, 255);  
         this.MovingPoint.Fill = new SolidColorBrush(Color.FromArgb(255, f(), f(), f()));  
       }  
     });  
     // 2 Millisekunden interval  
     await Task.Delay(2);  
   }  
 }  

Fazit

Das war alles. Und dazu war keine zusätzliche GameEngine Notwendig, um die Eingabedaten vom Xbox Controller zu lesen. Auf dem PC und Tablet funktioniert dies auch Kabellos. Nur mit dem Raspberry Pi 2 und 3 konnte ich die Verbindung nur mit einem USB Micro herstellen. Auf Windows Phone (Lumia 930) ließ sich die Anwendung starten, aber es konnte keine Bluetooth Verbindung hergestellt werden.

Github - ExampleUwpAndXboxController

Analog Anzeige auf dem TFT 1.8" zeichnen

Eine Analog Anzeige ist schon etwas Nostalgisch und haben eigentlich wegen ihrer ungenauen Ablesbarkeit keinen nutzen mehr. Aber das sollte kein Hindernis sein, dennoch solche Analogen Display auf einem Arduino zu Zeichnen. Das man dazu nicht viel machen muss, zeige ich in diesen Post mit einem Code Schnipsel.

• Arduino UNO / Duemilanove
• TFT Display 128x160
• Ggf. TFT Display Shield

Die Bibliothek für TFT hat fast alle Methoden, um das Zeichnen einer Analogen Anzeige zu ermöglich. Damit man nicht zu sehr in Grafik Experimente verfällt, ist es hilfreich sich vorher eine Skizze zu machen. Mit den Rechtecken und Kreisen und einer richtigen Reihenfolge, kann die Grundlage der Analoganzeige gezeichnet werden. Jedoch der Interessante Teil ist, das Animieren der Anzeigenadel.

Anzeigenadel

Der Aufbau der Anzeigenadel ist sehr überschaubar und kommt mit einfacher Schulmathematik aus. Für das Beispiel wird allerdings nur eine Linie gezeichnet. Eine Pfeilspitze würde beim Zeichnen mehr Zeit aufwenden und eine flüssige Darstellung wäre ggf. nicht möglich. Zumindest nicht mit der Bibliothek, da das Pixelzeichnen nicht in ein Backbuffer des TFT geschrieben werden kann.

Später beim Zeichnen eines Wertzustandes, muss der vorige Stand zurück gesetzt werden. Hierbei reicht es die Anzeigenadel mit dem vorigen Wert nochmal mit der Hintergrundfarbe zu Zeichnen.

Code Schnipsel

Der folgende Programmcode Zeichnet nur die Anzeigenadel. Als Eingabewert wird der Pin A0 mit 'analogRead' ausgelesen. Die vollständige Analoganzeige findet ihr wieder auf meinem Github Repository.

 #include <SPI.h>  
 #include <TFT.h>  
 #include <Wire.h>  
 #define CS  10  
 #define DC  9  
 #define RST 8  
 TFT mScreen = TFT(CS, DC, RST);  
 float mValuePointer = 0.0;            
 float mValuePointerLast = 0.0;         
 void setup() {  
  Wire.begin();  
  mScreen.begin();  
  mScreen.background(0, 0, 0);  
  pinMode(A0, INPUT);   
 }  
 void loop() {  
  mValuePointer = ((float)analogRead(A0) / 1023.0) * 100.0;  
  mScreen.stroke(0, 0, 0);  
  renderValuePointer(40, 40, 25, mValuePointerLast);  
  mScreen.stroke(35, 200, 140);  
  renderValuePointer(40, 40, 25, mValuePointer);  
  mValuePointerLast = mValuePointer;  
  delay(10);  
 }  
 void renderValuePointer(int locationX, int locationY, float diffRadius, float val) {  
  float section = 2.0 * 3.14 / 100.0;  
  float sectionStart = section * 5;  
  float center = diffRadius / 2.0;  
  val = val + 50.0;  
  float x = diffRadius * cos(section * val) + diffRadius;  
  float y = diffRadius * sin(section * val) + diffRadius;  
  mScreen.line(locationX + diffRadius, locationY + diffRadius, locationX + x , locationY + y );  
 }  

Wenn ihr das auf eure Umgebung hoch lädt, dann sollte eine Line auf dem Bildschirm zu sehen sein. Das Zappeln ist praktisch gesehen ein Rauschen, wenn kein Pull-Up oder Pull-Down Widerstand gesetzt wurde auf Pin A0.

Kurzes

Wie ihr seht, steckt da nicht viel dahinter und schon schafft man etwas mehr Optik.

Github - ExampleAnalogDisplay

Aufräumen und Codestyle ändern

Irgendwann ist die Schmerzgrenze angekommen, dass der Code wie dieser im Bild geschrieben wurde und einige Schwierigkeiten beim Lesen bereiten. Fehlende Vorzeichen sowie Groß- und Kleinschreibung von Funktionsvariablen erschweren die Übersicht.

Neue Fassade

Der Programmcode den ich für diesen Teil zur Verfügung stelle, funktioniert wie bereits aus 'Von Händlern, Kisten und Münzen (Arduino Esplora, Part8)'. Der wesentliche Unterschied ist, dass der Code zurecht gerückt, größten Teils kommentiert und zusätzliche Trennlinien hinzugekommen sind. Natürlich werden in Zukunft auch alle anderen Beispiele nach diesem Codestyle geschrieben. Durch die Festlegung verschiedener Regeln beim Codeformat, sollte die Lesbarkeit deutlich verbessern.

Im Internet suchte ich einige Codebeispiele und las sie bezüglich dessen Aufbau und Formatierung. Zwar gibt es zu dem Thema bereits einige Codestyles, aber die Anforderung sollte ein Kompromiss für Hobby Entwickler sein.

Folgende Codeformat Vorgaben haben sich bei der Suche und Vergleich als Sinnvoll ergeben.

	Beschreibung	Wie der Code aussehen könnte
1	If-Else Abfragen. Auch wenn man sie in einer Zeile schreiben kann, ist die Form schlecht zu lesen. Auch wenn nur eine Sache behandelt wird.	if(stateValue > 0) {     doAnything(stateValue); }
2	Kommentare zu einer Zeile Nach einigen Vergleichen von Kommentierten Programmcode, empfand ich die rechts neben dem Code stehenden Kommentare als angenehm. Eine Prämisse hat diese Form jedoch. Da keine Auto Funktion vorhanden ist, dass die Kommentare in gleicher Höhe einrückt ist der Vorgang mit etwas Fleiß verbunden.	int16_t stateValue = 0;     // local variable for todo anything
3	Kommentare über einer Funktionsmethode Scrollt man durch den Code, dann helfen Trennlinien zwischen den Methoden. Wie lang die Trennlinie selbst sein soll, kann soweit bestimmt werden, wie sie für die Sichtbarkeit benötigt wird.	// ============================================ void loop() {   mCounter++; }
4	Zusammenhängende Funktionsvariablen Zusammengenutzte Variablen sollten auch möglich nahe zusammenliegen und auch ggf. eine Beschreibung haben.	// ============================================ // function variables int16_t mCounter = 0;   // it is only a counter
5	Wertetypen Ist sicherlich mühseliger zu schreiben, aber gewährleistet das auch mit anderen Compiler dasselbe Ergebnis kommt. Das kann beim Verwenden eines 16Bit oder 32Bit Microcontrollers vorkommen, das beim kompilieren die Wertetypen anders übersetzt. Z.B. würde statt eines 'int16' ein 'int32' eingesetzt. Bei Berechnungen mit größeren Werten kann es da schon zu Rechenfehler kommen.	int8_t value8 = 123; int16_t value16 = 123; int32_t value32 = 123; uint8_t valueU8 = 123; uint16_t valueU16 = 123; uint32_t valueU32 = 123;
6	Funktionsvariablen Obwohl man möglichst versucht keine Globalen Variablen zu verwenden, bleibt es nicht aus. Bisher waren die von der Schreibweise von lokalen und globalen nicht zu unterscheiden. Ein 'm' davor und der Variablenname groß geschrieben und schon lassen sich funktionsvariablen leichter zuordnen.	int8_t mMyFunctionVariable = 123; void FunctionAndLocalVariable() {   int8_t myLocalVariable = 123; }
7	#define Um diesen Wert wiederum von den Funktionsvariablen zu unterscheiden, werden diese vollständig groß geschrieben. Bei mehreren Wörter, sollte ein Unterstrich geschrieben werden.	#define MY_DEFINE_VALUE 123

Ordnung ist das halbe Leben

Im Wesentlichen sollten man sich bewusst machen, dass der Programmcode ab einer gewissen Größe immer einer Ordnung folgen sollte. Das Projekt mit dem Arduino Esplora ist noch relativ klein und leicht zu Händeln, da bietet sich die Änderungen der Code Darstellung gut an und hilft auch bei der Selbstreflektion des eigenen geschriebenen Codes. Abgesehen haben wir heute größere Bildschirme und mehr als Ausreichend Festplattenspeicher, so dass kompaktes zusammenrücken und einsparen von Zeichen nicht mehr Zeitgemäß ist.

Der Inhalt zu den Beispiel kann sich mit der Zeit Ändern bzw. erfolgen weitere Codeformat Beispiele.

Github - ExampleCodeFormat

Überarbeitete Code Version aus 'Von Händlern, Kisten und Münzen (Arduino Esplora, Part8)'

Github - Blogpost_09_CleanUp

Reference zu verschieden Codestyle Beschreibungen.

GNU - The Best Use of C https://www.gnu.org/prep/standards/html_node/Writing-C.html

Wikibooks - C++ Konventionen https://de.wikibooks.org/wiki/C%2B%2B-Programmierung/_Einf%C3%BChrung_zum_Buch/_Konventionen

Motor Treiber für den Rover (.NETMF)

Was in C geht, geht auch in C#. Einige Zeit ist vergangen als ich das letzte Mal ein Beispiel zu Netduino gepostet habe. Viel hat sich nicht geändert und im Grunde verwendet ich statt .NETMF 4.2 nun .NETMF 4.3. Neu ist der Netduino 3 der in drei Varianten kommt und alle haben drei Go Port Anschlüsse. Zudem kommt dieser mit mehr Flash Speicher, bei den Varianten mit Netzwerk Eigenschaften. Nur der Takt ist weiterhin bei 168MHz, dass jedoch ausreichend ist für die meisten Anwendungen.

Nun zur Hardware

• Netduino 3 Wifi
• Motor Shield
• Externe Spannungsversorgung mit 9V oder einen zwei Zellen Lipo
• DAGU Rover 5 Chassis 4WD

Antrieb und Motor Shield

Zu meinem vorigen Post mit dem Arduino ändert sich am Antrieb und am Shield nichts. Die Pin Belegung und sowie auch die Betroffenen Signal Ausgänge, sind beim Netduino für diesen Zweck identisch. (Arduino, Motor Treiber für den Rover)

Programmcode

Mit der C# und .NET Micro Framework Variante habe ich weitgehend die Namen der Pin Variablen und auch die Methodennamen direkt übernommen. Ein Punkt ist jedoch anders. Das Ausgegebene Pwm Signal wird beim Initialisieren eingestellt. An der Stelle muss man sich bewusst machen, wie lang die Duration (die Länge des HIGH Level Puls) pro Periode sein darf. Beim Arduino konnte ein Wert von 0 bis 255 zugewiesen werden. Mit der PWM Klasse für den Netduino ist die einzustellende Duration davon abhängig, wie hoch die Periode gesetzt wurde. Für dieses Beispiel kann ein Duration Wert von 0 bis 1000 festgelegt werden.

 public class RoverMotorDriver  
 {  
   private OutputPort _latch;  
   private OutputPort _clock;  
   private OutputPort _data;  
   private OutputPort _regEn;  
   private PWM _outputM1;  
   private PWM _outputM2;  
   private PWM _outputM3;  
   private PWM _outputM4;  
   private const int _outputM1_A = 4;        
   private const int _outputM1_B = 8;        
   private const int _outputM2_A = 2;        
   private const int _outputM2_B = 16;       
   private const int _outputM3_A = 32;        
   private const int _outputM3_B = 128;       
   private const int _outputM4_A = 1;        
   private const int _outputM4_B = 64;        
   public RoverMotorDriver()  
   {  
     this._latch = new OutputPort(Pins.GPIO_PIN_D12, false);  
     this._clock = new OutputPort(Pins.GPIO_PIN_D4, false);  
     this._data = new OutputPort(Pins.GPIO_PIN_D8, false);  
     this._regEn = new OutputPort(Pins.GPIO_PIN_D7, false);  
     this._outputM1 = new PWM(PWMChannels.PWM_PIN_D11, 200d, .1d, false);  
     this._outputM1.Duration = 1;  
     this._outputM1.Start();  
     this._outputM2 = new PWM(PWMChannels.PWM_PIN_D3, 200d, .1d, false);  
     this._outputM2.Duration = 1;  
     this._outputM2.Start();  
     this._outputM3 = new PWM(PWMChannels.PWM_PIN_D6, 200d, .1d, false);  
     this._outputM3.Duration = 1;  
     this._outputM3.Start();  
     this._outputM4 = new PWM(PWMChannels.PWM_PIN_D5, 200d, .1d, false);  
     this._outputM4.Duration = 1;  
     this._outputM4.Start();  
   }  
   public void SetMotorShieldOn(bool setOn)  
   {  
     this._regEn.Write(!setOn);  
   }  
   public void MotorStop()  
   {  
     this.SetRunMotors(0, 0, 0);  
     this.SetMotorShieldOn(false);  
   }  
   public void SetForeward(int speedValueLeft, int speedValueRight)  
   {  
     int motorsOn = _outputM1_B | _outputM2_B | _outputM3_A | _outputM4_A;  
     this.SetRunMotors(motorsOn, speedValueLeft, speedValueRight);  
     this.SetMotorShieldOn(true);  
   }  
   public void SetBackward(int speedValueLeft, int speedValueRight)  
   {  
     int motorsOn = _outputM1_A | _outputM2_A | _outputM3_B | _outputM4_B;  
     this.SetRunMotors(motorsOn, speedValueLeft, speedValueRight);  
     this.SetMotorShieldOn(true);  
   }  
   public void SetTurnLeft(int speedValue)  
   {  
     int motorsOn = _outputM1_B | _outputM2_B | _outputM3_B | _outputM4_B;  
     SetRunMotors(motorsOn, speedValue, speedValue);  
     SetMotorShieldOn(true);  
   }  
   public void SetTurnRight(int speedValue)  
   {  
     int motorsOn = _outputM1_A | _outputM2_A | _outputM3_A | _outputM4_A;  
     SetRunMotors(motorsOn, speedValue, speedValue);  
     SetMotorShieldOn(true);  
   }  
   private void SetRunMotors(int motorsOn, int speedValueLeft, int speedValueRight)  
   {  
     this.SetOutputValue(speedValueLeft, speedValueRight);  
     this.RegisterWrite(motorsOn);  
   }  
   private void SetOutputValue(int speedValueLeft, int speedValueRight)  
   {  
     this._outputM1.Duration = this.GetLimitValue(speedValueLeft);  
     this._outputM2.Duration = this.GetLimitValue(speedValueLeft);  
     this._outputM3.Duration = this.GetLimitValue(speedValueRight);  
     this._outputM4.Duration = this.GetLimitValue(speedValueRight);  
   }  
   private uint GetLimitValue(int durationValue)  
   {  
     if(durationValue > 1000)  
     {  
       durationValue = 1000;  
     }  
     if(durationValue < 0)  
     {  
       durationValue = 0;  
     }  
     return 1000 + (uint)durationValue;  
   }  
   private void RegisterWrite(int motors)  
   {  
     this._latch.Write(false);  
     for (int bit = 0; bit < 8; bit++)  
     {  
       int target = motors & 0x80;  
       motors = motors << 1;  
       this._data.Write(target == 128);  
       this._clock.Write(true);  
       this.SleepWhile(5);  
       this._clock.Write(false);  
     }  
     this._latch.Write(true);  
   }  
   private void SleepWhile(int count)  
   {  
     for (int i = 0; i < count; i++) { }  
   }  
 }  

Unschönes

Die Methode "SleepWhile(int count)" ist eher Unschön, reicht aber hierfür aus, um den ShiftRegister richtig anzusteuern. Bisher traten mit der Einfachen Lösung keine Schwierigkeiten auf.

Fernsteuerung

Mit dem WLAN auf dem Netduino lässt sich schnell auch eine Fernsteuerung dazu bauen. Im nächsten Post werde ich darauf eingehen, wie man mit dem Netduino eine einfache Netzwerk Verbindung herstellt.

Github - ExampleDotNetRoverMotorDriver