UART WiFi Server Client Module am Netduino

Netduino Plus, Shield, WiFi Module und der Sensor MPU6050

Bereits letztes Jahr habe ich einen Post darüber geschrieben, wie dieses Modul eingerichtet wird und mit einem Arduino verwendet werden kann. Schon lange ist es daher überfällig, dass ich auch ein Bespiel mit dem Netduino schreibe. Aber bevor ich darüber schreiben konnte, musste ich so einige Versuche anstellen.

Zuvor war das Ergebnis, dass über dem Webbrowser ein “Hello World!” auf dem Browser erschien. Diesmal kommt ein Beispiel auf dem Netduino,  das den Text im Debugger anzeigt. Leider ist es beim dem WiFi Modul nicht möglich mit der Socket Klasse zu arbeiten, so dass uns nur die serielle Verbindung bleibt. Und zugegeben, wie ich später herausfand, funktioniert dies besser und einfacher, als ich erwartet hatte.

Mein neuer Netduino Shield für WiFi Modul und Sensor

Zunächst die Verkabelung, wofür ich meinen Netduino Plus und einen neuen (eigens erstellten) Shield verwende, mit dem ich nun den Sensor und das WiFi Modul aufstecken kann. Es ist noch nicht fertig, reicht aber für dieses Beispiel aus. Kommen wir zu ein wenig Quellcode.

using System.Threading; using SecretLabs.NETMF.Hardware.NetduinoPlus; using System.Text; using System.IO.Ports; using Microsoft.SPOT; namespace SerialPortExample {     public class Program     {         private static SerialPort _SerialPort;         public static void Main()         {             Thread.Sleep(6000);             _SerialPort = new SerialPort(SerialPorts.COM2, 115200);             _SerialPort.DataReceived += new SerialDataReceivedEventHandler(_SerialPort_DataReceived);             _SerialPort.Open();            while (true)            {                Thread.Sleep(1000);            }         }         private static void _SerialPort_DataReceived(object sender, SerialDataReceivedEventArgs e)         {             SerialPort sp = (SerialPort)sender;             byte[] buffer = new byte[sp.BytesToRead];             if (sp.Read(buffer, 0, buffer.Length) > 1)             {                 char[] ca = Encoding.UTF8.GetChars(buffer);                 string reading = string.Empty;                foreach (char item in ca)                 {                     reading += item.ToString();                 }                 Debug.Print(reading);             }         }     } }

Inhalt aus der Program.cs klasse. Das “public Class” herum und using

Dieser Code Ausschnitt reicht bereits aus, um Daten vom WiFi Modul zu lesen, die empfangen wurden. Zwei Sachen sind hier nur wichtig: An welchen COM Port habe ich mein Modul angeschlossen? Und mit welcher Baud Rate wird kommuniziert?

Kommen wir zum nächsten Punkt. Damit die Daten beim WiFi Modul ankommen, brauche ich einen Client zum Senden. Grundsätzlich reicht ein Browser aus, um Daten per Http zu versenden. Einfach in der Adresszeile die IP Adresse und Port Nummer des WiFi Moduls eingeben und dahinter den gewünschten Inhalt. Falls dies nicht klappen sollte, dann noch ein “Http://” davor schreiben, da es vorkommen kann, dass die Integrierte Suchmaschine startet.

Eingabe in die Adresszeile des Browsers.

Sieht man sich die Ausgabe im Debugger an, so sieht das doch nach relativ viel aus. Neben dem Text “Test”, sind noch viele anderen Informationen übermittelt worden. Ob die Daten gebraucht werden, ist vom Projekt abhängig und ich denke, für den Anfang möchte man einfach nur den Text haben.

“Debug.Print” Ausgabe

Daher ist es sinnvoll hier gleich einen eigenen Windows Client zu schreiben, der einfach nur den Text übermittelt und das geht mit Hilfe der der Socket Klasse. Mein neues Beispiel ist ähnlich wie aus meinem Blog Post zu “(Teil 1) Netzwerkverbindung zwischen Windows Phone 7 und Netduino Plus”, nur dass dieses mal eine Anwendung auf dem PC geschrieben wird.

