14 KiB

Raw Permalink Blame History

Virtuele single-board computer

In plaats van een IoT-apparaat te kopen, samen met sensoren en actuatoren, kun je je computer gebruiken om IoT-hardware te simuleren. Het CounterFit-project stelt je in staat om lokaal een app uit te voeren die IoT-hardware zoals sensoren en actuatoren simuleert. Je kunt vervolgens toegang krijgen tot deze sensoren en actuatoren vanuit lokale Python-code, geschreven op dezelfde manier als je zou doen op een Raspberry Pi met fysieke hardware.

Installatie

Om CounterFit te gebruiken, moet je enkele gratis softwareprogramma's op je computer installeren.

Taak

Installeer de benodigde software.

Installeer Python. Raadpleeg de Python-downloadpagina voor instructies over het installeren van de nieuwste versie van Python.
Installeer Visual Studio Code (VS Code). Dit is de editor die je zult gebruiken om je virtuele apparaatcode in Python te schrijven. Raadpleeg de VS Code-documentatie voor instructies over het installeren van VS Code.

💁 Je bent vrij om een andere Python-IDE of editor te gebruiken als je een voorkeur hebt, maar de lessen geven instructies op basis van het gebruik van VS Code.
Installeer de VS Code Pylance-extensie. Dit is een extensie voor VS Code die ondersteuning biedt voor de Python-taal. Raadpleeg de Pylance-extensiedocumentatie voor instructies over het installeren van deze extensie in VS Code.

De instructies voor het installeren en configureren van de CounterFit-app worden gegeven op het relevante moment in de opdrachtinstructies, omdat deze per project wordt geïnstalleerd.

Hello World

Het is gebruikelijk om bij het starten met een nieuwe programmeertaal of technologie een 'Hello World'-applicatie te maken - een kleine applicatie die iets als de tekst "Hello World" uitvoert om te laten zien dat alle tools correct zijn geconfigureerd.

De Hello World-app voor de virtuele IoT-hardware zorgt ervoor dat je Python en Visual Studio Code correct hebt geïnstalleerd. Het zal ook verbinding maken met CounterFit voor de virtuele IoT-sensoren en -actuatoren. Het gebruikt geen hardware, maar maakt alleen verbinding om te bewijzen dat alles werkt.

Deze app wordt opgeslagen in een map genaamd nightlight en zal later in deze opdracht opnieuw worden gebruikt met andere code om de nightlight-applicatie te bouwen.

Een Python virtuele omgeving configureren

Een van de krachtige functies van Python is de mogelijkheid om Pip-pakketten te installeren - dit zijn pakketten met code die door anderen zijn geschreven en op internet zijn gepubliceerd. Je kunt een Pip-pakket met één opdracht op je computer installeren en dat pakket vervolgens in je code gebruiken. Je zult Pip gebruiken om een pakket te installeren om met CounterFit te communiceren.

Standaard is een geïnstalleerd pakket overal op je computer beschikbaar, wat kan leiden tot problemen met pakketversies - bijvoorbeeld wanneer een applicatie afhankelijk is van een bepaalde versie van een pakket die niet werkt met een nieuwere versie die je voor een andere applicatie hebt geïnstalleerd. Om dit probleem te omzeilen, kun je een Python virtuele omgeving gebruiken, in feite een kopie van Python in een specifieke map. Wanneer je Pip-pakketten installeert, worden deze alleen in die map geïnstalleerd.

💁 Als je een Raspberry Pi gebruikt, heb je geen virtuele omgeving ingesteld op dat apparaat om Pip-pakketten te beheren. In plaats daarvan gebruik je globale pakketten, omdat de Grove-pakketten globaal worden geïnstalleerd door het installatiescript.

Taak - een Python virtuele omgeving configureren

Configureer een Python virtuele omgeving en installeer de Pip-pakketten voor CounterFit.

