IoT-Integration: Fernsteuerung von Arduino über Windows 10 UWP-Apps

Komponenten und Zubehör

Arduino UNO	×	1
SparkFun Bluetooth Modem – BlueSMiRF Silver (hier Gold-Version verwendet)	×	1

Über dieses Projekt

Hinweis: Siehe Updates in den Kommentaren unten.

Eine Windows 10 UWP-App kann auf der Remote-Wiring-Bibliothek aufbauen, um mit einem Arduino-Gerät zu interagieren, das Firmata ausführt. Eine App, ähnlich dem Windows Remote Arduino „Blinky“-Beispiel, aber mit Funktionserweiterungen, wird entwickelt. Sie beherrscht GPIO (Ein- UND Ausgabe) sowie Analog-I/O. Funktional identisch mit der Windows 8.1-Version im vorherigen Blog, hier aber im Universal Windows Platform (UWP)-Kontext. Zielplattformen: Win 10 Desktop, Win 10 Phone, Raspberry Pi 2 (Win 10 IoT) – letzteres „Work in Progress“. Dieser Blog kann ohne Vorwissen gelesen werden.

Projektdetails auf meinem Blog: embedded101.com

Das Windows Remote Arduino „Blinky“ Beispiel findet sich unter ms-iot.github.io.

Universal Apps und Universal Windows Platform Apps

Universal Apps (UA) erreichten ihren Zenit in Windows 8.1: Ein Solution für Windows Intel Desktop, ARM RT Surface, Windows Phone (ARM). Gemeinsamer Code (Eventhandler, Berechnungen, Daten), XAML zielplattformspezifisch. Kompilierung pro Subprojekt.

Mit dem „One Windows“-Paradigma in Windows 10 kann derselbe Code (inkl. XAML) für alle Ziele verwendet werden. Derselbe Projekt wird nur für verschiedene Ziele neu kompiliert. Name: Universal Windows Platform (UWP) Apps.

Alle Windows 10 Plattformen unterstützen UWP-Apps, aber es gibt plattformspezifische Extensions (z. B. IoT-Extensions für GPIO, I2C, SPI; Mobile-Extensions für Telefonfunktionen). UWP bietet eine garantierte Kern-API-Schicht.

Für diesen Blog nutzen wir das UWP-Template (nicht UA wie im vorherigen Blog). Keine Extension SDKs nötig.

[1] Bluetooth-Kommunikation mit Arduino einrichten

Überspringen, falls bereits für Win 8.1 erledigt.

USB oder Bluetooth für Firmata-Kommunikation. Win 10 unterstützt beides, Win 8.1 nur Bluetooth. Hier: Bluetooth. Ich verwendete SparkFun Bluetooth Mate Gold (Reichweite bis 100m, Silver nur 10m; unterschiedliche Standard-Handshake-Einstellungen). Beide haben TTL-UART-Interface für Konfiguration und Arduino-Seriell-Schnittstelle.

Zur Konfiguration: SparkFun/Freetronics USB-Serial oder FTDI Basic mit Desktop-Serial-Terminal. Factory-Reset: PIO6 (eigentlich PIO4) auf High, dreimal togglen.

Bluetooth Mate hat gleichen Pinout wie SparkFun FTDI Basic – austauschbar. Nicht direkt auf FTDI Basic stecken (TX/RX tauschen). Diese Konfiguration mit Desktop-Serial-Terminal (FTDI per USB am Desktop) zur Bluetooth-Konfiguration.

Standard TTL UART Einstellungen:

• Baudrate 115.200
• 8 Bit, No Parity, 1 Stopbit
• Hardware Flow Control aktiviert (bei Mate Silver: None)
• Serial Port Profile (SPP): FireFly-WXYZ (WXYZ = letzte 4 Ziffern der BT-MAC)
• Passkey 1234

Gerät speichert bis zu 8 Pairings.

Dokumentation: rn-bluetooth-um.pdf

Firmata nutzt Baudrate 57600 – entweder Firmata ändern oder Bluetooth-Modul konfigurieren. Einfacher: Firmata anpassen. Hardware Flow Control durch Verbinden von RTS mit CTS handhaben.

Bluetooth-Modul auf Breadboard oder Prototyping Shield. Ich wählte Shield: 6-poliger Arduino Shield Header an UART-Pins des Bluetooth-Moduls (Buchse nach außen), Pins 90° abgewinkelt für vertikales Stecken. Kabel an PIO6 (PIO4) für Factory-Reset angelötet.

8-poliger Shield Header mittig auf Prototyping Shield, Außen-Header für direkten Uno-Anschluss. Bluetooth-Modul Richtung GPIO-Pins 0/1 (Rx/Tx) stecken, gelben Platz freilassen (für Reset-Kabel).

