Als erstes stell bitte sicher, dass Du eine aktuelle Version von Windows10 IoT Core auf Deinem Raspberry PI installiert hast. Eine Schritt-für-Schritt Anleitung kannst Du hier finden. Ich kann Dir nur empfehlen – wenn Du einen Monitor an dem PI angeschlossen hast – die Installation komplett über NOOBS (New Out Of The Box Software) durchzuführen. Noobs ist im Prinzip ein Tool um ein beliebiges OS auf der Micro SD Karte für den PI zu installieren. Das ganze passiert Menügesteuert. Dazu solltest Du natürlich auch eine beliebige Maus und Tastatur installiert haben.
NOOBS kannst Du von der Raspberry PI Seite (www.raspberry.org) runterladen. Der direkte Link zu NOOBS ist hier. Die installation vom WLAN auf dem PI ist ein wenig Tricky. Nach der frischen Installation findet der PI kein WLAN. Hierzu mußt Du ihn einfach einmal neu starten und siehe da, WLAN ist nun da und Du kannst Deinen PI connecten. Bitte ändere in der Weboberfläche vom PI auch dringend das Standardpasswort für den Administrator.
Benutzername : Administrator
Passwort : p@ssw0rt
Mit der Weboberfläche kannst Du auch die Zeitzone, Auflösung etc ändern. Warum das bis jetzt noch nicht direkt auf dem PI geht : I don’t know 🙂
Wichtig ist, dass Du neben W10IoTCore auch das aktuelle Visual Studio – zumindest in der Community Edition – installiert hast. Den Downloadlink findet Du hier. Das komplette Setup – Schritt für Schritt (leider auf Englisch) – ist hier zu finden.
Last but not least empfehle ich Dir das Win10 IoT Core Dashboard herunterzuladen. Das Dashboard findet Du hier.
Wenn Du das jetzt alles installiert hast sollte Dein Raspberry PI 3 endlich mit Windows10 IoT Core laufen und Visual Studio installiert sein. So nun geht es ran an die ersten paar Zeilen Code. Dazu startet ihr bitte Visual Studio.
Selbstverständlich habe ich alle Sourcecode Dateien auf GitHub abgelegt. Ihr könnt sie aus meinem Portfolio unter https://github.com/pjaegerhh runterladen. Das Led Projekt ist unter https://github.com/pjaegerhh/Win10IoTCore_Demo zu finden.
Aber nun mal von Anfang an.
Zunächst legst Du ein neues Windows UWP Projekt an (Datei->Neu->Projekt oder Strg+Umst+N).
Wichtig ist, dass Du das „Blank App“ Template für eine universelle Windows10 App nutzt.
Als nächstes musst Du dann einen Verweis auf die IoT Core Bibliotheken hinzufügen. Dies machst Du indem Du mit der Rechten Maustaste auf „Verweis“ im „Projektmappen-Explorer klickst und dort „Verweis hinzufügen auswählst.
Im nächsten Dialog wählst Du dann unter „Universal Windows“ „Erweiterungen“ die „Windows IoT Extensions for the UWP“ aus. Überlicherweise gibt es mehr als eine Version. Wähle bitte die mit der höchsten Versionsnummer aus und klicke „OK“
Wenn Du nun die „MainPage.xaml.cs“ im Projektmappen-Explorer doppel klickt solltest Du das nahezu leere Template sehen.
Als nächstes ist es dann wichtig, die Kern Bibliotheken für das GPIO Board zu installieren. Codebeispiel siehe unten
Damit sollte Deine erste App lauffähig sein. Du mußt jetzt nur noch auf den Raspberry PI die App deployen. Dazu wählst Du bitte als Konfiguration „ARM“ aus und als Ziel „Remotecomputer“. Visual Studio öffnet nun einen neuen Dialog in dem Du Deinen Raspberry PI auswählen kannst. Wenn Du das alles getan hast, dann kannst Du nun auf „F5“ drücken und der Build Vorgang wird gestartet. Beim ersten Deployment auf einen neuen Raspberry PI werden alle möglichen Runtimes und Frameworks auf dem PI beim starten runtergeladen. Nach einer gewissen Zeit ist das fertig und die App läuft.
Wie Sie sehen – sehen Sie nichts. Und das ist auch gut so, da die App im Prinzip komplett leer ist.
Kommen wir nun zu dem Blink_LED Beispiel. Für das Projekt habe ich folgenden Schaltplan gebaut. Bitte baue ihn entsprechend nach. Wichtig hierbei ist, dass Du die gleichen PINs am Raspberry PI benutzt (GPIO5 und 5VO). Der Schaltplan ist in der Visual Studio Solution enthalten und den Downloadlink für das Programm zur Erstellung der Schaltpläne findest Du weiter unten.
Als nächstes lade Dir bitte aus meinem GitHub Portfolio die Win10IoTCore_Demo herunter in Dein lokales Repository und öffne die Blink_LED.sln Solution. Im Projektmappen Explorer bitte die MainPage.xaml.cs Datei öffnen. Hier findest Du den gesamten Code um die LED zum blinken zu bringen. Dein Arbeitsbereich in Visual Studio sollte jetzt ungefähr so aussehen wie die Grafik links.
Schauen wir uns als nächstes die wichtigsten Codezeilen einmal genauer an.
Mit dieser using Direktive werden die für die Ansteuerung des GPIO wichtigen Funktionen geladen.
using Windows.Devices.Gpio;
Als nächstes werden einige Variablen und Konstanten definiert. Wichtig ist hier die Konstante „LED_PIN“. Im Beispiel wird sie auf „5“ gesetzt. Dies ist der entsprechende GPIO Pin vom Extension Board. Die beiden Brushes die definiert sind sind für den Betrieb des Raspberry PI im „Headed“ Modus – sprich wenn ein Monitor angeschlossen ist – um die LED auch auf dem Monitor zu visualisieren. Dies geschieht in der XAML Datei (siehe weiter unten).
private const int LED_PIN = 5; // Am PI3 der GPIO Pin 5 (=GPIO5)
private GpioPin pin;
private GpioPinValue pinValue;
private DispatcherTimer timer;
private SolidColorBrush redBrush = new SolidColorBrush(Windows.UI.Colors.Red); // Rot
private SolidColorBrush grayBrush = new SolidColorBrush(Windows.UI.Colors.LightGray); // Grau
Als nächstes müssen wir den GPIO Kontroller initialisieren und einen neuen Timer initialisieren. Wir setzen den timer.Interval auf 500ms und starten den Timer. Die Funktion die bei jedem Tick aufgerufen wird wird mit „this.timer.Tick += Timer_Tick;“ gesetzt. Als nächstes initialisieren wir den GPIO Kontroller mit „this.InitGPIO();“ und starten den Timer.
this.InitializeComponent();
timer = new DispatcherTimer(); // Timer initialisieren
timer.Interval = TimeSpan.FromMilliseconds(500); // Timer Intervall = 500 mSec
this.timer.Tick += Timer_Tick;
this.InitGPIO();
if (pin != null) // pin = null => Kein GPIO vorhanden
{
timer.Start(); // Timer starten
}
Als letztes erkläre ich noch die Timer Funktion „Timer_Tick“. Wenn der pinValue auf „GpioPinValue.High“ (=Strom an) gesetzt ist, dann wird der Wert des Pins auf „Low“ gesetzt – sprich Strom aus. Mit „pin.Write(pinValue)“ wird der neue Wert für den Pin an den GPIO Kontroller gesendet. „LED.Fill“ (XAML Seite) wird gesetzt.
private void Timer_Tick(object sender, object e)
{
if (pinValue == GpioPinValue.High)
{
pinValue = GpioPinValue.Low; // Value = Low = AUS
pin.Write(pinValue); // pin.Write = Pin An- bzw Ausschalten
LED.Fill = redBrush; // LED => XAML Page
}
else
{
pinValue = GpioPinValue.High; // Value = High = AN
pin.Write(pinValue); // pin.Write = Pin An- bzw Ausschalten
LED.Fill = grayBrush; // LED => XAML Page, gray
}
}
Dieses Projekt könnt ihr jetzt entweder auf dem PC (Ziel = „Lokaler Computer“) oder direkt auf den RaspBerry PI (Ziel = „Remotecomputer“) ausführen. Da es sich bei der App um eine Windows10 UWP (Universal Windows Plattform) App handelt läuft sie natürlich auch auf dem PC, da aber kein GPIO Kontroller angeschlossen ist zeigt die App kurz nach dem Start eine Fehlermeldung. Von daher führe die App am Besten direkt auf dem „Remotecomputer“ aus.
Ich wünsche Dir nun viel Spaß beim experimentieren. Als nächstes könntest Du z.B. ein Projekt mit 2 LEDs bauen, in der die LEDs abwechselnd blinken oder Du änderst die Helligkeit der LED mit einem Potentiometer oder oder oder 🙂
Wichtige Links zu windowsondevices.com
GitHUB Link zu meinem Portfolio https://github.com/pjaegerhh
SunFounder Raspberry PI Kit auf Amazon
Raspberry PI3 auf Amazon
Netzteil für Raspberry PI3 auf Amazon
Gehäuse für Raspberry PI3 auf Amazon
32 GB Micro SD Card für Raspberry PI3 auf Amazon
Fritzing Diagramme / Schaltpläne erstellen
Kommentar verfassen