2017-05-15

Mai 2017

Band 32, Nummer 5

Internet der Dinge: Arbeiten mit dem Raspberry Pi und Windows 10

Auch wenn ich schon sehr lange mit Software arbeite, habe ich doch noch nie direkt mit Hardware interagiert. Ich habe viel Software entwickelt, die nah an der Hardware funktioniert, habe aber noch nie mit einem physischen Board gearbeitet, bei dem ich die vollständige Kontrolle über die Vorgänge besitze. Als sich mir die Chance bot, mit dem Raspberry Pi zu arbeiten (insbesondere unter Verwendung von Windows 10 und Visual Studio), habe ich sofort begeistert zugegriffen.

Der Raspberry Pi (in den Versionen 2 und 3) kann Windows 10 als Betriebssystem verwenden (auch wenn es sich nicht um die Vollversion handelt, können UWP-Apps (universelle Windows-Plattform) zum Steuern seiner Geräte verwendet werden). Es handelt sich um einen sehr preisgünstigen Computer (für weniger als 35 US-Dollar erhältlich), und er ist leistungsfähig. Der Raspberry Pi 3 verfügt über einen 64-Bit-ARM-Vierkernprozessor, HDMI-Video, Ethernet und ein WLAN-Netzwerk, Bluetooth sowie vier USB-Ports. Er kann definitiv für zahlreiche Aufgaben verwendet werden.

Die Hardware

Als Einstieg können Sie das Raspberry Pi-Board eigenständig verwenden. Das ist jedoch mit Einschränkungen verbunden. Wenn Sie nur das Board verwenden, würde das dem Entwickeln für einen Computer oder ein Smartphone gleichen. Sie müssen noch ein wenig zusätzliche Hardware verwenden. Einige Hersteller haben Kits zusammengestellt, die das Board ergänzen: Prototypboards, Widerstände, LEDs, Potentiometer, Sensoren und eine Speicherkarte. Sie können ein Gehäuse für den Computer erwerben. Dies ist jedoch nicht erforderlich, da der Computer geöffnet bleiben sollte, um die Verbindungen herzustellen.

Vertrautmachen mit der Hardware

Sobald Sie über das Board und das Kit verfügen, sollten Sie sich mit der Hardware vertraut machen. Im ersten Schritt sollten Sie den Raspberry Pi untersuchen und herausfinden, was er zu bieten hat. Abbildung 1 zeigt das Board.

Abbildung 1: Raspberry Pi 3, Modell B mit GPIO

In Abbildung 1 sehen Sie auf der rechten Seite des Boards die vier USB-Ports (1) und den Ethernetanschluss (2). Unten befinden sich (von links nach rechts) der Stromanschluss in Form eines Mini-USB-Anschlusses (3), der HDMI-Videoausgang (4), der Kameraport (5) und der Audioausgang (6). Auf der linken Seite des Boards sehen Sie den Steckplatz für die Micro SD-Karte (7) und einen Anschluss für ein LCD-Display (8). Außerdem erkennen Sie den WLAN- und Bluetooth-Adapter (9). In der Mitte des Boards sehen Sie den Prozessor (10) und den Netzwerkcontroller (11). Oben befindet sich der GPIO-Block (General Purpose Input/Output) (12), über den alle Verbindungen hergestellt werden. Jeder Pin besitzt einen eigenen Zweck, wie Sie oben in der Abbildung sehen können.

Der Raspberry Pi verwendet zwei Versorgungsspannungen: 5 V und 3,3 V. Die schwarzen Pins sind Masseanschlüsse. Die gelben Pins sind die GPIO-Pins, die Sie bei der Programmierung verwenden. Beachten Sie, dass die Nummerierung der Pins nicht sortiert ist. Sie sollten daher (wenn Sie kein perfektes fotografisches Gedächtnis besitzen) immer ein Belegungsdiagramm wie dieses im Zugriff haben (Sie finden ein solches Belegungsdiagramm z. B. unter bit.ly/1WcBUS2).

Der zweite Schritt besteht im Untersuchen des Kits. Ich werde nicht den gesamten Inhalt beschreiben, weil dieser abhängig vom Hersteller (oder von den Komponenten, deren Kauf Sie planen) stark abweichen kann. Für dieses Projekt benötigen Sie ein Breadboard (Steckbrett), drei LEDs, Widerstände und Steckverbinder. Weitere Informationen zu diesen Komponenten sowie zur Interaktion mit diesen finden Sie in Frank La Vignes Kolumne „Moderne Apps“ aus April 2016 „Entwickeln von UWP-Apps für das Internet der Dinge“ unter msdn.com/magazine/mt694090.

