.NET Micro Framework

Das Microsoft .NET Framework in Embedded-Anwendungen

Colin Miller

Laden Sie die Codebeispiele herunter

Es hat sich viel verändert, seitdem der erste kontextsensitive C-Code-Editor Anfang der 80er Jahre veröffentlicht wurde. Tools und Sprachen, die ursprünglich für Desktop-Apps entwickelt wurden, wurden auf Server, die Cloud und andere Umgebungen ausgeweitet. Das Microsoft .NET Framework und Visual Studio bieten Tools auf dem neuesten Stand der Technik, mit denen sich die Effizienz von Programmierern erheblich steigern lässt. Die Tools und Sprachen im .NET Framework bieten umfangreiche Bibliotheken und Tools zur Zusammenarbeit und schützen Programmierer vor den häufigsten Fehlern.

Diese Fortschritte blieben Entwicklern, die an Embedded-Geräten arbeiten, jedoch vorenthalten. Der Markt für Embedded-Tools wies einfach nicht das erforderliche Volumen auf, um Investitionen in der Größenordnung anzuziehen, wie sie in Tools für PC-, Server- und Cloud-Anwendungen getätigt wurden. Die Entwicklung von „intelligenten Geräten“ aus den verschiedensten Bereichen bewirkt nun eine Änderung dieses Ungleichgewichts.

Das .NET Micro Framework hat einen Strom neuer Produkte ausgelöst, darunter auch kleine Geräte, für deren Code-Entwicklung bisher eigene Fertigkeiten für Embedded-Geräte erforderlich waren. Stattdessen wurden diese jetzt von Einzelpersonen und Teams mit .NET-Fertigkeiten entwickelt. Wenn Sie ein .NET-Entwickler sind und schon einmal darüber nachgedacht haben, wie Sie kleine Embedded-Geräte in Ihren Anwendungen nutzen können, wird dieser Artikel Sie hoffentlich davon überzeugen, dass Ihre Fertigkeiten es Ihnen erlauben, aktiv am sich explosionsartig ausweitenden Internet of Things (IoT) und seinen intelligenten Geräten teilzunehmen.

Warum sollte Sie das interessieren? Eine kürzlich durchgeführte Analyse gelangte zu der Einschätzung, dass 94 Prozent der 2017 ausgelieferten Prozessoren nicht über die erforderliche Leistung verfügen werden, um eine traditionelle .NET-Anwendungsumgebung zu unterstützen. Mithilfe des .NET Micro Frameworks können Sie Ihre Reichweite vergrößern.

.NET Micro Framework – Das .NET Micro Framework wurde ursprünglich im Rahmen des SPOT-Uhrenprojekts entwickelt. Es ist jetzt seit 7 Jahren Teil der .NET-Familie. Es kann auf 32-Bit-Prozessoren ausgeführt werden, die zu klein sind, um vollständige Betriebssysteme zu unterstützen. Tatsächlich ist es .NET, das direkt auf der Hardware ausgeführt wird, und das Ausführungsmodul und das Typsystem sind in das ausführbare Image integriert.

Das .NET Micro Framework verfolgt das Ziel, .NET-Entwicklern beim Erstellen von Anwendungen zu helfen, die auf einem kleinen MCU-basierten 32-Bit-Gerät für Embedded-Anwendungen ausgeführt werden. Auf der Build-Konferenz 2014 beschrieb Microsoft eine Reihe von Betriebssystemplattformen, die den IoT-Bereich mit Windows Embedded Standard am oberen Ende und den Bereich der kleinen Geräte mit dem .NET Micro Framework abdecken.

Entwicklung für Embedded

Intelligente Geräte verfügen über lokale Rechenleistung und können mit anderen Geräten und möglicherweise auch mit der Cloud kommunizieren. Für diesen Artikel habe ich einen kleinen mobilen Roboter gebaut, den ich von einem Smartphone aus, das Windows Phone OS ausführt, steuern kann. Das Ziel besteht darin, zu zeigen, wie die .NET-Kenntnisse, die für die Windows Phone-App verwendet werden, genau so auf der Roboterseite angewendet werden können. Die Tools und die Sprachunterstützung stellen für diese Umgebung eine Neuerung dar, und die Entwicklungsumgebung kann nahtlos zwischen den beiden Zielplattformen hin- und herwechseln.

