Samouczek: tworzenie i debugowanie aplikacji partnerów

  • Artykuł

W tym samouczku pokazano, jak utworzyć i debugować przykładowy projekt obejmujący zarówno aplikację wysokiego poziomu, jak i aplikację z obsługą czasu rzeczywistego, w której obie aplikacje komunikują się między rdzeniem A7 wysokiego poziomu a rdzeniem M4 w czasie rzeczywistym. Zobacz Omówienie aplikacji Azure Sphere , aby uzyskać podstawowe informacje o aplikacjach wysokiego poziomu i aplikacjach z obsługą czasu rzeczywistego.

W tym samouczku dowiesz się, jak:

  • Instalowanie narzędzia GNU Arm
  • Konfigurowanie sprzętu do wyświetlania danych wyjściowych
  • Włączanie tworzenia i debugowania
  • Clone the Azure Sphere sample repo
  • Uruchamianie emulatora terminali w celu wyświetlenia danych wyjściowych
  • Tworzenie, uruchamianie i debugowanie aplikacji partnerów

Ważne

W tych instrukcjach założono, że używany jest sprzęt zgodny ze sprzętem do projektowania tablic referencyjnych MT3620 (RDB), takim jak MT3620 Dev Kit firmy Seeed Studios. Jeśli używasz innego sprzętu Azure Sphere, zapoznaj się z dokumentacją producenta, aby dowiedzieć się, czy grafika UART jest narażona i jak uzyskać do niego dostęp. Może być konieczne skonfigurowanie sprzętu w celu innego wyświetlania danych wyjściowych oraz zaktualizowanie przykładowego kodu i pola Uarts pliku app_manifest.json w celu użycia innego obiektu UART.

Wymagania wstępne

Instalowanie narzędzia GNU Arm Embedded Toolchain

  • Visual Studio 2022: Jeśli korzystasz z programu Visual Studio 2022, zainstaluj narzędzie GNU Arm Embedded Toolchain (arm-none-eabi) z witryny internetowej dewelopera Arm.
  • Visual Studio 2019: Narzędzie jest automatycznie instalowane z rozszerzeniem Azure Sphere dla programu Visual Studio w programie Visual Studio 2019. Jeśli używasz programu Visual Studio 2019, przejdź do tematu Konfigurowanie sprzętu do wyświetlania danych wyjściowych. Jeśli jednak ręcznie zainstalowano narzędzie GNU Arm Embedded Toolchain, program Visual Studio użyje zainstalowanej wersji.

Aby zainstalować narzędzie w witrynie internetowej dewelopera arm, znajdź GNU Arm Embedded Toolchain (arm-none-eabi), który zawiera kompilator dla procesora ARM Cortex-M4. Postępuj zgodnie z instrukcjami, aby pobrać i zainstalować kompilator dla platformy systemu operacyjnego.

Domyślnie Visual Studio Code wyszukuje narzędzie i powinna znaleźć zainstalowaną wersję. Jeśli wystąpią problemy z kompilacją związane z narzędziem, sprawdź Ustawienia preferencji>>Rozszerzenia>AzureSphere, aby upewnić się, że "Azure Sphere: Arm Gnu Path" identyfikuje katalog instalacji GNU Arm Embedded Toolchain.

Konfigurowanie sprzętu do wyświetlania danych wyjściowych

Obecnie każdy rdzeń w czasie rzeczywistym obsługuje grafikę UART obsługą samego rekordu TX. Funkcja RTApps może używać tego obiektu UART do wysyłania danych wyjściowych dziennika z urządzenia. Podczas tworzenia i debugowania aplikacji zwykle potrzebny jest sposób odczytywania i wyświetlania danych wyjściowych. Przykład HelloWorld_RTApp_MT3620_BareMetal pokazuje, jak aplikacja może pisać w UART.

Użyj adaptera USB-to-serial, takiego jak FTDI Friend, aby podłączyć grafikę UART z rdzenia w czasie rzeczywistym do portu USB w komputerze. Do nawiązania połączenia szeregowego z ustawieniami terminali 115200-8-N-1 (115200 bps, 8 bitów, bez bitów parzystości, bitów jednoskładnościowych) będzie potrzebny emulator terminalowy .