Aufbauen der ersten Schaltung

Da Sie das Board und diese einfachen Komponenten jetzt kennen, können Sie die erste Schaltung aufbauen. „Hello World“ für ein System wie dieses ist normalerweise ein Programm, das die LED zum Blinken bringt. Damit es noch einfacher wird, beginnen Sie mit einer Schaltung, die die LED ohne Blinken leuchten lässt. Dafür benötigen Sie kein Programm. Sie müssen nur die Schaltung verstehen, die Sie erstellen werden.

Wenn Sie die LED direkt mit dem 3,3 V-Pin des Raspberry Pi verbinden, brennt die LED möglicherweise durch, weil sie dessen Spannung nicht unterstützt. Mithilfe des Ohmschen Gesetzes (V = R*I) müssen Sie in der Schaltung einen 220 Ω-Widerstand (Rot/Rot/Schwarz) hinzufügen. Wenn kein 220 Ω-Widerstand verfügbar ist, können Sie auch einen größeren verwenden. Mit einem größeren Widerstand ist die Spannung in der Schaltung geringer, und die LED wird nicht beschädigt. Der Widerstand kann nicht viel größer sein, weil die LED nicht aktiviert wird, wenn die Spannung zu klein ist. In meinem Fall habe ich ohne Probleme einen 330 Ω-Widerstand verwendet.

Abbildung 2 zeigt den Aufbau im Breadboard . Das Bild wurde mit einem Open Source-Programm namens „Fritzing“ erstellt, das Sie unter fritzing.org herunterladen können.

Abbildung 2: Aufgebaute Schaltung

Nachdem die Schaltung aufgebaut wurde (dabei sollte die Stromversorgung des Raspberry Pi ausgeschaltet werden, damit keine der Komponenten durchbrennt), verbinden Sie die Stromversorgung. Wenn Sie die Schaltung richtig aufgebaut haben, sollte die LED eingeschaltet werden. Wenn die LED nicht eingeschaltet wird, überprüfen Sie, ob Sie die Pole der LED richtig angebracht haben: Der positive Pol (längeres Bein) und die Verbindung mit dem 3,3 V-Pin im Raspberry Pi sollten sich auf der gleichen horizontalen Linie befinden. Der negative Pol und der Widerstand (in diesem Fall gibt es keine Polarisierung) müssen sich auf der gleichen Linie befinden. Das zweite Bein des Widerstands muss mit der Linie verbunden sein, die zum Erdungspin im Raspberry Pi verläuft. Wenn alles stimmt, überprüfen Sie, ob die LED durchgebrannt ist. Ersetzen Sie sie in diesem Fall durch eine neue LED. Wenn die LED eingeschaltet wird, können Sie mit dem nächsten Schritt fortfahren: dem Erstellen eines Programms, das die LED steuert.

Installieren und Verwenden von Windows 10

Bis jetzt haben Sie kein Betriebssystem benötigt, weil Sie den Raspberry Pi nicht programmieren mussten. Nun stehen aber einige Programmierarbeiten an, damit Sie das Experiment fortsetzen können. Zu diesem Zweck verwenden Sie Windows 10. Sie können Windows 10 für den Raspberry Pi kostenlos herunterladen und installieren. Auch wenn es sich nicht um genau die gleiche Version handelt, die auf Desktops und Tablets ausgeführt wird, können Programme für die UWP ohne Änderungen ausgeführt werden.

Der erste Schritt besteht im Herunterladen und Installieren von Windows 10 auf der SD-Karte. Laden Sie zu diesem Zweck Windows 10 IoT Core Dashboard unter bit.ly/2lPXrRc herunter, und installieren Sie das Tool.

Zum Installieren von Windows 10 auf dem Raspberry Pi müssen Sie über eine kompatible Micro SD-Karte mit mindestens 8 GB Speicherkapazität verfügen. Wählen Sie im nächsten Schritt die Option „Neues Gerät einrichten“ im Dashboard aus, um Windows 10 auf die SD-Karte herunterzuladen und zu installieren. Es muss eine Möglichkeit bestehen, auf Ihrem Computer auf diese Karte zu schreiben. Wenn kein Kartenleser verfügbar ist, können Sie einen USB-Kartenleser erwerben.

