Tutorial: Criar e depurar aplicativos de parceiros

Artigo
03/01/2025

Importante

Esta é a documentação do Azure Sphere (Legado). O Azure Sphere (Legado) será desativado em 27 de setembro de 2027 e os usuários devem migrar para o Azure Sphere (Integrado) até esse momento. Use o seletor de versão localizado acima do sumário para exibir a documentação do Azure Sphere (Integrado).

Este tutorial mostra como criar e depurar um projeto de exemplo que inclui um aplicativo de alto nível e um aplicativo capaz de tempo real, onde os dois aplicativos se comunicam entre o núcleo A7 de alto nível e o núcleo M4 em tempo real. Consulte Visão geral dos aplicativos do Azure Sphere para obter informações básicas sobre aplicativos de alto nível e aplicativos capazes de tempo real.

Neste tutorial, irá aprender a:

Instale a cadeia de ferramentas GNU Arm
Configurar o hardware para exibir a saída
Habilitar desenvolvimento e depuração
Clone o repositório de exemplo do Azure Sphere
Iniciar um emulador de terminal para visualizar a saída
Crie, execute e depure um par de aplicativos parceiros

Importante

Estas instruções pressupõem que você esteja usando hardware que segue o hardware de design de placa de referência (RDB) MT3620, como o MT3620 Dev Kit da Seeed Studios. Se você estiver usando hardware diferente do Azure Sphere, consulte a documentação do fabricante para descobrir se o UART está exposto e como acessá-lo. Talvez seja necessário configurar o hardware para exibir a saída de forma diferente e atualizar o código de exemplo e o campo "Uarts" do arquivo app_manifest.json para usar um UART diferente.

Pré-requisitos

Instale CMake e Ninja para Windows ou Linux.

Instale o Visual Studio Code para Windows ou Linux.
Instale CMake e Ninja para Windows ou Linux.

Instale a extensão Azure Sphere para Visual Studio.

Instalar o SDK do Azure Sphere para Windows ou Linux
Escolha um inquilino e reclame o seu dispositivo
Configurar a rede e atualizar o SO do dispositivo

Instale a Cadeia de Ferramentas GNU ARM Incorporada.

Visual Studio 2022: Se você estiver usando o Visual Studio 2022, instale o GNU Arm Embedded Toolchain (arm-none-eabi) do site do desenvolvedor Arm.
Visual Studio 2019: A cadeia de ferramentas é instalada automaticamente com a Extensão do Azure Sphere para Visual Studio no Visual Studio 2019. Se você estiver usando o Visual Studio 2019, prossiga para Configurar hardware para exibir a saída. No entanto, se você instalou o GNU Arm Embedded Toolchain manualmente, o Visual Studio usará a versão que você instalou.

Para instalar a cadeia de ferramentas, no site do desenvolvedor Arm, encontre o GNU Arm Embedded Toolchain (arm-none-eabi) que inclui o compilador para o processador ARM Cortex-M4. Siga as instruções para baixar e instalar o compilador para sua plataforma de sistema operacional.

Por padrão, o Visual Studio Code procura a cadeia de ferramentas e deve encontrar a versão instalada. Se você encontrar problemas de compilação relacionados à cadeia de ferramentas, verifique Preferences>Settings>Extensions>AzureSphere para garantir que "Azure Sphere: Arm Gnu Path" identifique o diretório de instalação do GNU Arm Embedded Toolchain.

Configurar o hardware para exibir a saída

Atualmente, cada núcleo em tempo real suporta um UART somente TX. RTApps pode usar este UART para enviar saída de log do dispositivo. Durante o desenvolvimento e a depuração de aplicativos, você normalmente precisa de uma maneira de ler e exibir a saída. O exemplo de HelloWorld_RTApp_MT3620_BareMetal mostra como um aplicativo pode gravar no UART.

Use um adaptador USB para serial, como o FTDI Friend, para conectar o UART no núcleo em tempo real a uma porta USB em sua máquina. Você também precisará de um emulador de terminal para estabelecer uma conexão serial com configurações de terminal 115200-8-N-1 (115200 bps, 8 bits, sem bits de paridade, um bit de parada) para exibir a saída.

Para configurar o hardware para apresentar o resultado a partir de um RTApp, siga estes passos. Terá de consultar a documentação do fabricante do seu hardware para determinar as localizações afixadas. Se estiver a utilizar hardware que segue o hardware de estrutura de placa de referência (RDB) MT3620, como o Kit para Programador MT3620 da Seeed Studios, observar os cabeçalhos de interface RDB pode ajudá-lo a determinar as localizações afixadas.

