13 KiB

Raw Permalink Blame History Unescape Escape

Wirtualny komputer jednopłytkowy

Zamiast kupować urządzenie IoT wraz z czujnikami i elementami wykonawczymi, możesz użyć swojego komputera do symulacji sprzętu IoT. Projekt CounterFit pozwala uruchomić aplikację lokalnie, która symuluje sprzęt IoT, taki jak czujniki i elementy wykonawcze, oraz uzyskać do nich dostęp za pomocą lokalnego kodu Python, napisanego w taki sam sposób, jak kod, który napisałbyś na Raspberry Pi, używając fizycznego sprzętu.

Konfiguracja

Aby korzystać z CounterFit, musisz zainstalować na swoim komputerze kilka darmowych programów.

Zadanie

Zainstaluj wymagane oprogramowanie.

Zainstaluj Pythona. Odwiedź stronę pobierania Pythona, aby uzyskać instrukcje dotyczące instalacji najnowszej wersji Pythona.
Zainstaluj Visual Studio Code (VS Code). To edytor, którego będziesz używać do pisania kodu dla wirtualnego urządzenia w Pythonie. Odwiedź dokumentację VS Code, aby uzyskać instrukcje dotyczące instalacji VS Code.

💁 Możesz używać dowolnego IDE lub edytora dla Pythona, jeśli masz preferowane narzędzie, ale instrukcje w lekcjach będą oparte na używaniu VS Code.
Zainstaluj rozszerzenie Pylance dla VS Code. Jest to rozszerzenie, które zapewnia wsparcie dla języka Python. Odwiedź dokumentację rozszerzenia Pylance, aby uzyskać instrukcje dotyczące instalacji tego rozszerzenia w VS Code.

Instrukcje dotyczące instalacji i konfiguracji aplikacji CounterFit zostaną podane w odpowiednim momencie w ramach instrukcji zadania, ponieważ aplikacja jest instalowana indywidualnie dla każdego projektu.

Hello World

Tradycyjnie, zaczynając pracę z nowym językiem programowania lub technologią, tworzy się aplikację 'Hello World' – małą aplikację, która wyświetla tekst, np. "Hello World", aby upewnić się, że wszystkie narzędzia są poprawnie skonfigurowane.

Aplikacja Hello World dla wirtualnego sprzętu IoT pozwoli upewnić się, że Python i Visual Studio Code są poprawnie zainstalowane. Połączy się również z CounterFit, aby obsługiwać wirtualne czujniki i elementy wykonawcze IoT. Nie będzie używać żadnego sprzętu – po prostu połączy się, aby potwierdzić, że wszystko działa.

Ta aplikacja znajdzie się w folderze o nazwie nightlight i będzie ponownie używana z różnym kodem w późniejszych częściach tego zadania, aby zbudować aplikację lampki nocnej.

Konfiguracja wirtualnego środowiska Pythona

Jedną z potężnych funkcji Pythona jest możliwość instalowania pakietów Pip – są to pakiety kodu napisane przez innych i opublikowane w Internecie. Możesz zainstalować pakiet Pip na swoim komputerze za pomocą jednego polecenia, a następnie używać go w swoim kodzie. W tym zadaniu użyjesz Pip do zainstalowania pakietu umożliwiającego komunikację z CounterFit.

Domyślnie, gdy instalujesz pakiet, jest on dostępny wszędzie na twoim komputerze, co może prowadzić do problemów z wersjami pakietów – na przykład jedna aplikacja może wymagać jednej wersji pakietu, która przestaje działać po zainstalowaniu nowej wersji dla innej aplikacji. Aby rozwiązać ten problem, możesz użyć wirtualnego środowiska Pythona, czyli kopii Pythona w dedykowanym folderze. W takim środowisku pakiety Pip są instalowane tylko w tym folderze.

💁 Jeśli używasz Raspberry Pi, nie konfigurowałeś wirtualnego środowiska na tym urządzeniu do zarządzania pakietami Pip. Zamiast tego używasz pakietów globalnych, ponieważ pakiety Grove są instalowane globalnie przez skrypt instalacyjny.

Zadanie – konfiguracja wirtualnego środowiska Pythona

Skonfiguruj wirtualne środowisko Pythona i zainstaluj pakiety Pip dla CounterFit.