Aby skonfigurować sprzęt do wyświetlania danych wyjściowych z aplikacji RTApp, wykonaj poniższe czynności. Aby ustalić lokalizacje numerów PIN, należy zapoznać się z dokumentacją producenta sprzętu. Jeśli używasz sprzętu zgodnego ze sprzętem do projektowania tablic referencyjnych MT3620 (RDB), takim jak MT3620 Dev Kit firmy Seeed Studios, poszukaj nagłówków interfejsu RDB może pomóc w określeniu lokalizacji pinezki.

  1. Podłącz GND za pomocą adaptera USB-do-szeregowego do GND w zestawie deweloperów. Na sprzęcie RDB MT3620 GND to Nagłówek 3, pin 2.

  2. Podłącz RX za pomocą adaptera USB-do-szeregowego do IOM4-0 TX w zestawie deweloperów. Na sprzęcie MT3620 RDB IOM4-0 TX to Nagłówek 3, pin 6.

  3. Podłącz adapter USB-do-szeregowy do bezpłatnego portu USB w komputerze deweloperskim i określ, do którego portu jest podłączone urządzenie szeregowe.

    • W systemie Windows uruchom Menedżer urządzeń, wybierz pozycję Wyświetl>urządzenia według kontenera i poszukaj ciągu "USB UART". Na przykład karta FT232R USB UART wskazuje kartę FTDI Friend.

    • W systemie Linux wpisz następujące polecenie:

      dmesg | grep ttyUSB

      Port powinien mieć nazwę ttyUSBn, gdzie n wskazuje numer portu. Jeśli polecenie zawiera listę dmesg kilku portów USB, ten, który jest połączony z zazwyczaj ostatnim zgłaszanym jako dołączony. Na przykład w poniższym przykładzie należy użyć wartości ttyUSB4:

    ~$ dmesg | grep ttyUSB
[  144.564350] usb 1-1.1.2: FTDI USB Serial Device converter now attached to ttyUSB0
[  144.564768] usb 1-1.1.2: FTDI USB Serial Device converter now attached to ttyUSB1
[  144.565118] usb 1-1.1.2: FTDI USB Serial Device converter now attached to ttyUSB2
[  144.565593] usb 1-1.1.2: FTDI USB Serial Device converter now attached to ttyUSB3
[  144.570429] usb 1-1.1.3: FTDI USB Serial Device converter now attached to ttyUSB4
[  254.171871] ftdi_sio ttyUSB1: FTDI USB Serial Device converter now disconnected from ttyUSB1

  4. Uruchom program emulatora terminali i otwórz terminal 115200-8-N-1 do portu COM używanego przez adapter. Zapoznaj się z dokumentacją emulatora terminalu, aby dowiedzieć się, jak określić port i szybkość.

Włączanie tworzenia i debugowania

Aby można było utworzyć przykładową aplikację na urządzeniu Azure Sphere lub opracować dla niej nowe aplikacje, musisz włączyć tworzenie i debugowanie. Domyślnie urządzenia Usługi Azure Sphere są "zablokowane"; oznacza to, że nie zezwalają na aplikacje w trakcie opracowywania, które mają być ładowane z komputera, i nie zezwalają na debugowanie aplikacji. Przygotowanie urządzenia do debugowania usuwa to ograniczenie i ładuje oprogramowanie wymagane do debugowania i odblokowuje możliwości urządzenia.

Aby debugować rdzenie w czasie rzeczywistym, użyj polecenia az sphere device enable-development . To polecenie konfiguruje urządzenie do akceptowania aplikacji z komputera do debugowania i przypisuje urządzenie do grupy urządzeń deweloperów, która nie zezwala na aktualizacje aplikacji w chmurze.This command configures the device to accept applications from a PC for debugging and assigns the device to the development device group, which does not allow cloud application updates. 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.