Ligue o GND no adaptador USB para série ao GND no seu kit de programador. No hardware RDB MT3620, GND é Cabeçalho 3, marcador 2.
Ligue o RX no adaptador USB para série ao IOM4-0 TX no seu kit para programador. No hardware RDB MT3620, IOM4-0 TX é Cabeçalho 3, marcador 6.
Conecte o adaptador USB para serial a uma porta USB livre em sua máquina de desenvolvimento e determine a qual porta o dispositivo serial está conectado.
- No Windows, inicie o Gerenciador de dispositivos, selecione Exibir>dispositivos por contêiner e procure por 'USB UART'. Por exemplo, FT232R USB UART indica o adaptador FTDI Friend.
- No Linux, digite o seguinte comando:
```
dmesg | grep ttyUSB
```
  A porta deve ser chamada ttyUSBn, onde n indica o número da porta. Se o dmesg comando listar várias portas USB, aquela que está conectada à normalmente a última relatada como anexada. Por exemplo, a seguir, você usaria 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
```
Inicie um programa emulador de terminal e abra um terminal 115200-8-N-1 para a porta COM usada pelo adaptador. Consulte a documentação do emulador de terminal para descobrir como especificar a porta e a velocidade.

Habilitar desenvolvimento e depuração

Antes de criar um aplicativo de exemplo em seu dispositivo Azure Sphere ou desenvolver novos aplicativos para ele, você deve habilitar o desenvolvimento e a depuração. Por padrão, os dispositivos do Azure Sphere são "bloqueados"; ou seja, não permitem que aplicações em desenvolvimento sejam carregadas a partir de um PC e não permitem a depuração de aplicações. A preparação do dispositivo para depuração remove essa restrição e carrega o software necessário para a depuração e desbloqueia os recursos do dispositivo, conforme descrito em Recursos e comunicação do dispositivo.

Para depurar nos núcleos em tempo real, use o comando azsphere device enable-development. Este comando configura o dispositivo para aceitar aplicativos de um PC para depuração e atribui o dispositivo ao grupo de dispositivos de desenvolvimento, que não permite atualizações de aplicativos na nuvem. Durante o desenvolvimento e a depuração de aplicativos, você deve deixar o dispositivo nesse grupo para que as atualizações de aplicativos na nuvem não substituam o aplicativo em desenvolvimento.

No Windows, você deve adicionar o --enable-rt-core-debugging parâmetro, que carrega os servidores de depuração e os drivers necessários para cada tipo de núcleo no dispositivo.

Windows
Linux

Inicie sessão no Azure Sphere se ainda não o tiver feito:
```
azsphere login
```
Abra uma interface de linha de comando usando o PowerShell ou o Prompt de Comando do Windows com privilégios de administrador. O --enable-rt-core-debugging parâmetro requer privilégio de administrador porque instala drivers USB para o depurador.

Introduza o seguinte comando:

azsphere device enable-development --enable-rt-core-debugging

Feche a janela após a conclusão do comando porque o privilégio de administrador não é mais necessário. Como prática recomendada, você deve sempre usar o menor privilégio que pode realizar uma tarefa.

Se o comando azsphere device enable-development falhar, consulte Solucionar problemas do Azure Sphere para obter ajuda.

Transferir a aplicação de exemplo

Você pode baixar os aplicativos InterCore Communications da seguinte maneira:

Aponte seu navegador para Microsoft Samples Browser.
Digite "Azure Sphere" na caixa Pesquisar.
Selecione Azure Sphere - Inter-core Communications nos resultados da pesquisa.
Selecione Baixar ZIP.
Abra o arquivo baixado e extraia para um diretório local.

Crie e execute os aplicativos de parceiros

Inicie o Visual Studio. Selecione Abrir uma pasta local e navegue até a pasta onde você extraiu os aplicativos IntercoreComms.

Importante

Se você estiver usando o Visual Studio 2022 versão 17.1 ou posterior e tiver extraído o exemplo IntercoreComms antes da versão 22.02 do Azure Sphere, deverá adicionar um arquivo CMakeWorkspaceSettings.json à sua pasta de projeto de nível superior.
Se você não estiver usando um RDB MT3620, atualize os arquivos de app_manifest.json para ambos os aplicativos e o arquivo de definição de hardware e CMakeLists.txt arquivo para o aplicativo de alto nível para corresponder ao seu hardware.
Se a geração CMake não iniciar automaticamente, selecione o arquivo CMakeLists.txt.
No Visual Studio, View>>Show output from: CMake output deve mostrar as mensagens CMake generation started e .CMake generation finished
Selecione Build>Build All. Se o menu não estiver presente, abra o Gerenciador de Soluções, clique com o botão direito do mouse no arquivo de CMakeLists.txt e selecione Compilar. O local de saída dos aplicativos IntercoreComms_HL & IntercoreComms RT aparece na janela Saída .
Selecione Select Startup Item>IntercoreComms (All cores).
Selecione Depurar> depuração ou pressione F5 para implantar e depurar os aplicativos.

Na janela Saída, selecione saída no menu, selecione Saída do dispositivo. A janela Saída deve mostrar a saída do aplicativo de alto nível:

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

O emulador de terminal conectado deve exibir a saída do programa capaz de tempo real:

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

Use o depurador para definir pontos de interrupção, inspecionar variáveis e tentar outras tarefas de depuração.

No Visual Studio Code, abra a pasta onde você extraiu os aplicativos IntercoreComms. O Visual Studio Code deteta o arquivo intercore.code-workspace e pergunta se você deseja abrir o espaço de trabalho. Selecione Abrir espaço de trabalho para abrir o aplicativo em tempo real e o aplicativo de alto nível de uma só vez.
Se você não estiver usando um RDB MT3620, atualize os arquivos de app_manifest.json para ambos os aplicativos e o arquivo de definição de hardware e CMakeLists.txt arquivo para o aplicativo de alto nível para corresponder ao seu hardware.
Pressione F5 para iniciar o depurador. Se o projeto não tiver sido criado anteriormente ou se os arquivos tiverem sido alterados e a reconstrução for necessária, o Visual Studio Code criará o projeto antes do início da depuração.
A janela de saída do Azure Sphere deve apresentar a mensagem "A implementar imagem…" seguida dos caminhos para o SDK e para o compilador.

A janela de saída deve mostrar a saída do aplicativo de alto nível:

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

O emulador de terminal conectado deve exibir a saída do programa capaz de tempo real:

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

Use os recursos de depuração do Visual Studio Code para definir pontos de interrupção, inspecionar variáveis e tentar outras tarefas de depuração.

Resolução de Problemas

O aplicativo pode começar a ser executado antes que o OpenOCD faça uma conexão. Como resultado, os pontos de interrupção definidos no início do código podem ser perdidos. Uma solução simples para isso é atrasar o início do aplicativo até que o OpenOCD se conecte.

Insira o seguinte código no início do ponto de entrada do aplicativo RTCoreMain. Isso fará com que o aplicativo entre e permaneça em um while loop até que a variável f seja definida como true.
```
static _Noreturn void RTCoreMain(void)
{
  .
  .
  .
 volatile bool f = false;
 while (!f) {
    // empty.
 }
  .
  .
  .
}
```
Pressione F5 para iniciar o aplicativo com depuração e, em seguida, interromper a execução.
No painel de depuração Locais, altere o valor de f zero para um.
Percorra o código como de costume.

Ao criar com a CLI, você primeiro cria e implanta o aplicativo capaz de tempo real e, em seguida, cria e implanta o aplicativo de alto nível.

Crie e implante o aplicativo com capacidade em tempo real

Navegue até a pasta onde você extraiu os aplicativos IntercoreComms e, em seguida, selecione a pasta IntercoreComms/IntercoreComms_RTApp_MT3620_BareMetal.
Abra o arquivo app_manifest.json e verifique se a ID do componente do aplicativo de alto nível é mostrada no recurso AllowedApplicationConnections.
Abra uma interface de linha de comando usando PowerShell, Prompt de Comando do Windows ou shell de comando do Linux. Navegue até o diretório de compilação do projeto.
No diretório de compilação do projeto, no prompt de comando, execute o CMake com os seguintes parâmetros:
```
cmake --preset <preset-name> <source-path>
```
- --preset <preset-name>
  
  O nome da predefinição de configuração de compilação conforme definido em CMakePresets.json.
- --build <cmake-path>
  
  O diretório binário que contém o cache CMake. Por exemplo, se você executar o CMake em um exemplo do Azure Sphere, o comando build será cmake --build out/ARM-Debug.
- <source-path>
  
  O caminho do diretório que contém os arquivos de origem para o aplicativo de exemplo. No exemplo, o repositório de exemplos do Azure Sphere foi baixado para um diretório chamado AzSphere.
  
  Os parâmetros CMake são separados por espaços. O caractere de continuação de linha (^ para linha de comando do Windows, \ para linha de comando do Linux ou ' para PowerShell) pode ser usado para legibilidade, mas não é necessário.
Os exemplos a seguir mostram os comandos CMake para o IntercoreComms RTApp:
- Windows
- Linux
Linha de Comandos do 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"
```
```
 cmake \
--preset "ARM-Debug" \
 ./AzSphere/azure-sphere-samples/Samples/IntercoreComms/IntercoreComms_RTApp_MT3620_BareMetal
```
No diretório de compilação do projeto, no prompt de comando, execute o Ninja para construir o aplicativo e criar o arquivo do pacote de imagem.
```
ninja -C out/ARM-Debug
```
Ninja coloca o aplicativo resultante e os arquivos .imagepackage no diretório especificado.