Voer vanuit je terminal of opdrachtregel het volgende uit op een locatie naar keuze om een nieuwe map te maken en ernaartoe te navigeren:
```
mkdir nightlight
cd nightlight
```
Voer nu het volgende uit om een virtuele omgeving te maken in de map .venv:
```
python3 -m venv .venv
```
💁 Je moet expliciet python3 aanroepen om de virtuele omgeving te maken, voor het geval je Python 2 naast Python 3 (de nieuwste versie) hebt geïnstalleerd. Als je Python 2 hebt geïnstalleerd, zal het aanroepen van python Python 2 gebruiken in plaats van Python 3.
Activeer de virtuele omgeving:
- Op Windows:
  - Als je de Command Prompt of de Command Prompt via Windows Terminal gebruikt, voer dan het volgende uit:
```
.venv\Scripts\activate.bat
```
  - Als je PowerShell gebruikt, voer dan het volgende uit:
```
.\.venv\Scripts\Activate.ps1
```
    Als je een foutmelding krijgt over het uitschakelen van scripts op dit systeem, moet je het uitvoeren van scripts inschakelen door een geschikte uitvoeringsbeleid in te stellen. Dit kun je doen door PowerShell als beheerder te starten en het volgende commando uit te voeren:
```
Set-ExecutionPolicy -ExecutionPolicy Unrestricted
```
    Voer Y in wanneer je wordt gevraagd om te bevestigen. Start vervolgens PowerShell opnieuw en probeer het opnieuw.
    
    Je kunt dit uitvoeringsbeleid later opnieuw instellen als dat nodig is. Meer informatie hierover vind je op de pagina over uitvoeringsbeleid op Microsoft Docs.
- Op macOS of Linux, voer het volgende uit:
```
source ./.venv/bin/activate
```
💁 Deze opdrachten moeten worden uitgevoerd vanuit dezelfde locatie waar je de opdracht hebt uitgevoerd om de virtuele omgeving te maken. Je hoeft nooit naar de .venv-map te navigeren. Je moet altijd de activeringsopdracht en eventuele opdrachten om pakketten te installeren of code uit te voeren uitvoeren vanuit de map waar je de virtuele omgeving hebt gemaakt.
Zodra de virtuele omgeving is geactiveerd, zal de standaard python-opdracht de versie van Python uitvoeren die is gebruikt om de virtuele omgeving te maken. Voer het volgende uit om de versie te controleren:
```
python --version
```
De uitvoer moet het volgende bevatten:
```
(.venv) ➜  nightlight python --version
Python 3.9.1
```
💁 Je Python-versie kan anders zijn - zolang het versie 3.6 of hoger is, zit je goed. Zo niet, verwijder dan deze map, installeer een nieuwere versie van Python en probeer het opnieuw.
Voer de volgende opdrachten uit om de Pip-pakketten voor CounterFit te installeren. Deze pakketten omvatten de hoofdapp CounterFit en shims voor Grove-hardware. Deze shims stellen je in staat om code te schrijven alsof je fysieke sensoren en actuatoren uit het Grove-ecosysteem programmeert, maar dan verbonden met virtuele IoT-apparaten.
```
pip install CounterFit
pip install counterfit-connection
pip install counterfit-shims-grove
```
Deze Pip-pakketten worden alleen in de virtuele omgeving geïnstalleerd en zijn niet beschikbaar buiten deze omgeving.

Schrijf de code

Zodra de Python virtuele omgeving klaar is, kun je de code schrijven voor de 'Hello World'-applicatie.

Taak - schrijf de code

Maak een Python-applicatie om "Hello World" naar de console te printen.

Voer vanuit je terminal of opdrachtregel het volgende uit binnen de virtuele omgeving om een Python-bestand genaamd app.py te maken:
- Op Windows voer je uit:
```
type nul > app.py
```
- Op macOS of Linux voer je uit:
```
touch app.py
```
Open de huidige map in VS Code:
```
code .
```
💁 Als je terminal command not found retourneert op macOS, betekent dit dat VS Code niet aan je PATH is toegevoegd. Je kunt VS Code aan je PATH toevoegen door de instructies te volgen in de sectie over starten vanaf de opdrachtregel in de VS Code-documentatie en daarna het commando opnieuw uit te voeren. Op Windows en Linux wordt VS Code standaard aan je PATH toegevoegd.
Wanneer VS Code wordt gestart, activeert het de Python virtuele omgeving. De geselecteerde virtuele omgeving verschijnt in de onderste statusbalk:
Als de VS Code Terminal al actief is wanneer VS Code wordt gestart, zal de virtuele omgeving niet geactiveerd zijn in de terminal. Het eenvoudigste is om de terminal te sluiten met de knop Kill the active terminal instance:

Je kunt zien of de terminal de virtuele omgeving heeft geactiveerd, omdat de naam van de virtuele omgeving een prefix is op de terminalprompt. Bijvoorbeeld, het kan zijn:
```
(.venv) ➜  nightlight
```
Als je geen .venv als prefix op de prompt hebt, is de virtuele omgeving niet actief in de terminal.
Start een nieuwe VS Code Terminal door Terminal -> New Terminal te selecteren of door CTRL+` in te drukken. De nieuwe terminal zal de virtuele omgeving laden en de activeringsopdracht zal in de terminal verschijnen. De prompt zal ook de naam van de virtuele omgeving (.venv) bevatten:
```
➜  nightlight source .venv/bin/activate
(.venv) ➜  nightlight 
```
Open het bestand app.py vanuit de VS Code-verkenner en voeg de volgende code toe:
```
print('Hello World!')
```
De functie print print alles wat eraan wordt doorgegeven naar de console.
Voer vanuit de VS Code-terminal het volgende uit om je Python-app uit te voeren:
```
python app.py
```
De volgende uitvoer zal verschijnen:
```
(.venv) ➜  nightlight python app.py 
Hello World!
```

😀 Je 'Hello World'-programma is een succes!

Verbind de 'hardware'

Als een tweede 'Hello World'-stap ga je de CounterFit-app uitvoeren en je code ermee verbinden. Dit is het virtuele equivalent van het aansluiten van IoT-hardware op een ontwikkelkit.

Taak - verbind de 'hardware'

Start vanuit de VS Code-terminal de CounterFit-app met het volgende commando:
```
counterfit
```
De app zal starten en openen in je webbrowser:

Het zal worden gemarkeerd als Disconnected, met de LED in de rechterbovenhoek uitgeschakeld.
Voeg de volgende code toe aan het begin van app.py:
```
from counterfit_connection import CounterFitConnection
CounterFitConnection.init('127.0.0.1', 5000)
```
Deze code importeert de CounterFitConnection-klasse uit de counterfit_connection-module, die afkomstig is uit het eerder geïnstalleerde counterfit-connection Pip-pakket. Vervolgens initialiseert het een verbinding met de CounterFit-app die draait op 127.0.0.1, een IP-adres dat altijd kan worden gebruikt om toegang te krijgen tot je lokale computer (vaak aangeduid als localhost), op poort 5000.

💁 Als je andere apps hebt die draaien op poort 5000, kun je dit wijzigen door de poort in de code bij te werken en CounterFit uit te voeren met CounterFit --port <port_number>, waarbij <port_number> wordt vervangen door de gewenste poort.
Je moet een nieuwe VS Code-terminal starten door de knop Create a new integrated terminal te selecteren. Dit komt omdat de CounterFit-app draait in de huidige terminal.
Voer in deze nieuwe terminal het bestand app.py uit zoals eerder. De status van CounterFit zal veranderen naar Connected en de LED zal oplichten.

💁 Je kunt deze code vinden in de code/virtual-device-map.

😀 Je verbinding met de hardware is een succes!

Disclaimer:
Dit document is vertaald met behulp van de AI-vertalingsservice Co-op Translator. Hoewel we streven naar nauwkeurigheid, dient u zich ervan bewust te zijn dat geautomatiseerde vertalingen fouten of onnauwkeurigheden kunnen bevatten. Het originele document in zijn oorspronkelijke taal moet worden beschouwd als de gezaghebbende bron. Voor cruciale informatie wordt professionele menselijke vertaling aanbevolen. Wij zijn niet aansprakelijk voor eventuele misverstanden of verkeerde interpretaties die voortvloeien uit het gebruik van deze vertaling.

14 KiB Raw Permalink Blame History