using System; using System.Net.Sockets; using System.Threading; using System.Net; namespace NetworkClient {     public class ClientController     {         private Socket _Socket = null;         private int _Timeout = 5000;         private Thread _Thread;         private ManualResetEvent _ClientDone = new ManualResetEvent(false);         private string _OperationResult = string.Empty;         public string Connect(string hostAddress, int port)         {             _Socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);             _Socket.ConnectAsync(                 CreateOperationEvent(                 new DnsEndPoint(hostAddress, port)));             _ClientDone.WaitOne(_Timeout);            return _OperationResult;         }         public void Send(byte[] data)         {            if (_Thread == null || !_Thread.IsAlive)             {                 _Thread = new Thread(new ParameterizedThreadStart(Send_InThread));                 _Thread.Start(data);             }         }         private void Send_InThread(object obj)         {             SocketAsyncEventArgs socketEvent = CreateOperationEvent(_Socket.RemoteEndPoint);             socketEvent.SetBuffer((byte[])obj, 0, ((byte[])obj).Length);             _Socket.SendToAsync(socketEvent);             _ClientDone.WaitOne(_Timeout);             StatusEvent(_OperationResult);         }         private SocketAsyncEventArgs CreateOperationEvent(EndPoint remoteEndPoint)         {             _OperationResult = "Operation Timeout";            SocketAsyncEventArgs socketEvent = new SocketAsyncEventArgs();             socketEvent.RemoteEndPoint = remoteEndPoint;             socketEvent.Completed += new EventHandler<SocketAsyncEventArgs>(delegate(object s, SocketAsyncEventArgs e)             {                 _OperationResult = e.SocketError.ToString();                 _ClientDone.Set();             });             _ClientDone.Reset();             return socketEvent;         }         public void Close()         {             if (_Socket != null)             {                 if (_Socket.Connected)                 {                     _Socket.Disconnect(true);                     _Socket.Close();                 }             }         }         public bool IsSending         {             get             {                 if (_Thread != null && _Thread.ThreadState == ThreadState.Running)                 {                     return true;                 }                 return false;             }         }         public bool IsConnected         {             get {            try{ return _Socket.Connected; }             catch{ return false; }                   }         }         public delegate void NetwokrStatusHandler(object sender, NetworkStatusEventArgs e);         public event NetwokrStatusHandler NetworkStatus;         public virtual void StatusEvent(string message)         {             if (NetworkStatus != null)             {                 NetworkStatus(this, new NetworkStatusEventArgs(message));             }         }     } }

Klasse für eine Client Verbindung (Achtung, Eventklasse ist hier nicht gepostet, siehe Download)

Die Client Klasse unterscheidet sich kaum von der Client Klasse, die ich für das Windows Phone 7 bereits verwendet habe. Daher waren nur wenige Änderungen notwendig, um den Programmcode für den PC tauglich zu machen. Natürlich werde ich wieder hier den Quellcode mit Kommentaren als Download zur Verfügung stellen.

Beispiel Anwendung das über Socket Klasse den Text übermittelt.

Ergebnis des Empfangenen Text.

Leider ist das Beispiel nur für das Debuggen geeignet, es sei denn, am Netduino wird ein Display angeschlossen, das den Text ebenfalls wiedergeben kann. Aber mit etwas Kreativität findet sich sicherlich ein passendes Projekt zum umsetzen.

Ein kleiner Hinweis. Je nach dem, wie der Puffer eingestellt ist, kann ein Text abschneiden, der gesendet wurde. Das bedeutet, dass ggf. der Netduino am Serial Port, die Event Methode für den Empfang mehrmals aufgerufen wird.

Die Dateien für den Download:

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

MPU6050 Sensor auslesen mit dem Netduino

Netduino mit Shield - Aufsatz, für Sensor und Reglern

Für mein Quadrocopter Projekt habe ich vor einigen Monaten einen zusätzlichen Sensor benötigt, da ich mit einem Beschleunigungssensor allein Schwierigkeiten hätte, das Gleichgewicht und die Lage festzustellen. Um dies etwas kompakter zu gestalten, fand ich im Internet das MPU6050 Sensor Modul, das einen Beschleunigungssensor und Gyroskopsensor auf einem Chip hat. Über Ebay erhält man das Modul zu einem günstigen Preis, man muss allerdings mit einer gewissen Wartezeit rechnen, so ca.. 3-4 Wochen.

MPU6050 (Die Platine selbst, scheint für verschieden Sensor Typen gedacht zu sein, wegen der Aufschrift MPU-x050)

Im Arduino Umfeld scheint der Sensor seine Verbreitung gefunden zu haben. Das dürfte auch an der fertigen Library liegen, womit sich in nur wenigen Codezeilen der Sensor für seine eigenen Projekte einbinden lässt . Eine bereitgestellte Lösung für Netduino gab es dafür nicht, was mich um so mehr dazu bewegt hat, hierfür eine Lösung zu finden.