Você também pode invocar Ninja através do CMake com o seguinte comando:
```
cmake --build out/<binary-dir>
```
Defina <binary-dir> para o diretório binário que contém o cache CMake. Por exemplo, se você executar o CMake em um exemplo do Azure Sphere, o comando build será cmake --build out/ARM-Debug.

Ao solucionar problemas, especialmente depois de fazer alterações nos comandos do CMake, exclua toda a compilação e tente novamente.
Exclua todos os aplicativos que já estão implantados no dispositivo:
```
azsphere device sideload delete
```
No diretório build do seu projeto, no prompt de comando, carregue o pacote de imagem que o ninja criou:
```
azsphere device sideload deploy --image-package <path-to-imagepackage>
```
O aplicativo começará a ser executado logo após ser carregado.

Obtenha o ID do componente para a imagem:

azsphere image-package show --image-package <path-to-imagepackage>

O comando retorna todos os metadados para o pacote de imagem. O ID do componente para o aplicativo aparece na seção Identidade do Tipo de Imagem do Aplicativo. Por exemplo:

Image package metadata:
Section: Identity
Image Type:           Application
Component ID:         <component id>
Image ID:             <image id>

Crie e implante o aplicativo de alto nível

Navegue até a pasta onde você extraiu os aplicativos IntercoreComms e selecione a pasta IntercoreComms/IntercoreComms_HighLevelApp.
Abra o arquivo app_manifest.json e verifique se a ID do componente RTApp é mostrada no recurso AllowedApplicationConnections.
Abra uma interface de linha de comando usando PowerShell, Prompt de Comando do Windows ou shell de comando do Linux. Navegue até o diretório de compilação do projeto.
No diretório de compilação do projeto, no prompt de comando, execute o CMake com os seguintes parâmetros:
```
cmake --preset <preset-name> <source-path>
```
- --preset <preset-name>
  
  O nome da predefinição de configuração de compilação conforme definido em CMakePresets.json.