W systemie Windows musisz dodać --enable-rt-core-debugging parametr, który ładuje serwery debugowania i wymagane sterowniki dla każdego typu rdzenia na urządzeniu.

  1. Jeśli jeszcze tego nie zrobiono, zaloguj się do usługi Azure Sphere:

    az login

  2. Otwórz interfejs wiersza polecenia przy użyciu programu PowerShell lub wiersza polecenia systemu Windows z uprawnieniami administratora. Parametr --enable-rt-core-debugging wymaga uprawnień administratora, ponieważ instaluje sterowniki USB dla debugera.

  3. Wprowadź następujące polecenie:

    az sphere device enable-development --enable-rt-core-debugging  --catalog <CatalogName>  --resource-group <ResourceGroupName>

  4. Zamknij okno po zakończeniu wykonywania polecenia, ponieważ uprawnienia administratora nie są już wymagane. Najlepszym rozwiązaniem jest zawsze użycie najniższego uprawnienia, które może wykonać zadanie.

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

Pobierz przykładowe aplikacje

Aplikacje InterCore Communications 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 — Inter-core Communications z wyników wyszukiwania.
  4. Wybierz pozycję Pobierz plik ZIP.
  5. Otwórz pobrany plik i wyodrębnij go do katalogu lokalnego.

Tworzenie i uruchamianie aplikacji partnerów

  1. Uruchom program Visual Studio. Wybierz pozycję Otwórz folder lokalny i przejdź do folderu, w którym zostały wyodrębnione aplikacje IntercoreComms.

    Ważne

    Jeśli używasz programu Visual Studio 2022 w wersji 17.1 lub nowszej, a próbka intercorecomms została wyodrębniona przed wydaniem wersji 22.02 azure Sphere, musisz dodać plik CMakeWorkspaceSettings.json do folderu projektu najwyższego poziomu.

  2. Jeśli nie używasz bazy danych RDB MT3620, zaktualizuj pliki app_manifest.json zarówno dla aplikacji, jak i dla pliku definicji sprzętu i plikuCMakeLists.txt , aby aplikacja wysokiego poziomu była zgodna ze sprzętem.

  3. Jeśli generowanie klucza CMake nie uruchamia się automatycznie, wybierz plik CMakeLists.txt.

  4. W programie> Visual Studio wyświetl danewyjściowe>pokazu danych wyjściowych z: wyjście CMake powinno zawierać komunikaty CMake generation started i CMake generation finished.

  5. Wybierz pozycję Kompilacja>wszystko. Jeśli menu nie jest dostępne, otwórz Eksplorator rozwiązań, kliknij prawym przyciskiem myszy plik CMakeLists.txt i wybierz pozycję Konstruuj. Lokalizacja wyjściowa aplikacji IntercoreComms RT IntercoreComms_HL & zostanie wyświetlona w oknie Dane wyjściowe .

  6. Wybierz pozycjęIntercoreComms elementu >startowego (wszystkie rdzenie).

  7. Wybierz debugowanie>debugowania lub naciśnij klawisz F5, aby wdrożyć i debugować aplikacje.

  8. W oknie Dane wyjściowe wybierz menu Wybierz dane wyjściowe z , a następnie wybierz pozycję Dane wyjściowe urządzenia. W oknie Dane wyjściowe powinny być wyświetlane dane wyjściowe aplikacji wysokiego poziomu:

    Remote debugging from host 192.168.35.1, port 58817
High-level intercore comms application
Sends data to, and receives data from a real-time capable application.
Received 19 bytes: rt-app-to-hl-app-07
Sending: hl-app-to-rt-app-00
Sending: hl-app-to-rt-app-01

  9. Emulator podłączonego terminalu powinien wyświetlać dane wyjściowe z programu obsługującego czas rzeczywisty:

    Sender: 25025d2c-66da-4448-bae1-ac26fcdd3627