Und hier kommt Bert – Bert ist ein mobiler Roboter mit angetriebenen Rädern (siehe Abbildung 1). Er enthält eine Netduino 2-Hauptplatine, die für ca. 35 $ bei Secret Labs erhältlich ist. Mithilfe eines einfachen Controllers können die Motoren auf beiden Seiten des Roboters für Vorwärts- und Rückwärtsfahrt angesteuert werden. Allerdings gibt es keine Geschwindigkeitssteuerung.

Bert, der Roboter
Abbildung 1 Bert, der Roboter

Für die Kommunikation beinhaltet Bert ein Bluetooth-Modul, das mit dem Netduino Daten über eine serielle Schnittstelle austauscht. Um sicherzustellen, dass Sie Bert nicht in irgendetwas krachen oder einen Abhang hinunterstürzen lassen, gibt es Infrarot-Annäherungssensoren vorne und hinten. Nur zum Spaß gibt es auch Scheinwerfer und Blinker.

Die einfache Windows Phone-App ist aus einer Demo abgeleitet, die auf der Build-Konferenz zu sehen war. Sie stellt eine Verbindung mit dem richtigen Gerät her und verwendet den eingebauten Beschleunigungsmesser, um Bert mithilfe von per Bluetooth gesendeten Befehlen zu steuern. Die Oberfläche ist in Abbildung 2 zu sehen, das Dropdown-Auswahlfeld in Abbildung 3. Wählen Sie „Enumerate“ aus, um das verbundene Gerät auszuwählen, an das Sie die Befehle senden möchten. Die Befehle werden durch die Richtungsbuchstaben auf dem Bildschirm dargestellt.             

Windows Phone App-Oberfläche
Abbildung 2 Windows Phone App-Oberfläche

Dropdownfeld zur Geräteauswahl
Abbildung 3 Dropdownfeld zur Geräteauswahl

Sie können das .NET Micro Framework mithilfe des .NET Micro Framework Porting Kits (bit.ly/1wp57qm) auf andere Hardwareplattformen portieren. Verwenden Sie das Kit, um die Schnittstellen auf niedriger Ebene für die spezifische Hardware, auf der Sie das Programm ausführen möchten, zu erstellen. Das liegt schon näher an den klassischen Aktivitäten des Programmierens für Embedded. Aber wir können Entwarnung geben: Das haben Anbieter Ihnen bereits abgenommen. Die in dieser Anwendung eingesetzte Netduino-Platine ist ein Beispiel für eine Komplettlösung, die alles enthält, um mit dem Entwickeln von Code für die Platine im Netduino SDK (bit.ly/1CQygzz) zu beginnen.

Netduino ist ein Cortex-M3-Prozessor von STMicro mit 192 KB bis 384 KB Flashspeicher und 60 KB bis 100 KB RAM, der zu Arduino-Shields (Erweiterungsplatinen) anschlusskompatibel ist. Andere Geräte, die das .NET Micro Framework unterstützen, finden Sie bei GHI Electronics, Mountaineer, Sparkfun, Adafruit, Amazon und in anderen Stores.

Bei dem Board handelt es sich ebenfalls um Open Source-Hardware, sobald Sie Ihre Anwendung entwickelt haben und sie kommerziell verfügbar machen möchten, haben Sie also mehrere Optionen. Sie können bei kleinen Stückzahlen einfach die Netduino-Platine verwenden, wenn Sie aber auf ein größeres Volumen abzielen oder spezifische Anforderungen bestehen, etwa die Integration weiterer Elektronik auf der gleichen Leiterplatte, können Sie die Open Source-Entwurfsdateien zu einem Platinenhersteller bringen und von dort aus fortfahren.

Da ich von dem Netduino-Board ausgegangen bin, habe ich das Netduino-SDK installiert. Das schließt das .NET Micro Framework-SDK mit Visual Studio-Vorlagen und die Unterstützung aller benötigten Bibliotheken ein. Für andere Entwicklungsboards müssen Sie das .NET Micro Framework-SDK möglicherweise separat installieren. Das SDK enthält einen Emulator, Sie brauchen also keine Hardware anzuschaffen, um mit dem .NET Micro Framework zu experimentieren. Allerdings ermöglicht die Verwendung von Hardware mehr Produktivität, wenn Sie bereits wissen, welche Sensoren Sie einsetzen möchten.

Erstellen der Embedded-Anwendung

