Samouczek: tworzenie aplikacji wysokiego poziomu

  • Artykuł

Aplikacja wysokiego poziomu działa w systemie operacyjnym Azure Sphere, korzysta z bibliotek aplikacji Azure Sphere i może komunikować się z Internetem i usługami w chmurze. Zobacz Omówienie aplikacji Azure Sphere , aby uzyskać podstawowe informacje o aplikacjach wysokiego poziomu.

W tym samouczku dowiesz się, jak:

  • Przygotowywanie urządzenia do opracowywania i debugowania
  • Tworzenie, uruchamianie i debugowanie aplikacji wysokiego poziomu

Wymagania wstępne

Przygotowywanie urządzenia do opracowywania i debugowania

Zanim będzie można utworzyć przykładową aplikację na urządzeniu Azure Sphere lub opracować dla niej nowe aplikacje, musisz włączyć tworzenie i ładowanie bezpośrednie. Domyślnie urządzenia Usługi Azure Sphere są "zablokowane"; oznacza to, że nie zezwalają na aplikacje w trakcie projektowania, które mają być ładowane z komputera, i nie zezwalają na debugowanie aplikacji. Przygotowanie urządzenia do ładowania bezpośredniego usuwa to ograniczenie.

Polecenie az sphere device enable-development konfiguruje urządzenie do akceptowania aplikacji do debugowania, ładuje serwer debugowania na urządzenie i przypisuje urządzenie do grupy urządzeń , która nie zezwala na aktualizacje aplikacji w chmurze. Podczas tworzenia i debugowania aplikacji należy pozostawić urządzenie w tej grupie, aby aktualizacje aplikacji w chmurze nie zastępować aplikacji w trakcie opracowywania.

  1. Upewnij się, że urządzenie Azure Sphere jest podłączone do komputera i że komputer jest połączony z Internetem.

  2. Otwórz interfejs wiersza polecenia przy użyciu programu PowerShell, wiersza polecenia systemu Windows lub powłoki poleceń systemu Linux.

  3. Wprowadź następujące polecenie:

    az sphere device enable-development --resource-group <ResourceGroupName> --catalog <CatalogName> --device <DeviceIdValue>

    Powinny być widoczne dane wyjściowe podobne do następujących:

    Getting device capability configuration for application development.
Downloading device capability configuration for device ID '<device ID>'.
Successfully downloaded device capability configuration.
Successfully wrote device capability configuration file 'C:\Users\user\AppData\Local\Temp\tmpD732.tmp'.
Setting device group ID 'a6df7013-c7c2-4764-8424-00cbacb431e5' for device with ID '<device ID>'.
Successfully disabled over-the-air updates.
Enabling application development capability on attached device.
Applying device capability configuration to device.
Successfully applied device capability configuration to device.
The device is rebooting.
Installing debugging server to device.
Deploying 'C:\Program Files (x86)\Microsoft Azure Sphere SDK\DebugTools\gdbserver.imagepackage' to the attached device.
Image package 'C:\Program Files (x86)\Microsoft Azure Sphere SDK\DebugTools\gdbserver.imagepackage' has been deployed to the attached device.
Application development capability enabled.
Successfully set up device '<device ID>' for application development, and disabled over-the-air updates.
Command completed successfully in 00:00:38.3299276.

Jeśli polecenie az sphere device enable-development nie powiedzie się, zobacz Rozwiązywanie problemów z usługą Azure Sphere , aby uzyskać pomoc.

Tworzenie i uruchamianie aplikacji wysokiego poziomu za pomocą Visual Studio Code