Message size: 19 bytes:
Hex: 68:6c:2d:61:70:70:2d:74:6f:2d:72:74:2d:61:70:70:2d:30:30
Text: hl-app-to-rt-app-00
Sender: 25025d2c-66da-4448-bae1-ac26fcdd3627
Message size: 19 bytes:
Hex: 68:6c:2d:61:70:70:2d:74:6f:2d:72:74:2d:61:70:70:2d:30:31
Text: hl-app-to-rt-app-01

  10. Debuger służy do ustawiania punktów przerwania, sprawdzania zmiennych i wykonywania innych zadań debugowania.

  1. W Visual Studio Code otwórz folder, w którym zostały wyodrębnione aplikacje IntercoreComms. Visual Studio Code wykrywa plik intercore.code-workspace i pyta, czy chcesz otworzyć obszar roboczy. Wybierz pozycję Otwórz obszar roboczy, aby jednocześnie otworzyć zarówno aplikację w czasie rzeczywistym, jak i aplikację wysokiego poziomu.

  2. Jeśli nie używasz bazy danych RDB MT3620, zaktualizuj pliki app_manifest.json zarówno dla aplikacji, jak i dla pliku definicji sprzętu i plikuCMakeLists.txt , aby aplikacja wysokiego poziomu była zgodna ze sprzętem.

  3. Naciśnij klawisz F5 , aby uruchomić debuger. Jeśli projekt nie został wcześniej utworzony lub wymagane są zmiany plików i ich odbudowanie, Visual Studio Code utworze projekt przed rozpoczęciem debugowania.

  4. W oknie danych wyjściowych usługi Azure Sphere powinien być wyświetlany komunikat "Wdrażanie obrazu..." następnie ścieżki do zestawu SDK i kompilatora.

  5. W oknie danych wyjściowych powinny być wyświetlane dane wyjściowe aplikacji wysokiego poziomu:

    Remote debugging from host 192.168.35.1, port 58817
High-level intercore comms application
Sends data to, and receives data from a real-time capable application.
Received 19 bytes: rt-app-to-hl-app-07
Sending: hl-app-to-rt-app-00
Sending: hl-app-to-rt-app-01

  6. Emulator podłączonego terminalu powinien wyświetlać dane wyjściowe z programu obsługującego czas rzeczywisty:

    Sender: 25025d2c-66da-4448-bae1-ac26fcdd3627
Message size: 19 bytes:
Hex: 68:6c:2d:61:70:70:2d:74:6f:2d:72:74:2d:61:70:70:2d:30:30
Text: hl-app-to-rt-app-00
Sender: 25025d2c-66da-4448-bae1-ac26fcdd3627
Message size: 19 bytes:
Hex: 68:6c:2d:61:70:70:2d:74:6f:2d:72:74:2d:61:70:70:2d:30:31
Text: hl-app-to-rt-app-01

  7. Za pomocą funkcji debugowania Visual Studio Code możesz ustawiać punkty przerwania, sprawdzać zmienne i wykonywać inne zadania debugowania.

Rozwiązywanie problemów

Aplikacja może rozpocząć wykonywanie przed OpenOCD tworzy połączenie. W związku z tym punkty przerwania ustawione na początku kodu mogą zostać pominięte. Prostym obejściem tego problemu jest opóźnienie uruchamiania aplikacji do momentu nawiązania połączenia przez openOCD.

  1. Wstaw następujący kod na początku punktu wejścia aplikacji RTCoreMain. Spowoduje to, że aplikacja będzie wprowadzać i pozostać w while pętli, dopóki zmienna f nie zostanie ustawiona na wartość true.

    static _Noreturn void RTCoreMain(void)
{
  .
  .
  .
 volatile bool f = false;
 while (!f) {
    // empty.
 }
  .
  .
  .
}

  2. Naciśnij klawisz F5, aby uruchomić aplikację z debugowaniem, a następnie włamać się do wykonania.

  3. W okienku Debugowanie miejscowi zmień wartość f z zero na jedną.

  4. Przeprowadź kod w zwykły sposób.

Podczas tworzenia za pomocą interfejsu użytkownika należy najpierw utworzyć i wdrożyć aplikację obsługującą w czasie rzeczywistym, a następnie utworzyć i wdrożyć aplikację wysokiego poziomu.

Tworzenie i wdrażanie aplikacji z obsługą czasu rzeczywistego

  1. Przejdź do folderu, w którym zostały wyodrębnione aplikacje IntercoreComms, a następnie wybierz folder IntercoreComms/IntercoreComms_RTApp_MT3620_BareMetal.

  2. Otwórz plik app_manifest.json i sprawdź, czy identyfikator składnika aplikacji wysokiego poziomu jest widoczny w funkcji AllowedApplicationConnections.

  3. 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.

  4. 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 aplikacji IntercoreComms RTApp:

    Wiersz polecenia systemu Windows

     cmake ^