[2] Firmata einrichten

Überspringen, falls bereits für Win 8.1 erledigt.

Hinweis: Arduino Uno UART Pins 0 und 1 sind bei USB-Programmierung blockiert. Diese Pins sind mit Bluetooth-Modul UART verbunden. Daher: Bluetooth-Modul beim Programmieren ABZIEHEN.

1. Neues Standard Firmata Sketch in Arduino IDE erstellen.
2. Suche nach 57600, ersetze durch 115200. Speichern als Firmata_115200. Auf Uno hochladen. Fertig.

[3] Universal App Firmata Software-Stack einrichten

Leicht abweichend von Win 8.1.

Software-Stack (drei Schichten):

1. Remote-Wiring API – High-Level: GPIO (Get/Set Pin, OnPinChanged), Analog I/O. Nutzt Firmata-Protokoll.
2. Firmata – Kommuniziert nach unten via Serial-Protokoll.
3. Serial – Bluetooth und USB-Serial Transport-Layer. (USB nicht für Win 8.1).

Quellen:

1. windows-remote-arduino-samples
2. remote-wiring

Beide enthalten Win 8.1 und Win 10 Versionen. Ich verwendete Visual Studio 2015 RC.

1. Repository klonen (nicht ZIP download):
   git clone --recursive https://github.com/ms-iot/windows-remote-arduino-samples.git
2. Verzeichnisstruktur:
   windows-remote-arduino-samples/remote-wiring/Microsoft.Maker.win10/source (Win 10 relevant).
3. In Microsoft.Maker.win10 Solution öffnen.
4. Target Win32, Solution bauen (drei Builds für drei Schichten).
5. Gleiches für ARM (und x64 falls 64-Bit).

[4] HW LED UWP App erstellen

„Short-Circuit“ für Win 8.1-Erfahrene.

Erste Version: Software-Button schaltet Hardware-LED an (Pin 5), anderer Button aus.

Laut „Blinky“-Doku verschiedene Wege für Bibliotheken. Einfach: Universal App zur Solution hinzufügen und Referenzen setzen.

1. Neue C# Windows Blank Universal App zur Solution hinzufügen (Name: wrauwp). Nur EIN Projekt (UWP) – XAML und C# identisch für Desktop/Mobile, Unterschied nur bei Kompilierung.
2. Package.appmanifest (Texteditor): Capabilities um bluetooth.rfcomm und internetClient erweitern.
3. Referenzen auf Firmata, RemoteWiring, Serial (Desktop) hinzufügen.
4. Short-Circuit: Grid-XAML und Code aus Win 8.1 Projekt kopieren → zum Testen springen.
5. Andernfalls: MainPage.xaml Grid-XAML mit zwei Buttons (On/Off) definieren.
6. MainPage.cs: Deklarationen (BluetoothSerial bluetooth; RemoteDevice arduino; const int LED_PIN = 5;).
7. Constructor: bluetooth = new BluetoothSerial("FireFly-748B"); arduino = new RemoteDevice(bluetooth); bluetooth.ConnectionEstablished += OnConnectionEstablished; (SPP anpassen!).
8. OnConnectionEstablished: UI-Buttons aktivieren, arduino.pinMode(LED_PIN, PinMode.OUTPUT);.
9. Button-Handler: OnButton_Click → arduino.digitalWrite(5, PinState.HIGH);, OffButton_Click → arduino.digitalWrite(5, PinState.LOW);.
10. Test-Build für x86, x64, ARM.

[5] Deployment und Test der Universal Apps

Desktop-Test

1. Desktop-App als Startup-Projekt, Target x86, Local Machine, Rebuild.
2. Arduino Pin 5 → LED + Vorwiderstand + GND/VCC. (Entwicklungsboard oder „Blinky“-Hardware, ggf. Polung umkehren).
3. Arduino einschalten, Bluetooth-Modul mit Desktop pairen (Passkey 1234).
4. App starten, Bluetooth-Verbindung erlauben, Funktionalität testen, Breakpoints prüfen.
5. Für x64 wiederholen. Bluetooth am Desktop ausschalten.

Windows 10 Phone Test (für Development konfiguriert)

1. Phone Bluetooth an, mit Modul pairen (1234).
2. Target ARM, Device, Rebuild, per USB deployen.

Raspberry Pi 2 Test (WORK IN PROGRESS)

1. Remote Debugger auf RPi2 (Win 10 IoT) aktiv.
2. IP-Adresse ermitteln (Windows IoT Core Watcher).
3. Project Properties → Debug: Target Remote Machine, No Authentication, IP eingeben.
4. Rebuild, Deploy, Test auf RPi2.