Wählen Sie den Typ des Geräts, das Betriebssystem und das Laufwerk aus, in dem sich die SD-Karte befindet. Geben Sie einen Namen für den Computer an, und wählen Sie ein Administratorkennwort aus. Aktivieren Sie das Kontrollkästchen, um die Lizenzbedingungen zu akzeptieren, und klicken Sie dann auf die Schaltfläche „Installieren“. Nach dem Herunterladen und Aufzeichnen der Daten auf der Karte ist Windows 10 installiert und verwendungsbereit. Entfernen Sie die Karte aus dem Kartenleser des Computers, und legen Sie sie in den Kartensteckplatz des Raspberry Pi ein. Verbinden Sie diesen mit einem Ethernetkabel oder über WLAN mit einem WLAN-Dongle, wenn Sie Raspberry Pi 3 oder 2 verwenden. Schalten Sie das Gerät ein.

Nachdem Windows 10 gestartet wurde, können Sie unter „Meine Geräte“ im IoT Core Dashboard sehen, dass das Gerät verbunden ist.

Sie können das Device Portal im Browser an Port 8080 mithilfe der IP-Adresse öffnen, die für das verbundene Gerät angezeigt wird. In meinem Fall kann ich es mit der Adresse „http://192.168.1.199:8080“ öffnen. Sie werden zum Öffnen des Portals aufgefordert, das Administratorkennwort einzugeben, das Sie zuvor festgelegt haben. Abbildung 3 zeigt dies.

Abbildung 3: Device Portal

Hier können Sie das Gerät konfigurieren, die installierten Apps überprüfen und seine Leistung und seinen Speicher verifizieren. Mit der letzten Option („Remote“) können Sie Remotesteuerung für das Gerät aktivieren. Diese Option ist sinnvoll, wenn an das Gerät kein Bildschirm angeschlossen ist, weil Sie es remote über ihren Computer steuern können. Aktivieren Sie das Kontrollkästchen „Windows IoT-Remoteserver aktivieren“, um die Remotesteuerung auf dem Gerät zu aktivieren und die Remotesteuerungs-App für Windows 10 aus dem Store herunterzuladen.

Nachdem Sie diese installiert haben und die Windows IoT-Remotesteuerungs-App ausführen, können Sie das Gerät remote steuern und mit ihm interagieren.

Nun können Sie mit der Entwicklung für den Raspberry Pi mit Windows 10 beginnen.

Entwickeln für den Raspberry Pi mit Visual Studio

Wenn Sie für den Raspberry Pi mit Visual Studio entwickeln möchten, müssen Sie sicherstellen, dass Sie die Tools installiert haben. Sie können dies überprüfen, indem Sie „Benutzerdefinierte Installation“ auswählen und die „Entwicklungstools für universelle Windows-Apps“ in der Auswahl „Features“ aktivieren.

Sobald Sie dies ausgeführt haben, werden die Tools installiert, und Sie können mit der Entwicklung für den Raspberry Pi mit Windows 10 beginnen. Erstellen Sie ein neues Projekt, und wählen Sie die „leere“ UWP-App aus.

Es wird eine leere App erstellt. Sie erstellen nun eine App, die den Namen des aktuellen Computers auf dem Hauptbildschirm anzeigt. Fügen Sie in „MainPage.xaml“ den folgenden Code hinzu:

<Grid Background="{ThemeResource ApplicationPageBackgroundThemeBrush}">
  <TextBlock FontSize="32" x:Name="MachineText"
    HorizontalAlignment="Center"
    VerticalAlignment="Center"/>
</Grid>

Fügen Sie diesen Code dann in „MainPage.xaml.cs“ ein, um den Computernamen abzurufen und anzuzeigen:

public MainPage()
  this.InitializeComponent();
  Windows.Security.ExchangeActiveSyncProvisioning.EasClientDeviceInformation eas =
    new Windows.Security.ExchangeActiveSyncProvisioning.EasClientDeviceInformation();
  MachineText.Text = eas.FriendlyName;
}

Wenn Sie diese App auf Ihrem lokalen Computer ausführen, wird ein Fenster mit dem Namen Ihres Computers angezeigt.

Führen Sie anschließend den Raspberry Pi aus. Wählen Sie im Dropdownmenü „Projektmappenplattform“ die Option „ARM“ aus, und wählen Sie dann im Dropdownmenü „Gerät“ die Option „Remotecomputer“ aus. Es wird ein Dialogfeld zum Auswählen des Remotecomputers geöffnet.