- --build <cmake-path>
  
  O diretório binário que contém o cache CMake. Por exemplo, se você executar o CMake em um exemplo do Azure Sphere, o comando build será cmake --build out/ARM-Debug.
- <source-path>
  
  O caminho do diretório que contém os arquivos de origem para o aplicativo de exemplo. No exemplo, o repositório de exemplos do Azure Sphere foi baixado para um diretório chamado AzSphere.
  
  Os parâmetros CMake são separados por espaços. O caractere de continuação de linha (^ para linha de comando do Windows, \ para linha de comando do Linux ou ' para PowerShell) pode ser usado para legibilidade, mas não é necessário.
Os exemplos a seguir mostram os comandos CMake para o aplicativo de alto nível IntercoreComms.
- Windows
- Linux
Linha de Comandos do 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"
```
```
 cmake \
 --preset "ARM-Debug" \
 ./AzSphere/azure-sphere-samples/Samples/IntercoreComms/IntercoreComms_HighLevelApp
```
No diretório de compilação do projeto, no prompt de comando, execute o Ninja para construir o aplicativo e criar o arquivo do pacote de imagem.
```
ninja -C out/ARM-Debug
```
Ninja coloca o aplicativo resultante e os arquivos .imagepackage no diretório especificado.

Você também pode invocar Ninja através do CMake com o seguinte comando:
```
cmake --build out/<binary-dir>
```
Defina <binary-dir> para o diretório binário que contém o cache CMake. Por exemplo, se você executar o CMake em um exemplo do Azure Sphere, o comando build será cmake --build out/ARM-Debug.

Ao solucionar problemas, especialmente depois de fazer alterações nos comandos do CMake, exclua toda a compilação e tente novamente.
No diretório build do seu projeto, no prompt de comando, carregue o pacote de imagem que o ninja criou:
```
azsphere device sideload deploy --image-package <package-name>
```
O aplicativo começará a ser executado logo após ser carregado.

Obtenha o ID do componente para a imagem:

azsphere image-package show --image-package <path-to-imagepackage>

O comando retorna todos os metadados para o pacote de imagem. O ID do componente para o aplicativo aparece na seção Identidade do Tipo de Imagem do Aplicativo. Por exemplo:

Image package metadata:
  Section: Identity
    Image Type:           Application
    Component ID:         <component id>
    Image ID:             <image id>

Execute os aplicativos parceiros com a depuração habilitada

Pare o aplicativo em tempo real se ele estiver em execução.
```
azsphere device app stop --component-id <component id>
```

Reinicie o aplicativo para depuração.

azsphere device app start --component-id <component id>

Este comando retorna o núcleo no qual o aplicativo está sendo executado.

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

Navegue até a pasta Openocd para o sysroot com o qual o aplicativo foi construído. Os sysroots são instalados na pasta de instalação do SDK do Azure Sphere. Por exemplo, no Windows a pasta é instalada por padrão em C:\Program Files (x86)\Microsoft Azure Sphere SDK\Sysroots\*sysroot*\tools\openocd e no Linux, em /opt/azurespheresdk/Sysroots/*sysroot*/tools/sysroots/x86_64-pokysdk-linux.

Execute openocd como mostra o exemplo a seguir. O exemplo pressupõe que o aplicativo está sendo executado no núcleo 0. Se o aplicativo estiver sendo executado no núcleo 1, substitua "targets io0" por "targets io1".

Windows
Linux

   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"

   ./usr/bin/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"

Abra uma CLI do Azure Sphere usando PowerShell, Prompt de Comando do Windows ou um shell de comando do Linux.
Navegue até a pasta que contém o arquivo .out do aplicativo capaz de tempo real e inicie arm-none-eabi-gdb, que faz parte da GNU Arm Embedded Toolchain:
- Windows
- Linux
Linha de Comandos do 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
```
/opt/gnu-arm-toolchain/arm-none-eabi-gdb IntercoreComms_RTApp_MT3620_BareMetal.out
O servidor OpenOCD fornece uma interface de servidor GDB em :4444. Defina o destino para depuração.

target remote :4444
Agora você pode executar comandos gdb para o aplicativo capaz de tempo real. Adicione um ponto de interrupção na função HandleSendTimerDeferred:
```
break HandleSendTimerDeferred
```
O emulador de terminal conectado deve exibir a saída do aplicativo capaz de tempo real.
Abra uma CLI do Azure Sphere usando PowerShell, Prompt de Comando do Windows ou um shell de comando do Linux.
Navegue até a pasta que contém o arquivo .imagepackage do aplicativo de alto nível.
Pare o aplicativo de alto nível se ele estiver em execução.
```
azsphere device app stop --component-id <component id>
```

Reinicie o aplicativo de alto nível com depuração.

azsphere device app start --component-id <component id> --debug-mode

Abra um emulador de terminal e estabeleça uma conexão Telnet ou TCP para 192.168.35.2 na porta 2342 para visualizar a saída do aplicativo de alto nível.

Inicie o gdb com o seguinte comando:

Windows
Linux

Linha de Comandos do 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

/opt/azurespheresdk/Sysroots/*sysroot*/tools/sysroots/x86_64-pokysdk-linux/usr/bin/arm-poky-linux-musleabi/arm-poky-linux-musleabi-gdb IntercoreComms_HighLevelApp.out

Nota

O SDK do Azure Sphere é fornecido com várias sysroots para que os aplicativos possam direcionar diferentes conjuntos de APIs, conforme descrito em Versão do tempo de execução do aplicativo, sysroots e APIs Beta. Os sysroots são instalados na pasta de instalação do SDK do Azure Sphere em Sysroots.

Defina o destino de depuração remota para o endereço IP 192.168.35.2 na porta 2345:

target remote 192.168.35.2:2345
Adicione um ponto de interrupção na função SendMessageToRTApp:

break SendMessageToRTApp
Digite c para continuar, observe a saída em seu terminal Telnet/TCP e alterne para o prompt de comando ou janela do terminal que contém sua sessão de depuração de aplicativos em tempo real.
Digite c para continuar e observar a saída em sua sessão serial conectada.

Você pode trabalhar entre sessões de depuração, alternando entre o aplicativo capaz de tempo real e o aplicativo de alto nível. Você deve ver uma saída semelhante à seguinte nas duas janelas de saída:

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

Para encerrar cada sessão de depuração, digite q no prompt gdb.

Próximos passos

Explore amostras adicionais para aplicativos de alto nível e com capacidade em tempo real
Saiba mais sobre os aplicativos do Azure Sphere
Saiba mais sobre o ambiente de desenvolvimento do Azure Sphere

Partilhar via