Der Sensor verbunden mit dem Arduino Nano 3.0

Mein Ansatz war, den verfügbaren Code in C++ nach C# und .Net Micro Framework zu portieren. Das hieß viele Stunden Quellcode und Dokumentation zum Sensor lesen. Die Dokumentation befasst sich überwiegend mit den Befehlen des Mikroprozessors vom Sensor, was aber anhand der Beschreibung nur schwer nachvollziehbar ist. Überwiegend hat mir der Quellcode selbst am weitesten geholfen, um die Prozessreihenfolge zu verstehen. Am Anfang funktionierte der Code nur teilweise und ich bekam einfach keine brauchbaren Daten. Mehrmals kontrollierte und überarbeite ich das Initialisieren des Sensors über die Monate hinweg. Dazu muss ich hinzufügen, dass ich nur wenig Zeit hatte.

Unregelmäßige Werte vom Sensor. (Ausgabe Wert wird hier verkürzt dargestellt zwischen 0 bis 100)

Bis gestern dachte ich, dass ich mit dem Initialisieren den falschen Byte Wert verwendet habe. Es stellte sich heraus, dass ich bereits beim Einbinden des Sensors über den I²C Bus richtig gelegen hatte. Eine fehlende Codezeile, die ich an einer anderen Stelle gesetzt habe, wirkte Wunder. Also wichtiger Hinweis: “Bevor die Werte gelesen werden können, muss der erste Bytewert zunächst an den Sensor geschrieben werden.” Anschließend bekam ich endlich konstante und brauchbare Daten.

Stabile Werte, die sich erst verändern, wenn ich den Sensor bewege.

Nun käme normalweise der Punkt, wo ich nun endlich den Quellcode posten würde. Stattdessen hänge ich einen link an, und biete dieses als Download an, da sich der Blogeintrag zu sehr in die länge ziehen würde.
Beispiel Solution für den Sensor MPU6050

Hinweis zum Beispiel Quellcode:

• Der Quellcode dient als Beispiel und ist daher keine Lösung
• Soweit ich konnte, habe ich überall Kommentare eingetragen
• Ich bin für Fragen und (sinnvolle) Kritik offen

Nachtrag (07.07.2013):

Zu dem Thema habe ich eine neuen Blog Post veröffentlicht

Wie hoch ist die Spannung auf dem Netzwerkkabel?

Um sicherzugehen habe ich die Spannung auf dem Oszilloskop  gemessen. Pro Rasterfeld Y sind 0,5V und für X zwischen 1 bis 50 Nano Sekunden.

Seit einigen Wochen frage ich mich schon, welche Spannungen auf dem Netzwerkkabel zur Datenübertragung verwendet werden. Hierbei spreche ich vom gängigen Netzwerkanschluss über RJ45 für den Hausgebrauch.
Bevor ich herausfand, dass nur +/-1 Volt anliegen, dachte ich, es sei wesentlich mehr. Verunsichernd sind die gefährlichen Aussagen im Internet, wo man fast jede Spannungshöhe findet. Es kamen 5V, 15V, 48V und sogar 90V waren dabei. Zugegeben, ich läge wahrscheinlich schon im Grab und andere sicher auch, wenn ich mal zufällig die Kontakte berührt hätte, aus welchen Gründen auch immer. Jedoch kann ich berichten, dass ich schon das eine oder andere Mal einen elektrischen Schlag erhalten habe. Es liegt daher nahe, dass viele Menschen hier eine höhere Spannung vermuten.

Ein aufgeschnittenes Netzwerkkabel ermöglichte die Messung am Netzwerkkabel.

Hätte ich gleich nach den IEEE Standard gesehen, wäre mir für diese einfache Frage eine lange Suche erspart geblieben. Wobei ich das mehr überflogen habe als gelesen. Denn schließlich fasst die Dokumentation für den IEEE 802.3 Standard über 600 Seiten.

Die selben Einstellungen, allerdings mit einer Verbindung zwischen meinem Netduino und dem Access Point

Aber warum interessiert mich die Spannung auf dem Netzwerkkabel?
Es gibt einige Geräte, die laufen nicht mit +/-1 Volt, sondern mit +/-0,5 Volt. Dies stellte ich bereits im Sommer fest, als ich versuchte, eine Verbindung zwischen meinem Netduino und zu meinem Access Point über eine Kabelverbindung herzustellen. Es stellte sich heraus, dass beide auf der niedrigen Spannung arbeiten und somit keine wirkliche Kommunikation stattfinden konnte. Bei beiden Geräten wird ein normal betriebener Netzwerkanschluss vorausgesetzt.