Wählen Sie das Gerät „Raspberry Pi“ aus, und führen Sie die Anwendung aus. Die App wird für den Raspberry Pi bereitgestellt, und Sie sehen ihre Ausführung im Remotesteuerungsfenster. Beachten Sie, dass der im Fenster angezeigte Computername der Name sein sollte, den Sie beim Formatieren der SD-Karte und Installieren von Windows 10 auf der Karte festgelegt haben.

Sie können diese App auf die gleiche Weise wie eine lokale App debuggen, indem Sie Haltepunkte festlegen, Variablen analysieren usw. Wenn Sie die App in Visual Studio beenden, sehen Sie, dass die App geschlossen wird und der Hauptbildschirm auf dem Raspberry Pi angezeigt wird. Wenn Sie zum Browserportal navigieren, erkennen Sie, dass die App noch installiert ist und mithilfe der Schaltfläche „Ausführen“ ausgeführt werden kann. Abbildung 4 zeigt dies.

Abbildung 4: App-Portal mit Anzeige der installierten App

Ich bin vom Kompatibilitätsgrad überrascht, der mit UWP-Apps erreicht wird. Um das Potenzial zu zeigen, verwende ich eine App, die nicht für den Raspberry Pi erstellt wurde. Ich verwende die Beispiel-App für das UWP Community Toolkit, ein Toolkit aus von Microsoft und der Community entwickelten Komponenten. Dieses Toolkit sollten Sie sich unbedingt unter bit.ly/2b1PAJY ansehen.

Wenn Sie das Paket herunterladen und kompilieren, können Sie es für den Raspberry Pi bereitstellen und ausführen (ja, Sie können das Programm auf genau die gleiche Weise wie auf einem Desktop ausführen). Übrigens sollten Sie versuchen, die Steuerelemente im Gerät zu verwenden. Sie funktionieren gut.

Interagieren mit dem Board

Sobald Ihre Programme ausgeführt werden, müssen Sie beginnen, mit dem Board zu interagieren. Sie werden einen Controller für eine Ampel erstellen. Dieser verfügt über drei LEDS (rot, gelb und grün) und kann unterschiedliche Zeiteinstellungen für jede LED aufweisen.

Damit Sie die LEDs im Board betreiben können, müssen Sie den GPIO-Controller verwenden und den Pin öffnen, den Sie steuern möchten, und dann wie gewünscht festlegen. In Abbildung 1 erkennen Sie, dass der achte Pin im GPIO-Block (zweite Reihe) Pin 22 ist. Sie verwenden die Pins 22, 9 und 19. Die sich ergebende Schaltung entspricht Abbildung 5.

Abbildung 5: Schaltung für die Ampel

Nachdem diese Schaltung eingerichtet wurde, erstellen Sie eine neue leere UWP-App. Geben Sie den in Abbildung 6 gezeigten Code in „MainPage.xaml“ ein.

Abbildung 6: XAML-Code der Hauptseite für die Ampelschaltung

<Grid Background="{ThemeResource ApplicationPageBackgroundThemeBrush}">
  <Border BorderBrush="Black" BorderThickness="3" HorizontalAlignment="Center"
      VerticalAlignment="Center" CornerRadius="5">
    <StackPanel HorizontalAlignment="Center" VerticalAlignment="Center">
      <Ellipse Width="50" Height="50" Fill="Red" Opacity="0.5"
        Margin="20,20,20,10" x:Name="RedLed" Stroke="Black"
        StrokeThickness="1"/>
      <Ellipse Width="50" Height="50" Fill="Yellow" Opacity="0.5"
        Margin="20,10,20,10" x:Name="YellowLed" Stroke="Black"
        StrokeThickness="1"/>
      <Ellipse Width="50" Height="50" Fill="LimeGreen" Opacity="0.5"
         Margin="20,10,20,20" x:Name="GreenLed" Stroke="Black"
         StrokeThickness="1"/>
    </StackPanel>
  </Border>
</Grid>

Sie sehen die Ampel auf dem Board und im Display. Sie können sich also auch anhand des Remotedisplays informieren, was geschieht. Der Quellcode in „MainPage.xaml.cs“ wird in Abbildung 7 gezeigt.

Abbildung 7: Quellcode zum Einschalten der Ampel-LEDs in angegebenen Intervallen