Bluetooth auf RPi2 noch nicht funktionsfähig: Hauptsächlich nicht unterstützt. Kommentare mit Ideen/Erfolgen willkommen. Update folgt.

[6] UI aufhübschen

Connect/Disconnect-Buttons, ProgressRing beim Verbinden, größere Buttons, bessere Usability (getestet mit 4-jähriger Enkeltochter!).

1. Grid-XAML um Connect/Disconnect-Buttons und ProgressRing erweitern.
2. OnConnectionEstablished: ProgressRing deaktivieren/ausblenden.
3. Connect-Button-Handler: bluetooth.begin(115200, SerialConfig.SERIAL_8N1); ProgressRing anzeigen.
4. Disconnect-Button-Handler: bluetooth.end(); Buttons zurücksetzen.
5. Zeile bluetooth.begin(...) aus Constructor entfernen (nun in Connect-Handler).
6. State-Management in On/Off-Buttons (jeweils anderen aktivieren/deaktivieren).
7. Deploy und Test auf allen Zielen.

[7] Taster-Eingabe hinzufügen

Pushbutton an Arduino Pin 6, Zustand in UI anzeigen. Zuerst Polling, dann Event-Driven (DigitalPinChanged).

1. UI: TextBox für Pushbutton-Status hinzufügen.
2. MainPage: const int PB_PIN = 6;, in OnConnectionEstablished → arduino.pinMode(PB_PIN, PinMode.INPUT);.
3. DispatcherTimer alle 250ms Pollen, PBTimer_Tick liest Pin, ruft Pushbutton_Pressed auf.
4. Pushbutton_Pressed aktualisiert TextBox nur bei Änderung.
5. Hardware: Taster an Pin 6 (Pull-Down) oder Entwicklungsboard nutzen. Entprellung: kleiner Kondensator parallel zum Taster, optional Schmitt-Trigger.
6. Build, Deploy, Test.

Software-LED (Ellipse) in UI für Tasterzustand:

1. Ellipse in Grid-XAML (Row 7), zwei Farbpinsel (Rot/Grau) in Deklarationen.
2. Constructor: Ellipse initial Grau.
3. Pushbutton_Pressed: Ellipse Rot bei HIGH, Grau bei LOW.
4. Build, Deploy, Test.

Event-Driven Version (DigitalPinUpdated):

1. Poll-Timer-Code auskommentieren, Pushbutton_Pressed behalten.
2. In OnConnectionEstablished: arduino.DigitalPinUpdatedEvent += Arduino_DigitalPinUpdated;.
3. Handler asynchron auf UI-Thread marshalen:

private async void Arduino_DigitalPinUpdated(byte pin, PinState pinValue) {
  await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () => {
    if (pin == PB_PIN) Pushbutton_Pressed(pinValue);
  });
}

4. Build, Deploy, Test.

[8] Analog-Eingang hinzufügen

Potentiometer an A0 (Pin 14), Fortschrittsbalken in UI.

1. UI: ProgressBar (Max 255, Grün) hinzufügen.
2. MainPage: const int ANALOG_PIN = 14;, in OnConnectionEstablished → arduino.pinMode(ANALOG_PIN, PinMode.ANALOG); (echte Pin-Nummer, nicht Analog-Index!).
3. Poll-Timer: int PinValue = arduino.analogRead(ANALOG_PIN-14); analogBar.Value = PinValue; (Analog-Index = Pin-14).
4. Build, Deploy, Test – Potentiometer drehen, Balken beobachten.

Event-Driven (AnalogPinUpdated):

1. Poll-Timer auskommentieren.
2. In OnConnectionEstablished: PinMode ANALOG setzen, Event-Handler registrieren.
3. Handler:

private async void Arduino_AnalogPinUpdated(byte pin, ushort PinValue) {
  if (pin == ANALOG_PIN - 14) {
    await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () => {
      analogBar.Value = PinValue;
    });
  }
}

4. Build, Deploy, Test.

[9] PWM-Ausgang (Leser-Übung)

• PWM-Pins: 3, 5, 6, 9, 10, 11
• PinMode: arduino.pinMode(PWM_PIN, PinMode.PWM)
• PWM-Level: arduino.analogWrite(byte, ushort) (0-255)

Implementierung: LED dimmen via Slider. Lösung evtl. später.

Code

WindowsRemoteArduino_Win10.zip (C#)

Erweiterte Version von „Blinky“ – Input, Output, Analog Input, schickere UI.

Download only (no preview).

Schaltpläne