Nachdem Sie das Netduino-SDK (das das .NET Micro Framework SDK enthält) installiert haben, erfolgt das Starten einer .NET Micro Framework-Embedded-Anwendung genau so wie das Starten anderer Projekte in Visual Studio. Sie wählen „Neues Projekt“ und den Typ der Anwendung aus, die Sie erstellen möchten. Wie in Abbildung 4 dargestellt, habe ich eine Netduino 2-Anwendung ausgewählt, die der Platine in Bert entspricht.

Beginnen mit einer .NET Micro Framework-Embedded-Anwendung
Abbildung 4 Beginnen mit einer .NET Micro Framework-Embedded-Anwendung

Sobald Sie das Projekt gestartet haben, können Sie direkt in das Erstellen der Kommunikationsverbindung zwischen dem Roboter und dem Smartphone einsteigen. 

Wie viele Embedded-Anwendungen, arbeitet Bert mit Batterien. Das bedeutet, dass Ihr Code den sparsamen Umgang mit Energie berücksichtigen muss. Glücklicherweise sind das .NET Framework und das .NET Micro Framework dafür bestens geeignet. Wenn kein auszuführender Thread vorhanden ist, kann das .NET Micro Framework den Prozessor automatisch in einen niedrigeren Energiezustand versetzen. Es setzt sich auch zunehmend durch, einen effizienten zweiten Prozessor hinzuzufügen, um die Interrupts zu überwachen und den Hauptprozessor in einen noch niedrigeren Energiezustand zu versetzen. Sie werden bald feststellen, ob sich das .NET Framework gut für die Erfordernisse dieser Art von Programmierung eignet.

Der Code in dieser Anwendung wird als Reaktion auf ein externes Ereignis ausgeführt und zwar nur in dem Maß, wie es für die Reaktion erforderlich ist. Sie werden also dafür sorgen, dass die gesamte Ausführung in einem Ereignishandler oder einem Thread enthalten ist, der die meiste Zeit angehalten ist, etwa so:

public class Program
  {
    public static void Main()
    {
      RunRobot myRunRobot = new RunRobot();
      myRunRobot.Start();
      while (true)
      {
        Thread.Sleep(Timeout.Infinite);
      }
    }
  }

Der RunRobot-Konstruktor initialisiert die E/A-Instanzen, die wir uns genauer ansehen werden, und die RunRobot.Start-Methode initialisiert die Interrupts, die die eigentliche Ausführung auslösen:

public void Start()
  {
  // Enable interrupts on BT input on the HC-06 radio
  hc06.DataReceived += hc06_DataReceived;
  // Use onboard button to turn on/off accepting commands
  button = new InterruptPort(Pins.ONBOARD_SW1, false, Port.ResistorMode.Disabled,
    Port.InterruptMode.InterruptEdgeHigh);
  // Start monitoring for button presses
  button.OnInterrupt += new NativeEventHandler(button_OnInterrupt);
  }

Bluetooth betriebsbereit machen 

Drei Schritte sind erforderlich, um die Bluetooth-Kommunikation zwischen Bert und der Windows Phone-App betriebsbereit zu machen:

  1. Verdrahten des Bluetooth-Moduls auf dem Roboter
  2. Senden von Befehlen von der Smartphone-App
  3. Empfangen dieser Befehle auf Bert 

Da Netduino mit Arduino kompatibel ist, können Sie für viele erforderliche Verbindungen einen Shield finden, der alle erforderlichen Verbindungen für Sie herstellt. Der Arduino ist eine beliebte Plattform für Hobbyentwickler, der ein umfangreiches Ökosystem an Peripherieteilen mitbringt. Aus vorhandenen Modulen können Sie eine große Bandbreite von Lösungen entwickeln.

Wenn Sie keine Zeit mit der Verdrahtung verbringen möchten, sehen Sie sich die Gadgeteer-Produkte von GHI Electronics an. Bei diesen Platinen und Komponenten können Sie einen Assistenten verwenden, um zu entscheiden, wie die Komponenten mit den Standardverbindungen verbunden werden müssen (siehe Abbildung 5), Sie brauchen also nicht über Kenntnisse zur Verdrahtung zu verfügen. Die Modulschnittstellen sind auf einem ähnlich hohen Niveau. Wie Arduino verfügt auch Gadgeteer über eine umfangreiche Sammlung von Modulen, mit denen Sie Ihre Lösung erstellen können. Nachdem Sie die Module verbunden haben, sind Sie immer noch in der Code-Entwicklung im .NET Micro Framework. Das ist besonders für das Rapid Prototyping Ihrer Ideen nützlich.