private int _currentLight;
private DispatcherTimer _timer;
private int[] _pinNumbers = new[] { 22, 9, 19 };
private GpioPin[] _pins = new GpioPin[3];
public MainPage()
{
  this.InitializeComponent();
  if (InitGPIO())
    InitTimer();
}
private void InitTimer()
{
  var intervals = new[] { 6000, 2000, 6000 };
  var lights = new[] { RedLed, YellowLed, GreenLed };
  _currentLight = 2;
  _timer = new DispatcherTimer { Interval = TimeSpan.FromMilliseconds(500) };
  _timer.Tick += (s, e) =>
  {
    _timer.Stop();
    lights[_currentLight].Opacity = 0.5;
    _pins[_currentLight].Write(GpioPinValue.High);
    _currentLight = _currentLight == 2 ? 0 : _currentLight + 1;
    lights[_currentLight].Opacity = 1.0;
    _pins[_currentLight].Write(GpioPinValue.Low);
    _timer.Interval = TimeSpan.FromMilliseconds(intervals[_currentLight]);
    _timer.Start();
  };
  _timer.Start();
}

Zum Ausführen dieses Codes müssen Sie den IoT-Erweiterungen einen Verweis hinzufügen. Klicken Sie mit der rechten Maustaste im Projektmappen-Explorer auf den Knoten „Verweise“, klicken Sie auf „Verweise hinzufügen“, und navigieren Sie dann zu „Erweiterungen“ und fügen die Windows IoT-Erweiterung für UWP hinzu.

Sie erstellen einen Timer, der jede LED in einem bestimmten Intervall einschaltet, das vom intervals-Array festgelegt wird (in Ihrem Fall 6 Sekunden, 2 Sekunden und 6 Sekunden). Für die Ellipsen auf dem Bildschirm wird die Lichtundurchlässigkeit auf 0,5 festgelegt, damit sie gedimmt erscheinen. Jede Ellipse wird auf 1 festgelegt, wenn das Licht eingeschaltet ist. Der Timer wird nur festgelegt, wenn Sie den GPIO-Connector für das Board in der InitGPIO-Funktion festlegen können. Abbildung 8 zeigt dies.

Abbildung 8: Code zum Initialisieren von GPIO und Festlegen von LED-Pins für die Ausgabe

private bool InitGPIO()
{
  var gpio = GpioController.GetDefault();
  if (gpio == null)
    return false;
  for (int i = 0; i < 3; i++)
  {
    _pins[i] = gpio.OpenPin(_pinNumbers[i]);
    _pins[i].Write(GpioPinValue.High);
    _pins[i].SetDriveMode(GpioPinDriveMode.Output);
  }
  return true;
}

Sie öffnen die drei Pins für die Ausgabe und legen sie auf „High“ fest, damit die LEDs ausgeschaltet werden. Wenn Sie einen Pin auf „Low“ festlegen, fließt der Strom durch die Schaltung, und die LED wird eingeschaltet. Wenn Sie das Programm ausführen, sehen Sie einen Bildschirm mit einer Ampel, deren Lichtsignale wie bei einer echten Ampel ein- und ausgeschaltet werden. Das Board sieht wie auf dem Foto in Abbildung 9 aus.

Abbildung 9: Ampelboard mit aktuell ausgeführtem Programm

Zusammenfassung

Wie Sie gesehen haben, ist es ganz einfach, Programme zu erstellen, die mit dem Raspberry Pi interagieren. Da Sie mit Windows 10-Programmierung vertraut sind, verfügen Sie bereits über das gesamte Wissen, das Sie zum Programmieren eines Raspberry Pi benötigen (ja, die Interaktion mit dem Board ist eine andere Sache, aber die Hälfte haben Sie bereits geschafft). Sie können Ihre Programme wie jedes beliebige andere Windows 10-Programm erstellen (in der Tat werden UWP-Programme ohne Änderungen im Raspberry Pi ausgeführt). Der einzige Unterschied besteht darin, dass Sie den GPIO-Controller zum Festlegen und Abrufen von Daten verwenden. Wenn Sie Ihr Wissen erweitern und andere Projekte ausprobieren möchten, finden Sie zahlreiche Beispiele unter bit.ly/2llecFZ. Ihnen eröffnen sich unzählige Möglichkeiten, und Sie können leistungsfähige Hardware mit beeindruckender und produktiver Software kombinieren. Das ist eine unschlagbare Kombination.

Bruno Sonnino ist seit 2007 ein Microsoft MVP. Er arbeitet als Entwickler, Berater und Autor. Er hat zahlreiche Bücher und Artikel zur Windows-Entwicklung geschrieben. Folgen Sie ihm auf Twitter: @bsonnino, oder lesen Sie seinen Blog unter blogs.msmvps.com/bsonnino.

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

Freigeben über