W terminalu lub wierszu poleceń uruchom następujące polecenia w wybranej lokalizacji, aby utworzyć i przejść do nowego katalogu:
```
mkdir nightlight
cd nightlight
```
Następnie uruchom następujące polecenie, aby utworzyć wirtualne środowisko w folderze .venv:
```
python3 -m venv .venv
```
💁 Musisz wyraźnie wywołać python3, aby utworzyć wirtualne środowisko, na wypadek gdybyś miał zainstalowanego Pythona 2 obok Pythona 3 (najnowszej wersji). Jeśli masz zainstalowanego Pythona 2, wywołanie python użyje Pythona 2 zamiast Pythona 3.
Aktywuj wirtualne środowisko:
- Na Windowsie:
  - Jeśli używasz Wiersza Poleceń lub Wiersza Poleceń w Windows Terminal, uruchom:
```
.venv\Scripts\activate.bat
```
  - Jeśli używasz PowerShell, uruchom:
```
.\.venv\Scripts\Activate.ps1
```
    Jeśli pojawi się błąd dotyczący wyłączonego uruchamiania skryptów w tym systemie, musisz włączyć uruchamianie skryptów, ustawiając odpowiednią politykę wykonywania. Możesz to zrobić, uruchamiając PowerShell jako administrator, a następnie wykonując następujące polecenie:
```
Set-ExecutionPolicy -ExecutionPolicy Unrestricted
```
    Wpisz Y, aby potwierdzić. Następnie ponownie uruchom PowerShell i spróbuj ponownie.
    
    Możesz później przywrócić tę politykę wykonywania, jeśli zajdzie taka potrzeba. Więcej informacji znajdziesz na stronie Execution Policies w dokumentacji Microsoft.
- Na macOS lub Linux uruchom:
```
source ./.venv/bin/activate
```
💁 Te polecenia powinny być uruchamiane z tej samej lokalizacji, w której uruchomiłeś polecenie tworzące wirtualne środowisko. Nigdy nie musisz wchodzić do folderu .venv, zawsze uruchamiaj polecenie aktywacji i inne polecenia instalacji pakietów lub uruchamiania kodu z folderu, w którym utworzyłeś wirtualne środowisko.
Po aktywacji wirtualnego środowiska domyślne polecenie python uruchomi wersję Pythona, która została użyta do utworzenia środowiska. Uruchom następujące polecenie, aby sprawdzić wersję:
```
python --version
```
Wynik powinien zawierać:
```
(.venv) ➜  nightlight python --version
Python 3.9.1
```
💁 Twoja wersja Pythona może być inna – o ile jest to wersja 3.6 lub nowsza, wszystko jest w porządku. Jeśli nie, usuń ten folder, zainstaluj nowszą wersję Pythona i spróbuj ponownie.
Uruchom następujące polecenia, aby zainstalować pakiety Pip dla CounterFit. Pakiety te obejmują główną aplikację CounterFit oraz shimy dla sprzętu Grove. Shimy te pozwalają pisać kod tak, jakbyś programował z użyciem fizycznych czujników i elementów wykonawczych z ekosystemu Grove, ale podłączonych do wirtualnych urządzeń IoT.
```
pip install CounterFit
pip install counterfit-connection
pip install counterfit-shims-grove
```
Te pakiety Pip zostaną zainstalowane tylko w wirtualnym środowisku i nie będą dostępne poza nim.

Napisz kod

Gdy wirtualne środowisko Pythona jest gotowe, możesz napisać kod dla aplikacji 'Hello World'.

Zadanie – napisz kod

Utwórz aplikację w Pythonie, która wypisze "Hello World" w konsoli.

W terminalu lub wierszu poleceń, będąc w wirtualnym środowisku, uruchom następujące polecenie, aby utworzyć plik Pythona o nazwie app.py:
- Na Windowsie uruchom:
```
type nul > app.py
```
- Na macOS lub Linux uruchom:
```
touch app.py
```
Otwórz bieżący folder w VS Code:
```
code .
```
💁 Jeśli twój terminal zwraca command not found na macOS, oznacza to, że VS Code nie został dodany do PATH. Możesz dodać VS Code do PATH, postępując zgodnie z instrukcjami w sekcji Launching from the command line w dokumentacji VS Code i uruchomić polecenie ponownie. VS Code jest domyślnie dodawany do PATH na Windowsie i Linuxie.
Po uruchomieniu VS Code aktywuje ono wirtualne środowisko Pythona. Wybrane środowisko pojawi się na dolnym pasku stanu:
Jeśli terminal VS Code jest już uruchomiony podczas startu VS Code, wirtualne środowisko nie będzie w nim aktywne. Najłatwiej jest zamknąć terminal, używając przycisku Kill the active terminal instance:

Możesz sprawdzić, czy terminal ma aktywne wirtualne środowisko, ponieważ nazwa środowiska będzie prefiksem w terminalu. Na przykład może to być:
```
(.venv) ➜  nightlight
```
Jeśli nie widzisz .venv jako prefiksu w terminalu, wirtualne środowisko nie jest aktywne.
Uruchom nowy terminal w VS Code, wybierając Terminal -> New Terminal lub naciskając CTRL+`. Nowy terminal załaduje wirtualne środowisko, a wywołanie aktywacji pojawi się w terminalu. W terminalu pojawi się również prefiks z nazwą środowiska (.venv):
```
➜  nightlight source .venv/bin/activate
(.venv) ➜  nightlight 
```
Otwórz plik app.py w eksploratorze VS Code i dodaj następujący kod:
```
print('Hello World!')
```
Funkcja print wypisuje w konsoli to, co zostanie do niej przekazane.
W terminalu VS Code uruchom następujące polecenie, aby uruchomić aplikację w Pythonie:
```
python app.py
```
W konsoli pojawi się:
```
(.venv) ➜  nightlight python app.py 
Hello World!
```

😀 Twój program 'Hello World' działa poprawnie!

Podłącz 'sprzęt'

Jako drugi krok 'Hello World', uruchomisz aplikację CounterFit i połączysz z nią swój kod. Jest to wirtualny odpowiednik podłączenia sprzętu IoT do zestawu deweloperskiego.

Zadanie – podłącz 'sprzęt'

W terminalu VS Code uruchom aplikację CounterFit za pomocą następującego polecenia:
```
counterfit
```
Aplikacja zacznie działać i otworzy się w przeglądarce internetowej:

Będzie oznaczona jako Disconnected, a dioda LED w prawym górnym rogu będzie wyłączona.
Dodaj następujący kod na początku pliku app.py:
```
from counterfit_connection import CounterFitConnection
CounterFitConnection.init('127.0.0.1', 5000)
```
Kod ten importuje klasę CounterFitConnection z modułu counterfit_connection, który pochodzi z pakietu Pip counterfit-connection, zainstalowanego wcześniej. Następnie inicjalizuje połączenie z aplikacją CounterFit działającą na 127.0.0.1, co jest adresem IP używanym do dostępu do lokalnego komputera (często nazywanego localhost), na porcie 5000.

💁 Jeśli inne aplikacje działają na porcie 5000, możesz to zmienić, aktualizując port w kodzie i uruchamiając CounterFit za pomocą CounterFit --port <port_number>, zastępując <port_number> wybranym portem.
Będziesz musiał uruchomić nowy terminal w VS Code, wybierając przycisk Create a new integrated terminal. Jest to konieczne, ponieważ aplikacja CounterFit działa w bieżącym terminalu.
W nowym terminalu uruchom plik app.py tak jak wcześniej. Status CounterFit zmieni się na Connected, a dioda LED zaświeci się.

💁 Kod ten znajdziesz w folderze code/virtual-device.

😀 Połączenie ze sprzętem zakończyło się sukcesem!

Zastrzeżenie:
Ten dokument został przetłumaczony za pomocą usługi tłumaczenia AI Co-op Translator. Chociaż staramy się zapewnić dokładność, prosimy pamiętać, że automatyczne tłumaczenia mogą zawierać błędy lub nieścisłości. Oryginalny dokument w jego rodzimym języku powinien być uznawany za autorytatywne źródło. W przypadku informacji o kluczowym znaczeniu zaleca się skorzystanie z profesjonalnego tłumaczenia przez człowieka. Nie ponosimy odpowiedzialności za jakiekolwiek nieporozumienia lub błędne interpretacje wynikające z użycia tego tłumaczenia.

13 KiB Raw Permalink Blame History Unescape Escape