Der Gadgeteer Wizard mit dargestellten Verbindungen
Abbildung 5 Der Gadgeteer Wizard mit dargestellten Verbindungen

Für Bert verwende ich nicht Gadgeteer, sondern stelle eigene Module zusammen.  Das Bluetooth-Modul (HC-06) verwendet eine serielle Schnittstelle mit vier Verbindungen – VIN, GND, RX und TX. Verbinden Sie VIN (Voltage In) wahlweise mit dem 5 V- oder dem 3,3 V-Ausgang des Netduinos, und verbinden Sie anschließend GND mit einer der GND-Verbindungen. Aus der E/A-Tabelle für den Netduino in Abbildung 6 können Sie ersehen, dass Sie das BT-Modul RX (Receive) mit dem Netduino TX (Transmit) und das BT-Modul TX mit dem RX am seriellen COM1-Anschluss verbinden müssen. Bei Bedarf finden Sie im Web Beispiele zum Verbinden dieser Module mit gängigen Microcontrollern.

Definition der Netduino-E/A-Anschlüsse
Abbildung 6 Definition der Netduino-E/A-Anschlüsse

Sind die Verbindungen hergestellt, können Sie den Netduino einschalten (wodurch das BT-Modul mit Strom versorgt wird) und das Gerät mit dem Smartphone koppeln. Der Standardname für das BT-Modul ist HC-06, damit müssen Sie also koppeln. Ich habe den Namen mithilfe von AT-Befehlen in „Bert“ geändert. Senden Sie ein Array aus Bytes mit den Zeichen „AT+NAMEBert“, um den Namen des BT-Moduls zu ändern. Sie können diese Schnittstelle außerdem zum Konfigurieren des Bluetooth-Moduls verwenden, einschließlich Parametern wie der Baud-Rate für die Kommunikation.

Jetzt können Sie das Smartphone zum Herstellen von Verbindungen mit Bert wie mit jedem anderen BT-Gerät verwenden und anfangen, Befehle zu senden. Zuerst greife ich auf den eingebauten Beschleunigungsmesser zu und lege ein sinnvolles Berichtsintervall fest, um den armen Bert nicht absaufen zu lassen:

accelerometer = Accelerometer.GetDefault();
if (accelerometer != null)
{
  uint minReportInterval = accelerometer.MinimumReportInterval;
  desiredReportInterval = minReportInterval > 250 ? minReportInterval : 250; 
    // Slowing this way down to prevent flooding with commands
  accelerometer.ReportInterval = desiredReportInterval;
    // Add event for accelerometer readings
  accelerometer.ReadingChanged += new TypedEventHandler<Accelerometer,
    AccelerometerReadingChangedEventArgs>(ReadingChanged);
}

Der ReadingChanged-Ereignishandler sendet Befehle, wie in Abbildung 7 dargestellt.

Abbildung 7 Der Ereignishandler für das Senden von Befehlen an Bert