--preset "ARM-Debug" ^
 "C:\AzSphere\azure-sphere-samples\Samples\IntercoreComms\IntercoreComms_RTApp_MT3620_BareMetal"

    Windows PowerShell

     cmake `
--preset "ARM-Debug" `
 "C:\AzSphere\azure-sphere-samples\Samples\IntercoreComms\IntercoreComms_RTApp_MT3620_BareMetal"

  5. W katalogu kompilacji projektu w wierszu polecenia uruchom aplikację 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.

  6. Usuń wszystkie aplikacje, które są już wdrożone na urządzeniu:

    az sphere device sideload delete

  7. Z katalogu kompilacji projektu w wierszu polecenia załaduj pakiet obrazów utworzony przez ninja:

    az sphere device sideload deploy --image-package <path-to-imagepackage>

    Aplikacja zacznie działać wkrótce po jej załadowaniu.

  8. Uzyskaj identyfikator składnika obrazu:

    az sphere image-package show --image-package <path-to-imagepackage>

    Polecenie zwróci wszystkie metadane pakietu obrazów. Identyfikator składnika aplikacji jest wyświetlany w sekcji Tożsamość dla typu obrazu aplikacji. Na przykład:

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

Tworzenie i wdrażanie aplikacji wysokiego poziomu

  1. Przejdź do folderu, w którym zostały wyodrębnione aplikacje IntercoreComms, a następnie wybierz folder IntercoreComms/IntercoreComms_HighLevelApp.

  2. Otwórz plik app_manifest.json i sprawdź, czy identyfikator składnika aplikacji RTApp jest widoczny w funkcji AllowedApplicationConnections.

  3. 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.

  4. 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 aplikacji intercorecomms wysokiego poziomu.

    Wiersz polecenia systemu Windows

     cmake ^
 --preset "ARM-Debug" ^
 "C:\AzSphere\azure-sphere-samples\Samples\IntercoreComms\IntercoreComms_HighLevelApp"

    Windows PowerShell

     cmake `
 --preset "ARM-Debug" `
 "C:\AzSphere\azure-sphere-samples\Samples\IntercoreComms\IntercoreComms_HighLevelApp"

  5. W katalogu kompilacji projektu w wierszu polecenia uruchom aplikację 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.

  6. Z katalogu kompilacji projektu w wierszu polecenia załaduj pakiet obrazów utworzony przez ninja:

    az sphere device sideload deploy --image-package <package-name>

    Aplikacja zacznie działać wkrótce po jej załadowaniu.

  7. Uzyskaj identyfikator składnika obrazu:

    az sphere image-package show --image-package <path-to-imagepackage>

    Polecenie zwróci wszystkie metadane pakietu obrazów. Identyfikator składnika aplikacji jest wyświetlany w sekcji Tożsamość dla typu obrazu aplikacji. Na przykład:

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