Spannungsmessungen mit dem Oszilloskop.

Die Lösung ist, einen Switch dazwischen zu schalten. Und hier das “Aber”. Das sollte möglichst alles Mobil sein, also für eine Fernsteuereinheit, das ich für die Entwicklung meines Quadrocopter benötige. Momentan habe ich tatsächlich einen Switch, jedoch suche ich nach einer Verstärker Möglichkeit.

Derzeitig noch mit Montiert, würde jedoch gerne die paar Gramm einsparen.

Vielleicht muss ich mir auch einfach einen anderen Access Point suchen, der nicht auf diesen Sparfunktionen arbeitet und somit auch für das Projekt brauchbar wird.

(Teil 2) Netzwerkverbindung zwischen Windows Phone 7 und Netduino Plus

Netduino und WP7 Anwendung

Im ersten Teil zeigte ich eine Client Anwendung für Windows Phone 7. Damit sich die App auch verbinden kann, brauchen wir noch ein wenig Code für den Netduino.
Wer sich mit der Socket Klasse für Windows Phone 7 auseinandergesetzt hat, wird sicherlich darauf gestoßen sein, dass nur eine Client Anwendung geschrieben werden kann (ab Mango Update). Jedoch ist das nicht weiter schlimm, da wir den Netzwerk Server auf dem Netduino schreiben können, was auch im nachhinein sinnvoller ist.

WP7 Handy, Netduino Plus und Servo

Auch hier habe ich wieder den Code auf (fast) das Wesentlich reduziert. Die Rückantwort an den Client, um den Empfang zu bestätigen, fällt hier weg. Wer später daraus eine Fernsteuerung programmiert, muss ohnehin darauf verzichten, und eher eine Fehlerbehandlung schreiben.
Der gesamte Code für den Netduino fällt wesentlich kürzer aus. Das liegt mitunter daran, dass im .NET Micro Framework nicht alles übernommen wurde, wie im herkömmlichen .NET Framework.
Die Netzwerkserver Klasse, mit der später die Daten empfangen werden.

   1: public class NetworkServerSocket

   2: {

   3:     /// <summary>

   4:     /// Legt die Anzahl der Verbindungen in der Warteschlange fest.

   5:     /// </summary>

   6:     private const int _Backlog = 5;

   7:     /// <summary>

   8:     /// Legt den zu empfangenen Puffer fest

   9:     /// </summary>

  10:     private const int _BufferSize = 1024;

  11:     /// <summary>

  12:     /// Wartet auf eine Anfrage des Client und stellt schließlich die Verbindung her.

  13:     /// </summary>

  14:     public void StartHost()

  15:     {

  16:         // Port festlegen

  17:         int serverPort = 1200;

  18:  

  19:         // Initialisiert die Socket Klasse mit 

  20:         // den Einstellungen für ein TCP Verbindung

  21:         Socket serverSocket =  serverSocket = new Socket(

  22:             AddressFamily.InterNetwork, 

  23:             SocketType.Stream, 

  24:             ProtocolType.Tcp);

  25:  

  26:         // Assoziiert den Socket mit einem lokalen Endpunkt

  27:         serverSocket.Bind(new IPEndPoint(IPAddress.Any, serverPort));

  28:  

  29:         // Versetz den Socket in den aktiven Abhörmodus

  30:         serverSocket.Listen(_Backlog);

  31:  

  32:         // Puffergröße festlegen

  33:         byte[] receiveBuffer = new byte[_BufferSize];

  34:  

  35:         // Zählt später, wie viele Bytes empfangen wurden

  36:         int countByteReceived;

  37:  

  38:         while (true)

  39:         {

  40:             // Zweiten Socket als Client anlegen.

  41:             // Dient dazu, die Anfrage vom Client zu verarbeiten.

  42:             Socket client = null;

  43:  

  44:             // Bleibt solange bis eine eigene Nachricht eingeht.

  45:             client = serverSocket.Accept();

  46:  

  47:             // Legt später fest, wieviele Bytes gesendet wurden

  48:             int totalBytesEcho = 0;

  49:  

  50:             // Schleife für den Empfang der Datenübermittlung

  51:             while ((countByteReceived = client.Receive(receiveBuffer, 0, receiveBuffer.Length, SocketFlags.None)) > 0)

  52:             {

  53:                 // Event senden

  54:                 NetworkMessage(receiveBuffer);

  55:                     

  56:                 // Anzahl Bytes summieren

  57:                 totalBytesEcho += countByteReceived;

  58:  

  59:                 // Buffer zurücksetzen

  60:                 receiveBuffer = new byte[_BufferSize];

  61:             }

  62:  

  63:  

  64:             // Es gibt hier kein Shutdown

  65:             // Schließe die Verbindung

  66:             client.Close();

  67:         }

  68:     }

  69:  

  70:     

  71:     public delegate void NetworkMessageEvent_Handler(object sender, NetworkMessageEventArgs e);

  72:     public event NetworkMessageEvent_Handler NetworkMessageEvent;

  73:     /// <summary>

  74:     /// Event senden

  75:     /// </summary>

  76:     /// <param name="byteMessage"></param>

  77:     public virtual void NetworkMessage(byte[] byteMessage)

  78:     {

  79:         if (NetworkMessageEvent != null)

  80:         {

  81:             NetworkMessageEvent(this, new NetworkMessageEventArgs(byteMessage));

  82:         }

  83:     }

  84: }