AccelerometerReading reading = args.Reading;
if (reading.AccelerationX > .4)  // These are arbitrary levels
                                 // set to what seemed easy
{
                        // Send Right
  if( cmdSent != 'R')   // Don’t resend the same command over and over
  {
      // Update the phone display
    txtRight.Text = "On";
    txtLeft.Text = " L";
    txtForward.Text = " F";
    txtBack.Text = " B";
      // Send the command
    packet = Encoding.UTF8.GetBytes("R");
    cmdSent = 'R';
    SendData(packet);
  }

Installieren und Ausführen von Befehlen

Jetzt können Sie daran denken, auf der Roboterseite einen Befehl zu empfangen. Das BT-Modul ist mit dem ersten seriellen Anschluss am Netduino verbunden. Erstellen Sie eine SerialPort-Instanz und einen Nachrichtenpuffer, genau wie Sie das auch in anderen .NET Framework-Versionen machen würden:

SerialPort hc06;                 // The BT radio
byte[] cmdBuffer = new byte[32]; // The input buffer for receiving commands

Konfigurieren Sie anschließend den seriellen Anschluss für die Kommunikation mit dem Bluetooth-Modul (9600 Baud sind der Standardwert; er lässt sich mithilfe von AT-Befehlen ändern, doch ist die Kommunikation sehr spärlich, um das Programm einfach zu halten, deshalb ist eine höhere Geschwindigkeit unnötig): 

// Set up the Bluetooth radio communication
hc06 = new SerialPort(SerialPorts.COM1, 9600, 
  Parity.None, 8, StopBits.One);
hc06.ReadTimeout = 1000;
hc06.Open();

Anschließend richte ich einen Ereignishandler „DataReceived“ ein, der den größten Teil der Verarbeitung in der App auslöst. Anders gesagt, Bert schläft, bis er einen Befehl erhält. Der Prozessor bleibt lange genug wach, um die Motoren in den richtigen Zustand zu versetzen und legt sich dann wieder schlafen: 

// Enable interrupts on BT input
hc06.DataReceived += hc06_DataReceived;

Eingehende Befehle werden im Ereignishandler verarbeitet, wie in Abbildung 8 dargestellt.

Abbildung 8 – Die eingehenden Befehle, um Bert in Bewegung zu versetzen

do
{
  try
  {
    count = hc06.Read(cmdBuffer, 0, 1);  // Should read one byte at a time
  }
  catch (Exception) { }        // Just eat exceptions
  if (count > 0)
  {
    cmd = (char)cmdBuffer[0];
    executeCmd(cmd);   // Execute command immediately
  }
} while (count > 0);

Dieser Code unterscheidet sich in keiner Weise von dem, den Sie auf einem Desktop einsetzen würden.

Bert in Gang setzen 

Der Motorcontroller, den ich verwende, erfordert, dass den logischen Zustand von vier Eingängen festlege, um zu bestimmen, wie die Räder drehen. Die Logik lautet:

/*        
A2  A1  Motor 1         B2  B1  Motor 2
0   0   Shaft locked    0   0   Shaft locked
0   1   Clockwise       0   1   Clockwise
1   0   Anti-clockwise  1   0   Anti-clockwise
1   1   Shaft locked    1   1   Shaft locked 
*/

Um auf diese Eingänge zu schreiben, erstelle ich einen „OutputPort“ und binde ihn an einen der digitalen Anschlüsse des Netduino, wie in Abbildung 6 gezeigt. „OutputPort“ ist eine einzigartige Klasse im .NET Framework, da Geräte, die das vollständige .NET Framework ausführen, normalerweise keine einzelnen E/A-Anschlüsse ansprechen können. Es gibt eine Reihe neuer Klassen im .NET Micro Framework, um die zusätzlichen E/A-Typen sowie weitere Probleme zu verarbeiten, die für diesen Anwendungsraum spezifisch sind, wie etwa Energiemanagement:

// Motor controller output
A1 = new OutputPort(Pins.GPIO_PIN_D2, false);  
  // A is the left tires when viewed from the front
A2 = new OutputPort(Pins.GPIO_PIN_D3, false);
B1 = new OutputPort(Pins.GPIO_PIN_D4, false);  
  // B is the right tires when viewed from the front
B2 = new OutputPort(Pins.GPIO_PIN_D5, false);
Setting them is as simple as writing true or false:
switch (cmd)
{
  case 'F':
  {
    Debug.Print("Forward");
    A1.Write(false);   // Left forward = false/true
    A2.Write(true);
    B1.Write(true);    // Right forward = true/false
    B2.Write(false);
    break;
  }

Vorsicht am Steuer

Bert soll nach Möglichkeit nicht mit Gegenständen kollidieren, um seiner selbst und um der Sicherheit der Dinge und Personen in seiner Umgebung willen, daher habe ich Infrarot-Annäherungssensoren von Sharp auf der Vorder- und der Rückseite angebracht. Diese Sensoren geben einen Wert zwischen 0,0 und 1,0 zurück, abhängig vom Abstand des nächsten Objekts, das das projizierte Infrarotlicht zurückwirft.

Der vordere Sensor ist schräg abwärts gerichtet und tastet den Boden ungefähr 45 cm vor Bert ab. Dadurch lässt sich der Sensor einerseits zum Erkennen von Objekten als auch andererseits eines abfallenden Bodens verwenden, etwa bei der Annäherung an Stufen. Die von diesen Sensoren zurückgegebenen Werte sind analog, was bedeutet, dass ich eine Instanz einer weiteren Klasse erstelle, die innerhalb von .NET Framework für das .NET Micro Framework spezifisch ist, der Klasse „AnalogInput“:

AnalogInput foreRange;    // Forward range finder input
AnalogInput backRange;    // Rear range finder input
// Set up range finder for collision and edge avoidance
foreRange = new AnalogInput(Cpu.AnalogChannel.ANALOG_5, 100, 0, -1);
backRange = new AnalogInput(Cpu.AnalogChannel.ANALOG_4, 100, 0, -1);

Dieser Konstruktor identifiziert den spezifischen analogen Anschluss, mit dem ich die Verbindung herstelle, einen Multiplikator, den ich verwenden kann, um die Ausgabe in einen handlicheren Bereich zu konvertieren, einen Offset, um die Ausgabe komfortabler nutzbar zu machen, und die Genauigkeit der Ausgabe festzulegen, wobei -1 die höchste Genauigkeit bedeutet. Damit diese Messungen periodisch erfasst werden und der Prozessor so viel wie möglich ruhen kann, werden diese Messungen durch einen Zeitgeber ausgelöst. Ich lege ihn fest, wenn der Empfang von Befehlen vom Smartphone beginnt, und lösche ihn, wenn das nicht der Fall ist:

// Start timer for rangeFinders
Timer rangeReader = new Timer(new TimerCallback(rangeTimerHandler), 
  null, 0, 100);

Allgemeiner Interrupt 

Die letzte neue Klasse, die ich einführen muss, ist die Klasse „InterruptPort“. Sie ermöglicht mir, Änderungen in der digitalen Eingabe zu überwachen, und Trigger z. B. bei Änderungen von niedrigen zu hohen Werten auszulösen. Ich verwende dies für die Taste auf der Netduino-Platine, die Bert dazu bringt, auf Befehle vom Smartphone zu reagieren. Das bedeutet, er ignoriert Befehle, bis diese Taste gedrückt wird, und ignoriert sie wieder, nachdem sie erneut gedrückt wurde:

// Use onboard button to turn on/off accepting commands
button = new InterruptPort(Pins.ONBOARD_SW1, false,
  Port.ResistorMode.Disabled,
  Port.InterruptMode.InterruptEdgeHigh);

„Pins.ONBOARD_SW1“ ist die interne Verbindung für die Taste auf der Netduino-Platine. Sie können einen Schalter mit jedem der digitalen Anschlüsse verbinden, die in Abbildung 6 aufgelistet sind. Das zweite Argument legt fest, ob ein Filter für Überschwinger auf diesen Schaltereingang angewendet werden muss, um Mehrfachauslösung bei einem einzelnen Tastendruck zu vermeiden.

Der nächste Parameter legt fest, ob ein Pullup- oder Pulldown-Widerstand am Schalter vorhanden ist. Dadurch wird die standardmäßige Anschlussposition bei nicht gedrückter Taste definiert (hoch oder niedrig). Der nächste Parameter wird festgelegt, um den Interrupt für den Übergang zurück zu hoch auszulösen, damit Ihr Finger nicht im Weg ist, wenn Bert sich plötzlich auf den Weg macht. Mit erstellter InterruptPort-Instanz kann der Interrupthandler zugewiesen werden:

// Start monitoring for button presses
button.OnInterrupt += new NativeEventHandler(button_OnInterrupt);

Der Interrupthandler lässt Bert auf alle Befehle hören, die vom Smartphone kommen, wie Sie in Abbildung 9 sehen können.

Abbildung 9 Interrupthandler beim Aktivieren der Befehlsüberwachung

private void button_OnInterrupt(uint data1, uint data2, DateTime time)
{
  cmdListenState = !cmdListenState;
  if (cmdListenState)
  {
    // Set up timer for rangeFinders
    rangeReader = new Timer(new TimerCallback(rangeTimerHandler), 
      null, 0, 100);
  }
  else
  {
    rangeReader.Dispose(); // Drop the timer because Bert isn't processing
                          // commands so he shouldn't be moving
  }
  led.Write(cmdListenState);  // The onboard LED indicates whether
                               // Bert is accepting commands
}

Embedded-Anwendungen und das .NET Micro Framework

Embedded-Anwendungen führen normalerweise eine Reihe zielgerichteter Funktionen auf Hardware aus, die genau dafür ausgelegt ist, den Mindestanforderungen zu entsprechen. Das Anfertigen fein auf das Ziel abgestimmter Anwendungen erfordert höhere Anfangsinvestitionen. Diese Investition amortisiert sich im Lauf eines längeren Produktlebenszyklus.

Eine der größten Herausforderungen in der traditionellen Embedded-Entwicklung besteht im Zeitaufwand, der für die Fertigstellung von Projekten erforderlich ist. Ein großer Teil von Embedded-Projekten wird aufgegeben, da die Kosten zu stark steigen oder die Anforderungen sich ändern, bevor die Projekte den Markt erreichen.

Eine Reihe von Faktoren wirkt sich auf die Dynamik von Embedded-Anwendungen aus. Als Microsoft das .NET Micro Framework vor 7 Jahren erstmals veröffentlichte, bauten die meisten Embedded-Anwendungen auf 8-Bit-Prozessoren auf, um die Kosten gering zu halten, die geforderten Leistungsanforderungen zu erfüllen und ein günstiges Energieprofil zu erzielen (wie etwa die Möglichkeit eines ausgedehnten Batteriebetriebs). 

Zugleich bildeten 32-Bit-Prozessoren, wie der ARM7, das größte Wachstumssegment im Embedded-Bereich. Diese Prozessoren wurden ständig günstiger, boten eine angemessene Leistung für die meisten Anwendungen, und die Energiebilanz verbesserte sich stetig. Die neueren Cortex-Prozessoren setzen den Trend hin zur 32-Bit-Familie bei Embedded-Anwendungen fort.

In letzter Zeit kamen mehr Geräte auf den Markt, die einen integralen Bestandteil breiterer Anwendungen bilden, darunter auch Embedded-Geräte, Gateways, Cloud-Konnektivität, Datenbanken, Business Intelligence-Anwendungen usw. Durch diese neuen Anwendungen ändert sich die Ökonomie von Embedded-Anwendungen. 

Die Einhaltung gängiger Kommunikationsprotokolle wird zunehmend wichtiger. Ein größerer Teil dieser neuen Geräte richtet sich an Endverbraucher, die Aussicht auf längere Entwicklungszyklen bringt daher größere Produktrisiken mit sich. Die Produkteinführungszeit ist für diese Anwendungen und bei der sich anbahnenden explosionsartigen Entwicklung bei „intelligenten Geräten“ sogar noch wichtiger.

Der große Einfluss dieser neuen Arten von Anwendungen liegt vor allem in der Bandbreite, die sie abdecken. Sie bringen potenziell den Desktopentwickler und sein Wissen in der Kommunikation im großen Maßstab, bei Datenbanken und Geschäftsanalyse sowie Cloud-Protokollen mit dem Embedded-Programmierer und seinen Kenntnissen von Hardware und Low-Level-Programmierung zusammen. Die Tools und Sprachen unterstützen den Einsatz von Fähigkeiten aus einem Bereich für die gesamte Anwendung und ermöglichen so effizientere Projekte.

Vor diesem Hintergrund wurde das .NET Micro Framework entwickelt. Die Anfänge dieser Plattform entstanden als interne Tools für die Entwicklung von Microsoft SPOT-Uhrenanwendungen (dem Markt gerade einmal neun Jahre voraus). Als die Plattform sich für andere interne Projekte als nützlich erwies, wurde sie 2007 zur allgemeinen Plattform abgerundet.

Die treibenden Faktoren von Kosten, Leistung und Energieeffizienz sind nicht verschwunden. Beim Einsatz von Anwendungen, die mehrere Tausend Sensoren in einem Gebäude verwenden, wird die Kostenfrage eher noch kritischer. Auch die Anforderungen hinsichtlich Leistung und Energie unterscheiden sich je nach Anwendung. Die fortlaufende Ausweitung des Bereichs von Anwendungen, für die sich das .NET Micro Framework anbietet, stellt einen Schwerpunkt der Entwicklungsarbeit bei Microsoft dar.

Bereitstellen und Debuggen

Das Bereitstellen des Codes auf Ihrem Gerät beschränkt sich im Wesentlichen auf das Herstellen der Verbindung und Drücken von F5, genau wie bei der Windows Phone-App. Allerdings unterscheidet sich die Einrichtung. Im Dialogfeld „Projekt“ | „Eigenschaften“ gibt es eine Registerkarte „.NET Micro Framework“, auf der Sie den Transport (USB, seriell oder TCP/IP) angeben und das Gerät identifizieren können. Die Standardeinstellung ist „USB“. Sie kann ein .NET Micro Framework-Gerät automatisch identifizieren, sofern Sie also keine Verbindung mit mehreren Geräten haben, müssen Sie dieses Dialogfeld nicht benutzen. An diesem Punkt wurde der Build der Projektmappe bereits ausgeführt, und die Assemblys sind auf dem Gerät bereitgestellt. Sie können das im Ausgabefenster von Visual Studio verfolgen. Die Ausführung startet sofort, und Sie können beginnen, den auf dem Gerät ausgeführten Code zu debuggen.

Sie können die App auch auf einem Emulator, der auf einem Desktop-PC ausgeführt wird, bereitstellen. Windows Phone weist eine vergleichsweise geringe Anzahl Permutationen auf, sodass Sie den am besten übereinstimmenden Emulator unter den in Visual Studio verfügbaren auswählen können. Für das .NET Micro Framework gibt es einen allgemeinen Microsoft-Emulator. Wahrscheinlich müssen Sie einen eigenen Emulator erstellen, der zu Ihrer Hardware passt. Das ist definitiv eine Überlegung wert, wenn Sie mit der Code-Erstellung beginnen möchten, bevor die Hardware verfügbar ist.

Früher wurde das Debuggen der Kommunikation zwischen dem Roboter und der Windows Phone-App vielleicht mit einem JTAG-Debugger erledigt. Dieser gehört nicht zur Entwicklungsumgebung und ist .NET-Entwicklern nicht vertraut, daher kann es sinnvoll sein, wenn ein Entwickler überwacht, was auf dem Smartphone geschieht und ein anderer (in einem separaten Tool) überwacht, was auf dem Embedded-Gerät geschieht. Sie können beide simultan in Visual Studio überwachen. Sie können den Code auf dem Smartphone schrittweise durchlaufen, bei der Befehlsübertragung unterbrechen und dann schrittweise die Verarbeitung des Befehls auf Bert abarbeiten.

Zusammenfassung

Eine umfassende Darstellung der Erstellung einer sinnvollen Embedded-Anwendung im .NET Micro Framework würde ein ganzes Buch füllen. Das Ziel dieses Artikels bestand darin, vorzuführen, dass die Lernkurve beim Einsatz Ihrer .NET-Kenntnisse für Embedded-Anwendungen und das .NET Micro Framework nicht allzu steil ist. 

Dieses Projekt erfordert ein paar Klassen, die nicht zu den .NET-Bibliotheken gehören. Sie werden auch ein paar Dinge entdecken, die Ihnen vom .NET Framework her vertraut sind, die wir nicht in das .NET Micro Framework quetschen konnten, aber die Visual Studio-Umgebung wird mit IntelliSense, Haltepunkten, Überwachungspunkten, Aufruflisten und allem anderen, woran Sie sich gewöhnt haben, vollständig unterstützt. Es gibt Embedded-Anwendungen, für die das .NET Micro Framework nicht die richtige Lösung ist. Für viele funktioniert es aber ziemlich gut. Wir setzen die Anstrengungen fort, die Nutzbarkeit der Plattform auf größere Teile dieses wachsenden und zunehmend kritischen Teils der Informatik auszudehnen.

Sie sind jetzt bereit, sich an einem kleinen Projekt als Embedded-Programmierer zu versuchen.

Bert in Aktion

Sie haben jetzt gesehen, wie Sie Ihre Qualifikation als Entwickler sinnvoll für ein witziges Projekt einsetzen können. Sie haben eine App entwickelt, mit der Sie einen kleinen Roboter mithilfe eines Smartphones steuern können, auf dem Windows Phone OS ausgeführt wird. Die .NET-Kenntnisse, die Sie für die Windows Phone-App aufgebracht haben, können in gleicher Weise für den Roboter eingesetzt werden. Der Wechsel zwischen den beiden Umgebungen ist nahtlos. Ihre Arbeit ist getan – Zeit, sich Bert in Aktion anzusehen: youtu.be/ypuqTju2w4c.


Colin Miller ist ein leitender Programmmanager für das Internet of Things-Team bei Microsoft. Sie erreichen ihn unter colin.miller@microsoft.com. Er ist seit 20 Jahren bei Microsoft und hat am Internet of Things, Embedded, Entwicklertools, in der Forschung, für MSN, Internet Explorer, Word und andere Projekte gearbeitet.

Unser Dank gilt dem folgenden technischen Experten von Microsoft für die Durchsicht dieses Artikels: Lorenzo Tessiore