Uruchamianie aplikacji partnerów z włączonym debugowaniem

  1. Zatrzymaj aplikację w czasie rzeczywistym, jeśli jest uruchomiona.

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

  2. Uruchom ponownie aplikację do debugowania.

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

    To polecenie zwraca rdzeń, na którym działa aplikacja.

      <component id>
  App state: running
  Core        : Real-time 0

  3. Przejdź do folderu Openocd dla sysroot, za pomocą których aplikacja została utworzona. Sysroots są instalowane w folderze instalacji Azure Sphere SDK. Na przykład w systemie Windows folder jest domyślnie instalowany w systemie C:\Program Files (x86)\Microsoft Azure Sphere SDK\Sysroots\*sysroot*\tools\openocd Linux i w systemie Linux pod adresem /opt/azurespheresdk/Sysroots/*sysroot*/tools/sysroots/x86_64-pokysdk-linux.

  4. Uruchom openocd , jak pokazano w poniższym przykładzie. W przykładzie założono, że aplikacja jest uruchomiona na rdzeniu 0. Jeśli aplikacja działa na rdzeniu 1, zamień elementy docelowe io0 na "cele io1".

       openocd -f mt3620-rdb-ftdi.cfg -f mt3620-io0.cfg -c "gdb_memory_map disable" -c "gdb_breakpoint_override hard" -c init -c "targets io0" -c halt -c "targets"

  5. Otwórz nowy wiersz polecenia w usłudze Azure Sphere (klasyczny interfejs CLI w usłudze Windows Azure Sphere), wiersz polecenia standardowy lub program PowerShell (Windows Azure CLI) lub okno terminalu (Linux).

  6. Przejdź do folderu zawierającego plik .out z obsługą czasu rzeczywistego i uruchom arm-none-eabi-gdb, który jest częścią narzędzia GNU Arm Embedded Toolchain:

    Wiersz polecenia systemu Windows

    "C:\Program Files (x86)\GNU Arm Embedded Toolchain\9 2020-q2-update\bin\arm-none-eabi-gdb" IntercoreComms_RTApp_MT3620_BareMetal.out

    Windows PowerShell

     & "C:\Program Files (x86)\GNU Arm Embedded Toolchain\9 2020-q2-update\bin\arm-none-eabi-gdb" IntercoreComms_RTApp_MT3620_BareMetal.out

  7. Serwer OpenOCD zapewnia interfejs serwera GDB w systemie :4444. Ustaw cel debugowania.

    target remote :4444

  8. Teraz można uruchamiać polecenia gdb w aplikacji obsługowej w czasie rzeczywistym. Dodawanie punktu przerwania w funkcji HandleSendTimerDeferred:

    break HandleSendTimerDeferred

  9. Połączony emulator terminalu powinien wyświetlać dane wyjściowe z aplikacji obsługującej w czasie rzeczywistym.

  10. Otwórz nowy wiersz polecenia w usłudze Azure Sphere (klasyczny interfejs CLI w usłudze Windows Azure Sphere), wiersz polecenia standardowy lub program PowerShell (Windows Azure CLI) lub okno terminalu (Linux).

  11. Przejdź do folderu zawierającego plik .imagepackage aplikacji wysokiego poziomu.

  12. Zatrzymaj aplikację wysokiego poziomu, jeśli jest uruchomiona.

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

  13. Uruchom ponownie aplikację wysokiego poziomu za pomocą debugowania.

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

  14. Otwórz emulator terminali i nawiąż połączenie Telnet lub TCP z aktualizacją 192.168.35.2 na porcie 2342, aby wyświetlić dane wyjściowe aplikacji wysokiego poziomu.

  15. Uruchom gdb za pomocą następującego polecenia:

    Wiersz polecenia systemu Windows

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

    Windows PowerShell

    & "C:\Program Files (x86)\Microsoft Azure Sphere SDK\Sysroots\*sysroot*\tools\gcc\arm-poky-linux-musleabi-gdb.exe" IntercoreComms_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.

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

    target remote 192.168.35.2:2345

  17. Dodaj punkt przerwania w funkcji SendMessageToRTApp:

    break SendMessageToRTApp

  18. Wpisz c , aby kontynuować, obserwuj dane wyjściowe w terminalu Telnet/TCP, a następnie przełącz się do wiersza polecenia lub okna terminalu zawierającego sesję debugowania aplikacji w czasie rzeczywistym.

  19. Wpisz, c aby kontynuować i obserwować dane wyjściowe w połączonej sesji szeregowej.

Możesz pracować tam iz powrotem między sesjami debugowania, przełączając się między aplikacją obsługą czasu rzeczywistego a aplikacją wysokiego poziomu. W dwóch oknach wyjściowych powinny być widoczne dane wyjściowe podobne do następujących:

Starting debugger....
                     Process /mnt/apps/25025d2c-66da-4448-bae1-ac26fcdd3627/bin/app created; pid = 40
                     Listening on port 2345
                                           Remote debugging from host 192.168.35.1, port 56522
              High-level intercore comms application
                                                    Sends data to, and receives data from a real-time capable application.
                                          Sending: hl-app-to-rt-app-00
                                                                      Sending: hl-app-to-rt-app-01

IntercoreComms_RTApp_MT3620_BareMetal
App built on: Nov 17 2020, 09:25:19
Sender: 25025d2c-66da-4448-bae1-ac26fcdd3627
Message size: 19 bytes:
Hex: 68:6c:2d:61:70:70:2d:74:6f:2d:72:74:2d:61:70:70:2d:30:30
Text: hl-app-to-rt-app-00

Aby zakończyć każdą sesję debugowania, wpisz q tekst w wierszu polecenia gdb.

Następne kroki