Dazu wieder ein Event, damit immer nach einem Datenempfang ein neuer Stellwert gesetzt wird.

   1: public struct NetworkMessageEventArgs

   2: {

   3:     public byte[] ByteMessage;

   4:  

   5:     public NetworkMessageEventArgs(byte[] byteMessage)

   6:     {

   7:         ByteMessage = byteMessage;

   8:     }

   9: }

Das Protokoll, das ich bereits für die WP7 App angelegt habe, kann vollständig übernommen werden. Jedoch muss eine weitere Methode (die ich hier ToString benannt habe) hinzugefügt und der Konstruktor für die Übergabe des Byte Array angepasst werden.

   1: /// <summary>

   2: /// Ein Objekt, das als Protokol für die Übertragung verwendet wird.

   3: /// Der Inhalt kann beliebig erweitert werden. 

   4: /// Im Beispiel wird zunächst ein Wert übermittelt.

   5: /// </summary>

   6: public struct NetworkProtocolRemote

   7: {

   8:     /// <summary>

   9:     /// Die Variable zum festlegen des Stellwertes.

  10:     /// </summary>

  11:     private int _ServoValue;

  12:     /// <summary>

  13:     /// Initialisiert das Protokol mit Variablen.

  14:     /// </summary>

  15:     /// <param name="onVocabulary"></param>

  16:     public NetworkProtocolRemote(int servoValue)

  17:     {

  18:         _ServoValue = servoValue;

  19:     }

  20:     /// <summary>

  21:     /// Empfangenes Byte Array wird eingelesen und befüllt die Variablen.

  22:     /// </summary>

  23:     /// <param name="receive"></param>

  24:     public NetworkProtocolRemote(byte[] receive)

  25:     {

  26:         _ServoValue = 0;

  27:  

  28:         SetProperties(ToString(receive));

  29:     }

  30:     /// <summary>

  31:     /// Überstezt das Byte Array in einen String.

  32:     /// Ist leider nicht im .NET Micro Framework vorhanden.

  33:     /// </summary>

  34:     /// <param name="receive"></param>

  35:     /// <returns></returns>

  36:     public static string ToString(byte[] receive)

  37:     {

  38:         // Kann nur in ein Char Array umgewandelt werden.

  39:         // Im .NET Micro gibt es keine GetString Methode

  40:         char[] caValues = Encoding.UTF8.GetChars(receive);

  41:         string protocol = string.Empty;

  42:         for (int i = 0; i < caValues.Length; i++)

  43:         {

  44:             protocol += caValues[i].ToString();

  45:         }

  46:         return protocol;

  47:     }

  48:     /// <summary>

  49:     /// Der Inhalt des empfangenen Protokols wird in den Variablen festlegt.

  50:     /// </summary>

  51:     /// <param name="protocol"></param>

  52:     public void SetProperties(string protocol)

  53:     {

  54:         // Das Protokol kann um weitere Variablen erweitert werden,

  55:         // daher habe ich hier eine Schleife eingesetzt, 

  56:         // um hier die Variablen festzulegen.

  57:         foreach (string item in protocol.Split(';'))

  58:         {

  59:             string[] sa = item.Split(':');

  60:  

  61:             switch (sa[0])

  62:             {

  63:                 case ("ServoValue"):

  64:                     {

  65:                         _ServoValue = Convert.ToInt16(sa[1]);

  66:                         break;

  67:                     }

  68:                 default:

  69:                     {

  70:                         break;

  71:                     }

  72:             }

  73:         }

  74:     }

  75:     /// <summary>

  76:     /// Gibt den Inhalt des Objektes als Byte Array zurück

  77:     /// </summary>

  78:     /// <returns></returns>

  79:     public byte[] GetRemoteToByte()

  80:     {

  81:         string content = string.Empty;

  82:  

  83:         content += "Vocabulary:" + _ServoValue + ";";

  84:  

  85:         // Wenn weitere Werte übermittelt werden sollen,

  86:         // dann sollte die Sendung immer aus dem 

  87:         // Namen des Wertes, das mit dem Trennzeichen

  88:         // Doppelpunkt zum Wert und schließlich mit 

  89:         // Semikolon abgeschlossen wird.

  90:         // Beispiel:

  91:         //  IrgendEinWert:123;IrgendWasWert:456;

  92:  

  93:         return Encoding.UTF8.GetBytes(content);

  94:     }

  95:     /// <summary>

  96:     /// Ruft den Wert des Servos ab oder legt diesen fest.

  97:     /// </summary>

  98:     public int ServoValue

  99:     {

 100:         set { _ServoValue = value; }

 101:         get { return _ServoValue; }

 102:     }

 103: }