W tym samouczku użyto szablonu Azure Sphere Blink, który jest częścią rozszerzenia Azure Sphere dla Visual Studio Code. Szablon Blink miga diodą LED, dzięki czemu można sprawdzić, czy urządzenie i narzędzia Azure Sphere są zainstalowane i prawidłowo skonfigurowane.

  1. Rozpocznij Visual Studio Code. Wybierz pozycję Wyświetl>paletę poleceń, a następnie wpisz "Azure Sphere: Generate New Project".

  2. Z menu Szablony wybierz pozycję Migaj .

  1. Visual Studio Code następnie zostanie wyświetlone okno Eksplorator plików. Przejdź do folderu, w którym chcesz umieścić aplikację Blink. Visual Studio Code utworzy folder Blink w wybranej lokalizacji i wygeneruje pliki kompilacji dla aplikacji Blink. Powinny być widoczne wiadomości z usługi CMake.

  2. Otwórz plik CMakeLists.txt i zmień ustawienie TARGET_DIRECTORY, aby określić folder zawierający definicje używanego sprzętu. Domyślnie TARGET_DIRECTORY określa hardwareDefinitions/mt3620_rbd, który jest zgodny z zestawem deweloperskim Seeed Azure Sphere MT3620:

    azsphere_target_hardware_definition(${PROJECT_NAME} TARGET_DIRECTORY "HardwareDefinitions/mt3620_rdb" TARGET_DEFINITION "template_appliance.json")

    Szablon zawiera kilka definicji sprzętu. Jeśli na przykład używasz tablicy mini dev seeed MT3620, określ hardwaredefinitions/seeed_mt3620_mdb zamiast tego.

  3. Naciśnij klawisz F5 , aby utworzyć i debugować projekt. Jeśli projekt nie został wcześniej utworzony lub pliki zostały zmienione i wymagane jest ponowne odbudowanie, Visual Studio Code utworze projekt przed rozpoczęciem debugowania.

  4. Poczekaj kilka sekund, aż Visual Studio Code zbudować aplikację, utworzyć pakiet obrazów, wdrożyć go na tablicy i uruchomić w trybie debugowania. Po drodze w okienku Dane wyjściowe będą wyświetlane aktualizacje stanu.

    Najpierw funkcja CMake określa, czy aplikacja musi zostać skonstruowana. Jeśli tak, fokus zostanie przeniesiony do okienka danych wyjściowych, w którym zostaną wyświetlone dane wyjściowe z klucza CMake/build.

    Następnie w okienku danych wyjściowych są wyświetlane dane wyjściowe podczas wdrażania pakietu obrazów na urządzeniu. Na koniec konsola debugowania otrzymuje fokus i wyświetla dane wyjściowe gdb.

    Wskazówka

    Zanotuj lokalizację pakietu obrazów, ponieważ będzie on potrzebny podczas tworzenia wdrożenia. W oknie <Dane wyjściowe powinien zostać wyświetlony komunikat"Build files written to path" (Konstruuj pliki zapisane na <ścieżce>), gdzie ścieżka> to pełna ścieżka do folderu kompilacji aplikacji Blink, która zazwyczaj kończy się ciągiem "out\ARM-Debug" lub "out/ARM-Debug".

  5. Po krótkim opóźnieniu dioda LED powinna migać.

  6. Ustaw punkt przerwania gdzieś w pliku main.c i przejrzyj aplikację, aby móc poznać funkcje debugowania Visual Studio Code dla usługi Azure Sphere.

Tworzenie i uruchamianie aplikacji wysokiego poziomu za pomocą programu Visual Studio

W tym samouczku użyto szablonu Azure Sphere Blink, który jest częścią rozszerzenia Azure Sphere dla programu Visual Studio. Szablon Blink miga diodą LED, dzięki czemu można sprawdzić, czy urządzenie i narzędzia Azure Sphere są zainstalowane i prawidłowo skonfigurowane.

  1. Jeśli jesteś nowym użytkownikiem programu Visual Studio, skorzystaj z przewodnika Szybki start lub Przewodnik , aby dowiedzieć się więcej o nawigacji i korzystaniu z niego.

  2. Otwórz program Visual Studio i wybierz pozycję Utwórz nowy projekt. W polu Search wpisz "azure sphere", aby uzyskać listę szablonów usługi Azure Sphere. Wybierz z listy pozycję Azure Sphere Blink .

  3. Wprowadź nazwę i lokalizację projektu, a następnie wybierz pozycję Utwórz.

  4. Otwórz plik CMakeLists.txt i zmień ustawienie TARGET_DIRECTORY, aby określić folder zawierający definicje używanego sprzętu. Domyślnie TARGET_DIRECTORY określa hardwareDefinitions/mt3620_rbd, który jest zgodny z zestawem deweloperskim Seeed Azure Sphere MT3620:

    azsphere_target_hardware_definition(${PROJECT_NAME} TARGET_DIRECTORY "HardwareDefinitions/mt3620_rdb" TARGET_DEFINITION "template_appliance.json")

    Szablon zawiera kilka definicji sprzętu. Jeśli na przykład używasz tablicy mini dev seeed MT3620, określ hardwaredefinitions/seeed_mt3620_mdb zamiast tego.

  5. W programie Visual Studio wybierz pozycję Wyświetl>dane wyjściowe , aby wyświetlić okienko Dane wyjściowe .

  6. Upewnij się, że urządzenie jest podłączone do komputera za pomocą portu USB. W menu Ustaw element startowy naciśnij klawisz F5 lub wybierz pozycję Azure Sphere App (HLCore)*, gdzie aplikacja Azure Sphere to nazwa bieżącej aplikacji wysokiego poziomu.

  7. Jeśli zostanie wyświetlony monit o skonstruowanie projektu, wybierz pozycję Tak. Visual Studio kompiluje aplikację, tworzy pakiet obrazów, pobiera go na tablicę i uruchamia w trybie debugowania. Ładowanie bezpośrednie oznacza, że aplikacja jest dostarczana bezpośrednio z komputera za pośrednictwem połączenia przewodowego, a nie dostarczana przez chmurę.

    Wskazówka

    Zanotuj lokalizację pakietu obrazów, ponieważ będzie on potrzebny podczas tworzenia wdrożenia. W wynikach funkcji Wyświetl>> danewyjściowe pokaż dane wyjściowe z: Kompilacja<> powinien zostać wyświetlony komunikat "Plik wyjściowy znajduje się w ścieżce: <ścieżka> do folderu kompilacji aplikacji Blink", zazwyczaj kończący się ciągiem "out/ARM-Debug".

  8. Domyślnie w okienku Dane wyjściowe są wyświetlane dane wyjściowe z danych wyjściowych urządzenia. Aby wyświetlić wiadomości z debugera, wybierz debugowanie z menu rozwijanego Pokaż dane wyjściowe z . Możesz również sprawdzić dezasemblowanie programu, rejestry lub pamięć za pomocą menu Debugowanie>systemu Windows .

  9. Po uruchomieniu programu dioda LED powinna migać.

