Abstandsmessungen mit dem Netduino

Links: HC-SR04 Ultraschall Sensor, Rechts: GP2-1080 Optischer Sensor

Für die Abstandsmessung kann wahlweise ein Ultraschall- oder ein optischer Sensor verwendet werden. Naja beides könnte man auch verwenden, es kommt aber auf die Anwendung an:

• Welche Entfernungen muss ich messen können?
• In welcher Umgebung wird agiert?
• Wie sieht es mit Störfaktoren aus?
• Wie viel darf der Sensor kosten?

Was nun von beidem besser ist, möchte ich hier nicht begründen, da beide Varianten eine Daseinsberechtigung haben. Für einen richtigen Vergleich hätte ich allerdings mehr einkaufen müssen, daher ist meine Vergleichstabelle nur als Ansatz gedacht.

	HC-SR04	GP2-1080
Betriebsspannung	5V	4,5V-5,5V
Stromaufnahme	15mA	33mA
Messung erfolgt	Abstand von Trigger Puls bis Echo Puls	Ergebnis wird als Analoges Spannungssignal ausgegeben
Distanzmessung	2cm - 400cm	10cm – 80cm
Nachteile	Kann durch Geräusche gestört werden	Funktioniert auf Reflektierenden Oberflächen nicht
Vorteile	weite Distanz-Messung	Kann leicht in Analoge Schaltungen verwendet werden.
Preis	1,86€ (Ebay, aus China Import), ab 4,99€ (Amazon)	7,05€ (Reichelt)

Im programmatischen Anteil sind beide recht unterschiedlich von der Handhabung. Wo es beim optischen Sensor geradezu ein Kinderspiel ist, zeigt sich der Ultraschallsensor wesentlich aufwendiger.

Schaltbild für den optischen Sensor

So einfach der Aufbau, so einfach ist auch der Programmcode.

public static void Main() {     AnalogInput ai = new AnalogInput(Cpu.AnalogChannel.ANALOG_0);     while (true)     {         Debug.Print("ReadRaw:" + ai.ReadRaw().ToString());         Thread.Sleep(10);     } }

Die Ausgabe zeigt einen Wert zwischen 0 bis 1000 an.

Ich glaube, dass ist bisher unter den Sensoren der übersichtlichste Programmcode, was ich bisher posten konnte. Im Grunde wird nur ein Pegel vom Infrarotsensor gemessen. Beim Ultraschallsensor ist nur die einfache Verkabelung, der Rest sieht daher leider anders aus.

Die Schaltung mit dem Ultraschall Sensor ist unwesentlich gegenüber dem optischen Sensor. (Leider gibt es in der Fritzing Software den Ultraschallsensor nicht.)

Für den Ultraschallsensor habe ich versucht, so weit wie möglich zu kürzen. Naja, das ist dabei herausgekommen:

private static long _End; public static void Main() {     OutputPort transmitter = new OutputPort(Pins.GPIO_PIN_D12, false);     InterruptPort receiver = new InterruptPort(Pins.GPIO_PIN_D11, false, Port.ResistorMode.Disabled, Port.InterruptMode.InterruptEdgeLow);     receiver.OnInterrupt += new NativeEventHandler(receiver_OnInterrupt);     long begin;     long result = 0;    while (true)     {         // Sende Ping         transmitter.Write(true);         Thread.Sleep(1);        // Werte auf Startpunkt festlegen         _End = 0;         begin = DateTime.Now.Ticks;         transmitter.Write(false);        // Bis in 50 Millisekunden sollte die Messung erfolgt sein.         Thread.Sleep(50);         if (_End > 0)         {            // Differenz von Start und Stopzeit berechnen             result = _End - begin;             if (result < 0)             {                 result = 0;             }         }         Debug.Print("Result: " + result.ToString());         Thread.Sleep(100);     } } // Wird ausgeführt, wenn der Ping Empfangen wurde. private static void receiver_OnInterrupt(uint data1, uint data2, DateTime time) {     _End = time.Ticks; }

Deutlich mehr als das, was man vermutet.

Wenn man sich unbelastet und die Sache als Unerfahrener von außen betrachtet, würde man davon ausgehen, dass die vielen Chips auf dem HC-SR04 bereits diese Arbeit abnimmt. Wer nicht viel drum herum programmieren möchte, der sollte zumindest eine fertige Klasse schreiben. Wer Threads verwendet, der sollte berücksichtigen, dass es zu Messfehlern kommen kann.

Fazit: Wer einen großen Messbereich für wenig Geld benötigt, für den ist der Ultraschallsensor das Richtige. Für einfache und präzise Anwendungen dürfte der optische Sensor die ideale Lösung sein.

PWM Signal Einlesen mit dem Netduino

Der Empfänger am Netduino

Es gibt zwei Lösungen, wie man ein PWM Signal einlesen kann. Über eine RC Schaltung mit der “AnalogInput” Klasse oder vollständig programmatisch. Wenn keine Bauteile wie Widerstand und Kondensator vorhanden ist, dann erübrigt sich das letztere. Beim Arduino kennt man bereits aus der Library die Methode ‘pulseIn()’. Leider wurde das für den Netduino noch nicht umgesetzt. Alternativ bleibt die Möglichkeit, die sich ändernden Pulszustände zeitlich zu messen und das geht hervorragend mit der “InterruptPort” Klasse.

/// <summary> /// Dieses Klasse ermöglicht das genaue Einlesen des eingehenden Pulssignals /// </summary> private static InterruptPort _IntPort = new InterruptPort(     Pins.GPIO_PIN_D0,     true,     Port.ResistorMode.Disabled,     Port.InterruptMode.InterruptEdgeBoth); /// <summary> /// Wird verwendet um den Startzeit des Pulssignals zu merken /// </summary> private static long _HighTicks = 0; /// <summary> /// Kann verwendet werden um einen Servo anzusteuern /// </summary> private static PWM _PwmOutput = new PWM(Cpu.PWMChannel.PWM_0, 20000, 1500, PWM.ScaleFactor.Microseconds, false); public static void Main() {     // PWM Ausgang starten     _PwmOutput.Start();     // Event zuweisen     _IntPort.OnInterrupt += new NativeEventHandler(_IntPort_OnInterrupt);     while (true)     {         Thread.Sleep(1000);     } } /// <summary> /// Wird ausgeführt, wenn sich der Zustand am Eingang geändert hat. /// </summary> private static void _IntPort_OnInterrupt(uint data1, uint data2, DateTime time) {    if (data2 == 1)     {         // Startzeit des Pulssignals merken         _HighTicks = time.Ticks;     }     else     {         // Mit Ende des High Zustands wird die aktuelle         // Zeit mit der begin Zeit abgerechnet und erhält hier         // die Pulslänge des High Signals         double result = time.Ticks - _HighTicks;         // Werte werden zwischen 10.000 bis 20.000 ausgegeben         Debug.Print(result.ToString());        if (result < 20000)         {             // Das Pulssignal darf nur zwischen 1000 bis 2000 sein             _PwmOutput.Duration = (uint)(result / 10);         }     } }

Zum einlesen eines PWM Signals

Über die PWM Klasse gebe ich das eingelesene Signal wieder aus, um z.B. einen Servo oder Regler anzusteuern. Sinn ergibt dies jedoch, wenn der Wert noch verarbeitet wird, bevor es weiter gegeben wird.

Solution zum Downloaden: ExampleReadPwm

Monzoom Pro Rückblick

Raumschiff U.S.S.Adler

Das Programm hieß vor seiner Umbenennung Reflection und war (glaube ich) ein beliebtes Werkzeug zum modulieren, texturieren und animieren in den 1990iger Jahren.

Radpanzer

Während meiner Schulzeit habe ich viele Modelle entworfen oder andere Objekte nachgemacht. Das Programm begleitete mich bis 2002 und zwang meinen PC in die Knie, wenn ich eine Filmsequenz gerendert habe.

Angler am Strand 3D

Letztes Jahr habe ich in meiner Datensicherung meine gesammelte Arbeit wiedergefunden und ich dachte, dass rendere ich mal in High Definition. Wer bereits die Videos gesehen hat, die ich auf meinem Blog gepostet habe, dürfte sich an einen Pixelhaufen erinnern. Früher hatte ich nur einen Pentium 300MHz PC, mit einer Eraser III und 64MB Arbeitsspeicher (später jedoch auf 192MB aufgerüstet). Nun denn, genug Nostalgie.

Ein zusammenschnitt der 3D Animationen mit Monzoom Pro in HD Auflösung.

Daten vom Arduino verarbeiten und visualisieren

Arduino Nano 3.0 und der Magnet Sensor HMC5883L. Gelb=SDA (Pin4), Orange=SCL (Pin5), Rot=+5V und Schwarz=GND

Wenn ich keine Lösung für dem Netduino habe, dann finde ich eine für Arduino. Eines meiner ersten Programme war eines zum Lesen der Sensordaten. Zunächst verwendete ich den Arduino Monitor, der allerdings nichts anderes tat, als eine serielle Verbindung herzustellen. Mit ein “wenig” C# und .NET Framework Kenntnis kann auch ein eigenes Programm geschrieben werden, das die Daten ebenfalls lesen kann. Mein neues Bespiel zeigt die magnetischen Einflüsse auf 3 Achsen an, was ich mit Hilfe von Windows Forms visualisiere.

Windows Forms mit analoger Anzeige

Warum Windows Forms? Die GUI ist schon etwas in die Jahre gekommen und bietet kaum Neuerungen, dennoch kann man grafisch immer noch etwas an Ergebnissen erreichen. Also wäre es doch schön, eine analoge Anzeige auf digitalem Boden zu schaffen. Aber erstmal eins nach dem anderen.

Auf der Seite Gihub stellt der Entwickler Jeff Roberg seine Bibliotheken zur Verfügung für Zahlreiche Sensoren die mit dem Arduino angesprochen werden können. Für mein Beispiel wird der Ordner HMC5883L und die I2Cdev Inhalt benötigt, die dann in den Order “libraries” vom Arduino Compiler kopiert werden. Anschließend kann das mitgelieferte Beispiel “HMC5883L_Example” geöffnet und auf dem Arduino hochgeladen werden. Die Ausgabe erfolgt über die serielle Verbindung, die auf dem Arduino Monitor betrachtet werden kann.

Ausgabe über den Monitor

Nun zur PC Anwendung, die die Daten auswertet und sie in einer visuellen Form darstellt. Als erstes stellen wir die Verbindung sicher, und hier hilft uns das .NET Framework mit der Klasse “SerialPort”. Damit wir die Einstellungen auch später in der Anwendung anpassen können, benötigen wir eine kleine Setup Möglichkeit. Hier reichen die Auswahl des Ports und der Baudrate.

Das kleine Setup mit einem Button zum “Aktualisieren” und einem für “Verbinden”.

In “Form1.cs” Code Seite kommt zunächst die Event Methode, die durch einen Doppelklick auf dem Button im Designer erstellt wird. Dort schreiben wir etwas Code, um die Auswahl über die ComboBoxen auszufüllen.

private void buttonUpdate_Click(object sender, EventArgs e) {     comboBoxChooseCom.Items.Clear();     foreach (string item in SerialPort.GetPortNames())     {        comboBoxChooseCom.Items.Add(item);     }     comboBoxChooseBaud.Items.Clear();     comboBoxChooseBaud.Items.Add(9600);     comboBoxChooseBaud.Items.Add(38400);     comboBoxChooseBaud.Items.Add(115200); }

Füllt die ComboBox mit den Einstellungen.

Die SerielPort Klasse wird nun als Member in der “Form1.cs” angelegt. Einen weiteren Button, der den Text “Verbinden” erhält, erstellen wir ebenfalls durch Doppelklick auf die Event Methode. Hier initialisieren wir die Klasse mit den Einstellungen aus der ComboBox. Damit die Anwendung fehlerfrei läuft, sollte vorher geprüft werden, ob eine Auswahl besteht. Nach erfolgreicher Verbindung muss noch ein neuer Event erzeugt werden, der immer ausgeführt wird, sobald am seriellen Port neue Daten verfügbar sind.

private void buttonConnect_Click(object sender, EventArgs e) {      if (!string.IsNullOrEmpty(comboBoxChooseCom.Text) &           !string.IsNullOrEmpty(comboBoxChooseBaud.Text) &           _SerialPort == null)      {          _SerialPort = new SerialPort(                  comboBoxChooseCom.Text,                  (int)comboBoxChooseBaud.SelectedItem,                  Parity.None, 8, StopBits.One);          _SerialPort.DataReceived +=                  new SerialDataReceivedEventHandler(                  _SerialPort_DataReceived);          _SerialPort.Open();      } } private void _SerialPort_DataReceived(      object sender, SerialDataReceivedEventArgs e) { }

Mit den Einstellungen die Verbindung herstellen.

Jetzt kommen wir zum visuellen Teil der Anwendung, wofür wir ein neues UserControl anlegen, indem wir in unserem Projekt mit Rechtsklick das Kontextmenü öffnen und dann über Hinzufügen >  Neues Element.. das Benutzersteuerelement auswählen. Zuvor sollte ein entsprechender Name verwendet werden wie “AnalogView.cs” oder ähnliches. In meinem Bespiel hat das UserControl eine Größe von 200x100 Punkten, was über die Layout Eigenschaften festgelegt werden kann. Anschließend geht es auf der Code Seite weiter.

public partial class UserControlAnalogView : UserControl {    private Point _PointerValue = new Point(100, 20);    private double _DisplayRawValue = 0.0;     private double _MaximumValue = 90;    public double Maxi_MinimumValue     {         set         {             _MaximumValue = value;             _MinimumValue = 0 - _MaximumValue;         }        get { return _MaximumValue; }     }     public UserControlAnalogView()     {         InitializeComponent();     }     public void RenderAnalogDisplay()     {         SuspendLayout();        Graphics g = CreateGraphics();         g.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.HighQuality;         Pen p = new Pen(new SolidBrush(Color.Black), 2);         p.DashStyle = System.Drawing.Drawing2D.DashStyle.Solid;         g.FillPie(Brushes.WhiteSmoke, 5, 5, 190, 190, 0, -180);         g.DrawPie(p, 5, 5, 190, 190, 0, -180);         p.DashStyle = System.Drawing.Drawing2D.DashStyle.Solid;         p.EndCap = System.Drawing.Drawing2D.LineCap.ArrowAnchor;         g.DrawLine(p, new Point(100, 100), _PointerValue);         ResumeLayout(false);     }     public double DisplayValue     {         set         {             _DisplayRawValue = value;             double alpha = _DisplayRawValue / _MaximumValue;             double w1 = Math.Cos(alpha) * 90;             double w2 = Math.Sin(alpha) * 90;             _PointerValue = new Point((100 + Convert.ToInt32(w2)), 100 - Convert.ToInt32(w1));             RenderAnalogDisplay();         }         get { return _DisplayRawValue; }     } }

Der Codeabschnitt für das Erstellen der Analoganzeige. Die Methode “RenderAnalogDisplay()” zeichnet die Anzeige, und über “DisplayValue” wird die Zeigerposition neu ausgerichtet.

Das Benutzersteuerelement ist fertig und nach dem Drücken der F6 Taste steht es auch schon in unser Toolbox, wo wir es in der Designeransicht auf die Form1 ziehen können. Für jede Achse wird eine analoge Anzeige verwendet; man stelle in den Eigenschaften das Maximum auf 4000 ein.

Die Analoge Anzeige wird erst gerendert, wenn die Methode im UserControl “RenderAnalogDisplay()” ausgeführt wird.

Als nächstes kommt das Auslesen der empfangen Werte. Der Inhalt sind Konstanten und können durch eine Methode einfach ausgewertet werden.

Raw: 455  39  668  Scaled:  418.60  35.88  614.56  Heading:  0.13 Radians  7.52 Degrees

Die Zeichenkette, die uns der Arduino nach dem lesen des Sensor übermittelt.

Im Beispiel beschränken wir uns auf die Raw Daten und programmieren entsprechend in die Event Methode vom SerialPort den Lesevorgang und schreiben das Ergebnis an die analogen Anzeigen.

private void _SerialPort_DataReceived(       object sender, SerialDataReceivedEventArgs e) {         string content = _SerialPort.ReadLine();        string[] sa = content.Split('\t');        string[] sa2 = sa[1].Split(' ');         int[] ia = new int[3];         int axis = 0;         for (int i = 0; i < sa2.Length; i++)         {             if (!string.IsNullOrEmpty(sa2[i]))             {                int.TryParse(sa2[i], out ia[axis]);                 axis++;             }         }         userControlAnalogView1.DisplayValue = ia[0];         userControlAnalogView2.DisplayValue = ia[1];         userControlAnalogView3.DisplayValue = ia[2];     } }

Methode für das Einlesen der Raw Daten.

An dieser Stelle sind wir mit dem Beispiel fertig und die Anwendung kann nun über F5 gestartet werden. Mit Aktualisieren erhalten wir die verfügbaren COM Verbindungen und wählen natürlich die vom Arduino.

Nähert man sich auf einige Zentimeter an den Sensor bewegen sich die Zeiger.

Mit einem Magneten können wir das Magnetfeld um den Sensor manipulieren und sehen, wie die Zeiger ausschlagen. Mit ein paar weiteren Codezeilen lässt sich auch der Rest der Daten anzeigen, allerdings verbleibe ich dabei, mich möglichst kurz zu halten.

Zuletzt darf die bereits fertiggestellte und kommentierte Solution des kleinen Tools nicht fehlen:

• Solution vom “Analog Viewer”

Arduino Nano 3.0 und MPU6050 in Quellcode Kurzfassung

Verkabelungsbeschreibung ist am ende dieses Blogs.

Bereits Anfang des Jahres habe ich eine Lösung in C#  und .NET Micro Framework geschrieben. Ursprünglich habe ich die Lösung aus der in C++ geschriebenen Library portiert (Library für Arduino). Zuvor suchte ich nach einem kürzeren und funktionalem Beispiel, aber ohne Erfolg. Da ich nun selbst relativ gut mit dem Sensor vertraut bin, konnte ich ein kürzeres Beispiel für den Arduino schreiben.

#include <Wire.h> #define sensor_address 0x68 void setup() {   // 9600 Baut reichen zum Betrachten aus.   Serial.begin(9600);   Wire.begin();   delay(1000);     // Powermanagement aufrufen   // Sensor schlafen und Reset, Clock wird zunächst von Gyro-Achse Z verwendet    Serial.println("Powermanagement aufrufen - Reset");   SetConfiguration(0x6B, 0x80);     // Kurz warten   delay(500);     // Powermanagement aufrufen   // Sleep beenden und Clock von Gyroskopeachse X verwenden   Serial.println("Powermanagement aufrufen - Clock festlegen");   SetConfiguration(0x6B, 0x03);     delay(500);     // Konfigruation  aufrufen   // Default => Acc=260Hz, Delay=0ms, Gyro=256Hz, Delay=0.98ms, Fs=8kHz   Serial.println("Konfiguration aufrufen - Default Acc = 260Hz, Delay = 0ms");   SetConfiguration(0x1A, 0x00);     // Leerzeichen   Serial.println(""); } void loop() {   byte result[14];   // Anfangs Adresse von Beschleunigungssensorachse X   result[0] = 0x3B;      // Aufruf des MPU6050 Sensor   Wire.beginTransmission(sensor_address);   // Anfangsadresse verwenden.   Wire.write(result[0]);   Wire.endTransmission();   // 14 Bytes kommen als Antwort   Wire.requestFrom(sensor_address, 14);   // Bytes im Array ablegen   for(int i = 0; i < 14; i++)   {     result[i] = Wire.read();   }     // Zwei Bytes ergeben eine Achsen Wert und könenn // per Bit Shifting  zusammengelegt werden.     // Beschleunigungssensor   int acc_X = (((int)result[0]) << 8) | result[1];   int acc_Y = (((int)result[2]) << 8) | result[3];   int acc_Z = (((int)result[4]) << 8) | result[5];     // Temperatur sensor   int temp = (((int)result[6]) << 8) | result[7];     // Gyroskopesensor   int gyr_X = (((int)result[8]) << 8) | result[9];   int gyr_Y = (((int)result[10]) << 8) | result[11];   int gyr_Z = (((int)result[12]) << 8) | result[13];     // Ausgabe   Serial.print("ACC X:\t");   Serial.print(acc_X); Serial.print("\t");   Serial.print("Y:\t");   Serial.print(acc_Y); Serial.print("\t");   Serial.print("Z:\t");   Serial.print(acc_Z); Serial.print("\t");   Serial.print("Temperatur:\t");   Serial.print(temp); Serial.print("\t");   Serial.print("Gyroskope X:\t");   Serial.print(gyr_X); Serial.print("\t");   Serial.print("Y:\t");   Serial.print(gyr_Y); Serial.print("\t");   Serial.print("Z:\t");   Serial.print(gyr_Z); Serial.println("\t"); } void SetConfiguration(byte reg, byte setting) {    // Aufruf des MPU6050 Sensor   Wire.beginTransmission(sensor_address);   // Register Aufruf   Wire.write(reg);   // Einstellungsbyte für das Register senden   Wire.write(setting);   Wire.endTransmission(); }

Kurzfassung für den Sensor Aufruf, ohne weitere Library.

Mit dem Quellcode wird der Sensor mit den Standardwerten initialisiert, so dass die Empfindlichkeit des Gyroskop bei 250°/s und der Beschleunigungssensor bei 2g liegt. Steht der Sensor still auf dem Tisch sollten die Werte für das Gyroskop und den Beschleunigungssensor für X und Y Achse nahe bei 65536 oder 0 liegen. Beschleunigung auf der Z-Achse bei ca. 16000.

Ausgabe über dem Arduino Monitor

Ich hoffe, ich konnte somit dem einen oder anderen mit diesem kleinen Bespiel weiterhelfen. Bei Fragen kann gerne die Kommentarfunktion verwendet werden.

Anschluss Beschreibung:

• Arduino Nano 3.0 – Pin4 –> MPU6050 Pin SDA
• Arduino Nano 3.0 – Pin5 –> MPU6050 Pin SCL
• Arduino Nano 3.0 – Pin5V –> MPU6050 Pin VCC
• Arduino Nano 3.0 – PinGND –> MPU6050 Pin GND

 

Zuletzt geändert 20.11.2014

LED 8x8 Matrix (Rot/Grün) Schaltung

Die LED 8x8 Matrix an meiner Schaltung.

So einige wie ich haben seltsamerweise kein Dokument zu der LED Matrix im Internet gefunden. Letzten Endes habe ich dann selbst durch einiges Prüfen herausgefunden, welcher Pin nun für welche Funktion ist. Anschließend konnte ich dann einen Versuchsaufbau starten, der allerdings aufwendiger wurde. Auf den ersten Blick sieht meine Schaltung mit den vielen Kabeln ziemlich unüberschaubar aus. Dennoch habe ich den Aufbau mal wieder aus dem Kopf heraus zusammengesteckt, woran man sieht, dass diese Schaltung nicht sonderlich kompliziert sein kann.

Die Verwendeten ICs. Shiftregister, 2x Demultiplexer und 2x Inverter

Für die Schaltung habe ich Folgendes verwendet:

• LED 8x8 Matrix (Rot/Grün)
• Shiftregister (74hc595)
• 2x Demultiplexer (74HC154)
• 2x Inverter (74F04)
• 8x Widerstände (150 Ohm)
• 2x kurze Breadboards
• 1x langer Breadboard
• und viel Kabel zum Verbinden

Der Netduino wird hier als Steuereinheit verwendet, auf dem später meine Library “Game of Life” läuft.

Der Shiftregister ist entscheidend für die Darstellung an der LED-Matrix, da diese Einheit den Zustand der Demultiplexer schaltet, wenn alle 8 Bits gesetzt wurden. Im meinem ersten Versuch habe ich die zwei Demultiplexer direkt am Netduino angeschlossen. Hierbei wurden mehrere LEDs als gesetzt geschaltet. Der Fehler ließ sich jedoch nachvollziehen. In einer Methode habe ich die 8 Ausgänge geschaltet, die sehr zeitnah nacheinander ausgeführt werden. Leider war dieser Vorgang nicht schnell genug, so dass sich während dieser Zeit auch andere Schaltzustände ergaben. Zwar leuchten die nicht gesetzten LEDs nicht hell, aber dennoch stört dieser Zustand.

Schaltbild von der LED Matrix.

An der LED Matrix sind insgesamt 24 Pins und deswegen sind es zum Anschließen an einen einzelnen Netduino oder Arduino zu viel. Abhilfe schafft hier der Demultiplexer, der mit seinen 4 Eingängen bis zu 16 Zustände annehmen kann. Da einer nicht reicht, kommt ein zweiter hinzu, und wenn man diese in eine Matrix einbindet, dann können bis zu 256 Zustände erreicht werden. Den ersten Demultiplexer verwende ich für die 8 Reihen Rot und 8 Reihen Grün. Der zweite ist für die 8 Zeilen, die vorher durch einen Inverter geschaltet werden. Grund hierfür sind die Signale an den Demultiplexerausgängen, die negiert sind. Die Widerstände teilen die Spannung auf und trimmen die Stromaufnahme bei 20mA. Jedoch hier der Hinweis, dass ich die Spannung der LEDs auf 2.0V schätze. Also ergibt sich aus meiner Rechnung, dass am Widerstand 3V anliegen sollten. Mit der Grundformel R=U/I erhält man den benötigten Widerstandswert von 150Ohm. Im folgenden habe ich mir aus meinem Beispiel ein Schaltbild in Eagle erstellt. Was hier allerdings nicht so schön ist,ist dass die Last von den LEDs direkt an den ICs liegt. Also ist diese Schaltung aus diesem Grunde nur experimentell und nicht für den Dauerbetrieb geeignet. 

Gesamtes Schaltbild, ohne Netduino.

Nun ein bisschen Quellcode zum Ende, den ich jedoch von Netduino.com abgeschrieben und etwas abgeändert habe. Ich empfehle auf der Seite nachzuschauen, falls die Verbindungen mit Shiftregister und Netduino unklar sein sollten.

private static OutputPort _Data = new OutputPort(Pins.GPIO_PIN_D0, false); private static OutputPort _Clock = new OutputPort(Pins.GPIO_PIN_D1, false); private static OutputPort _Latch = new OutputPort(Pins.GPIO_PIN_D2, false); /// Code von der Seite Netduino /// Der Besipeil code und ein Schaltbild private static void UpdateLEDs(int value) {     _Latch.Write(false);     for (int i = 0; i < 8; i++)     {         int bit = value & 0x80;         value = value << 1;         if (bit == 128)         {             _Data.Write(true);         }         else         {             _Data.Write(false);         }         _Clock.Write(true);         //Thread.Sleep(1);         SleepWhile(5);         _Clock.Write(false);     }     _Latch.Write(true); } /// Dient als Ersatz zu Thread.Sleep private static void SleepWhile(int count) {     for (int i = 0; i < count; i++){ } }

Members und die Methode für das ansteuern des Shiftregister.

Wird nun an der Methode ein Wert zwischen 0 und 255 übergeben, wird die entsprechende Bit Einstellung am Shiftregister gesetzt. Dieser steuert die zwei Demultiplexer, die wiederum mit der LED Matrix verbunden sind und die entsprechende LED leuchtet.

Normalerweise würde man hier einen LED Matrix Treiber verwenden, um sich die umfangreiche Verkabelung zu sparen. Jedoch möchte ich zeigen, dass es auch andere Lösungen gibt und hoffe, dass dieses Bespiel dem einen oder anderen weiterhilft.

Mein Beispiel mit “Game of Life” und einem Gleiter.

UART WiFi Server Client Module kann auch senden

Netduino Plus, Shield, WiFi Module und der Sensor

Diesmal möchte ich ein Beispiel beschreiben, in dem nicht der Netduino der Empfänger ist, sondern der Sender, ohne dass auf die Serverfunktion verzichtet werden muss. Der Quellcode vom letzten Blog-Post wird an Server und Client seitig erweitert. Am Server (Netduino) Quellcode ist dies sogar recht simpel, da man an dieser Stelle nur vier weitere Zeilen Code hinzufügen muss:

while (true) {       byte[] message = Encoding.UTF8.GetBytes("DateTime: " + DateTime.Now.ToString());       _SerialPort.Write(message, 0, message.Length);       Thread.Sleep(1000); }

Relativ simpel fällt der Code für das Senden aus.

In der “While”-Schleife ist nun zu sehen, dass ich die aktuelle Zeit als String wiedergebe und anschließend in ein Byte Array umwandle, um es für den Schreibvorgang vorzubereiten. Die “Write”-Methode selbst erledigt den Rest und gibt den Inhalt an das WiFi Modul weiter.

Am Client jedoch ist ein wenig mehr Arbeit notwendig. Wenn die Daten ankommen, muss auch ein Event erfolgen, um die Daten zu verarbeiten und schließlich an die Anwendung auszugeben.

Das Programm mit einem zusätzlichen TextBlock für den Empfang.

Für den Empfang der PC Anwendung habe ich eine recht einfache Lösung verwendet, die auch leicht nachvollziehbar ist. Leider ist diese aber nicht ideal, da es eventuell zur Vollauslastung kommt, wenn hier die Schleife nicht etwas gebremst wird. Ein besseres Beispiel gibt es auf MSDN, wie hier mit Hilfe der Socket Klasse ein Event erstellt werden kann.

Nun zur Erweiterung in der Client Socket Klasse, wo eine weitere Methode später im Thread ausgeführt wird. Die Thread-Klasse selbst kommt in den Member Bereich mit dem Namen “_ThreadWaitReceive”. Der Grund hierfür ist, dass später beim Schließen der Klasse der Thread beendet werden muss. Sonst läuft der Thread weiter, obwohl die Anwendung selbst lange beendet wurde.

private Thread _ThreadWaitReceive; private void WaitReceive(object obj) {      byte[] buffer = new byte[1024];      while (_Socket != null && buffer.Length > _Socket.Receive(buffer, SocketFlags.None))      {           string message = Encoding.UTF8.GetString(buffer).Replace('\0', ' ').Trim();           ReceiveEvent(message);           buffer = new byte[1024];      } }

Die zusätzliche Methode für den Empfang.

Mit der Encoding wird der String eingelesen und über die Methoden Replace() und Trim()  werden die leeren Inhalte gefiltert. Mit der folgenden Zeile wird dann der Inhalt an die Event Methode übergeben.

public delegate void NetworkReceiveEventHandler(object sender, NetworkStatusEventArgs e); public event NetworkReceiveEventHandler NetworkReceiveEvent; public virtual void ReceiveEvent(string message) {     if (NetworkReceiveEvent != null & !string.IsNullOrEmpty(message))     {          NetworkReceiveEvent(this, new NetworkStatusEventArgs(message.Trim()));     } }

Die Methode, mit Handler und Event.

Mit dem Event geht es weiter an die Oberfläche, um den Inhalt des Empfang in einem TextBlock lesen zu können.

public MainWindow() {     InitializeComponent();     _Client.NetworkReceiveEvent += new ClientController.NetworkReceiveEventHandler(_Client_NetworkReceiveEvent); } private void _Client_NetworkReceiveEvent(object sender, NetworkStatusEventArgs e) {     Dispatcher.BeginInvoke(new WriteReceiveHandler(WriteReceive), new object[] { e.Message }); } private delegate void WriteReceiveHandler(string message); private void WriteReceive(string message) {     textBlockDataReceive.Text = message; }

Event zugewiesen, Handler für die Oberfläche und Methode, um in die Textbox zu schreiben.

Mit ein paar Code Zeilen Ergänzungen ist nun die PC Anwendung und der Netduino imstande, in beide Richtungen zu kommunizieren. Sicherlich gibt es hier etwas besseres, als sich nur das DateTime anzuzeigen.

Wie bereits zuvor gibt es wieder das Ganze in zwei fertigen Solutions, mit den Quelltexten und natürlich auch den Kommentaren.

Die Solutions für den Download:

• Für den Netduino und UART WiFi Server.
• Windows Client