Zuletzt kommt die Program.cs Klasse, um den Server auch starten zu können. Dazu gehört natürlich auch das Initialisieren für einen PWM Port, um den Servo später anzusteuern und auch die Übergabe des Einstellwertes über die Event Methode.

   1: public class Program

   2: {

   3:     /// <summary>

   4:     /// Ein PWM Signal erzeugen, um den Servo anzusteuern.

   5:     /// </summary>

   6:     private static PWM _ServoForControl;

   7:     /// <summary>

   8:     /// Server Klasse initialisieren

   9:     /// </summary>

  10:     private static NetworkServerSocket _Server = new NetworkServerSocket();

  11:     private static NetworkProtocolRemote _Protocol;

  12:  

  13:     public static void Main()

  14:     {

  15:         // Initialisiere PWM Klasse und lege den Pin Ausgang fest.

  16:         _ServoForControl = new PWM(Pins.GPIO_PIN_D5);

  17:  

  18:         // Puls Signal festlegen als Ausgangspunkt

  19:         _ServoForControl.SetPulse(20000, 1500);

  20:  

  21:         // Event hinzufügen für den Empfang

  22:         _Server.NetworkMessageEvent += new NetworkServerSocket.NetworkMessageEvent_Handler(server_NetworkMessageEvent);

  23:  

  24:         // Server in eigenem Thread starten.

  25:         new Thread(_Server.StartHost).Start();

  26:     }

  27:     /// <summary>

  28:     /// Wird ausgeführt, wenn neue Daten empfangen wurden.

  29:     /// </summary>

  30:     /// <param name="sender"></param>

  31:     /// <param name="e"></param>

  32:     private static void server_NetworkMessageEvent(object sender, NetworkMessageEventArgs e)

  33:     {

  34:         // Variablen festlegen über das Protokol

  35:         _Protocol = new NetworkProtocolRemote(e.ByteMessage);

  36:  

  37:         // Neuen Wert festlegen am PWM Port

  38:         _ServoForControl.SetPulse(20000, ServoValueToPwmValue(_Protocol.ServoValue));

  39:     }

  40:     /// <summary>

  41:     /// Übersetz den empfangenen Wert zu einer Pulslänge um.

  42:     /// </summary>

  43:     /// <param name="servoValue"></param>

  44:     /// <returns></returns>

  45:     public static uint ServoValueToPwmValue(int servoValue)

  46:     {

  47:         return (uint)System.Math.Round(((double)servoValue / 180) * 2000);

  48:     }

  49: }

So, im Großen und Ganzen war das schon alles, um ein einfaches Bespiel zu erhalten, mit dem sich eine Netzwerkverbindung zwischen Windows Phone 7 und Netduino Plus herstellen lässt.

Netzwerkverbindung zwischen WP7 und Netduino Plus

Zur Veranschaulichung ein Video.

 

Das Ganze habe ich natürlich auch wieder als Visual Studio 2010 Solution vorbereitet:
Netduino Plus Programm Solution - Download