Pobierz przykładowe aplikacje

Aplikację HelloWorld można pobrać w następujący sposób:

  1. Wskaż przeglądarce microsoft samples browser.
  2. Wpisz "Azure Sphere" w polu Search.
  3. Wybierz pozycję Azure Sphere — Hello world z wyników wyszukiwania.
  4. Wybierz pozycję Pobierz plik ZIP.
  5. Otwórz pobrany plik i wyodrębnij go do katalogu lokalnego.

Stwórz próbkę

Aby utworzyć pliki kompilacji i imagepackage dla przykładowej aplikacji HelloWorld_HighLevelApp, wykonaj następujące czynności.

  1. Zaktualizuj próbkę, aby w razie potrzeby była przeznaczona na sprzęt. Domyślnie próbki to sprzęt docelowy zgodny z projektem tablicy referencyjnej MT3620 (RDB), taki jak ZESTAW DEWELOPERSKI MT3620 firmy Seeed Studios. Dodatkowe docelowe definicje sprzętu dla przykładowych aplikacji są dostępne w katalogu HardwareDefinitions repo w usłudze Azure Sphere Samples. Na przykład pliki definicji sprzętu dla zestawu startowego Avnet MT3620 znajdują się w podkategorii HardwareDefinitions/avnet_mt3620_sk.

    • Otwórz CMakeLists.txt i zaktualizuj parametr TARGET_DIRECTORY w funkcji azure_target_hardware_definition , aby wskazywał podkatalog sprzętu. Na przykład:

      azsphere_target_hardware_definition(${PROJECT_NAME} TARGET_DIRECTORY "../../../HardwareDefinitions/avnet_mt3620_sk" TARGET_DEFINITION "sample_appliance.json")

  2. Otwórz interfejs wiersza polecenia przy użyciu programu PowerShell, wiersza polecenia systemu Windows lub powłoki poleceń systemu Linux. Przejdź do katalogu kompilacji projektu.

  3. W katalogu kompilacji projektu w wierszu polecenia uruchom program CMake z następującymi parametrami:

    cmake --preset <preset-name> <source-path>

    • --preset <preset-name>

      Wstępnie ustawiona nazwa konfiguracji kompilacji zdefiniowana w CMakePresets.json.

    • --build <cmake-path>

      Katalog binarny zawierający pamięć podręczną CMake. Jeśli na przykład uruchomisz narzędzie CMake na przykładzie usługi Azure Sphere, polecenie kompilacji będzie miało wartość cmake --build out/ARM-Debug.

    • <source-path>

      Ścieżka katalogu zawierającego pliki źródłowe dla przykładowej aplikacji. W tym przykładzie repozytorium próbek azure Sphere zostało pobrane do katalogu o nazwie AzSphere.

      Parametry klucza CMake są oddzielone spacjami. Znak kontynuacji wiersza (^ dla wiersza polecenia systemu Windows, \dla wiersza polecenia systemu Linux lub ' dla programu PowerShell) może być używany w celu zwiększenia czytelności, ale nie jest wymagany.

    W poniższych przykładach pokazano polecenia CMake dla Hello world aplikacji wysokiego poziomu:

    Wiersz polecenia systemu Windows

     cmake ^
 --preset "ARM-Debug" ^
 "C:\AzSphere\azure-sphere-samples\Samples\HelloWorld\HelloWorld_HighLevelApp"

    Windows PowerShell

     cmake `
 --preset "ARM-Debug" `
 "C:\AzSphere\azure-sphere-samples\Samples\HelloWorld\HelloWorld_HighLevelApp"

  4. Uruchom ninja, aby zbudować aplikację i utworzyć plik pakietu obrazów:

    ninja -C out/ARM-Debug

    Ninja umieszcza otrzymane pliki aplikacji i plików imagepackage w określonym katalogu.

    Możesz również wywołać ninja za pośrednictwem CMake za pomocą następującego polecenia:

    cmake --build out/<binary-dir>

    Ustaw <binary-dir> na katalog binarny, który zawiera pamięć podręczną CMake. Jeśli na przykład uruchomisz narzędzie CMake na przykładzie usługi Azure Sphere, polecenie kompilacji będzie miało wartość cmake --build out/ARM-Debug.

    Podczas rozwiązywania problemów, zwłaszcza po wprowadzeniu jakichkolwiek zmian w poleceniach CMake, usuń całą kompilację i spróbuj ponownie.

Uruchom próbkę

  1. Jeśli na urządzeniu jest już uruchomiona aplikacja, usuń ją:

    az sphere device sideload delete

  2. Zmień na katalog zawierający pliki kompilacji i imagepackage utworzone wcześniej.

  3. Załaduj pakiet obrazów na urządzenie, uruchamiając polecenie wdrażania az sphere device sideload i określając pakiet obrazów. Na przykład:

    az sphere device sideload deploy --image-package HelloWorld_HighLevelApp.imagepackage

    To polecenie ładuje pakiet obrazów i uruchamia aplikację. Dioda LED powinna migać.

    Wskazówka

    Zanotuj ścieżkę pakietu obrazów. Pakiet obrazów zostanie użyty później w przewodniku Szybki start wdrażania.

Debugowanie próbki

  1. Zmień na katalog zawierający pliki kompilacji i imagepackage utworzone wcześniej.

  2. Uzyskaj identyfikator składnika, jeśli jeszcze go nie masz:

    az sphere image-package show --image-package HelloWorld_HighLevelApp.imagepackage

  3. Jeśli aplikacja jest uruchomiona, zatrzymaj ją, a następnie uruchom ponownie z opcją --debug-mode :

    az sphere device app stop --component-id <ComponentId>

    az sphere device app start --debug-mode --component-id <ComponentId>

    Powinien zostać wyświetlony następujący komunikat:

     ...
   "Identity": {
     "ComponentId": "<component-id>",
     "ImageId": "<image-id>",
     "ImageType": "Application"
   },
 ...

  4. Użyj klienta terminalu , aby ustanowić połączenie Telnet lub raw TCP w celu odczytania strumienia wyjściowego z procesu. Jako port określ wartość 192.168.35.2 jako adres IP, a numer 2342.

  5. Otwórz interfejs wiersza polecenia przy użyciu programu PowerShell lub standardowego wiersza polecenia w systemie Windows lub powłoki poleceń w systemie Linux i przekaż plik binarny aplikacji .out z kompilacji jako parametr. Spowoduje to włączenie pełnego debugowania kodu źródłowego.

    Wiersz polecenia systemu Windows

    "C:\Program Files (x86)\Microsoft Azure Sphere SDK\Sysroots\*sysroot*\tools\gcc\arm-poky-linux-musleabi-gdb" HelloWorld_HighLevelApp.out

    Windows PowerShell

    & "C:\Program Files (x86)\Microsoft Azure Sphere SDK\Sysroots\*sysroot*\tools\gcc\arm-poky-linux-musleabi-gdb" HelloWorld_HighLevelApp.out

Uwaga

Zestaw SDK Azure Sphere jest dostarczany z wieloma sysrootami , dzięki czemu aplikacje mogą kierować różne zestawy interfejsów API, zgodnie z opisem w wersji środowiska wykonawczego aplikacji, sysrootach i interfejsach API beta. Sysroots są instalowane w folderze instalacji Azure Sphere SDK w obszarze Sysroots.

  1. Ustaw dla celu debugowania zdalnego adres IP 192.168.35.2 na porcie 2345:

    target remote 192.168.35.2:2345

  2. Uruchom dowolne inne wybrane polecenia gdb. Na przykład następujące polecenia ustawiają punkt przerwania przy wpisie na wartość main(), a następnie kontynuuj wykonywanie odpowiednio po punkcie przerwania.

    break main

    c

    Aby uzyskać więcej informacji na temat debugowania za pomocą gdb, zobacz GDB: Debuger projektu GNU lub jedno z wielu innych źródeł na ten temat.

Następne kroki

Masz wbudowaną aplikację wysokiego poziomu do uruchamiania na urządzeniu Azure Sphere. Być może zechcesz go teraz zmodyfikować. Definicje sprzętowe opisują sposób edytowania pliku JSON definicji sprzętu i ponownego generowania skojarzonego pliku nagłówka.

Następnie dowiedz się, jak wdrożyć aplikację wysokiego poziomu z chmury.

Samouczek: tworzenie wdrożenia w chmurze

Zobacz też

Odwiedź Witrynę Azure Sphere Gallery, kolekcję inspirujących, nieutrzymanych i wielokrotnego użytku skryptów, narzędzi i funkcji Azure Sphere.