Tutorial: Criar um aplicativo de alto nível

Artigo
08/09/2023

Um aplicativo de alto nível é executado no sistema operacional do Azure Sphere, usa as bibliotecas de aplicativos do Azure Sphere e pode se comunicar com a Internet e com serviços baseados em nuvem. Consulte Visão geral dos aplicativos do Azure Sphere para obter informações básicas sobre aplicativos de alto nível.

Neste tutorial, você aprenderá a:

Preparar seu dispositivo para desenvolvimento e depuração

Criar, executar e depurar um aplicativo de alto nível

Pré-requisitos

Instale CMake e Ninja para Windows ou para Linux.

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

Instale o Visual Studio e a extensão do Azure Sphere.

Instale o SDK para Windows ou para Linux.
Escolha um catálogo e reclame seu dispositivo.
Configure a rede e atualize o sistema operacional do dispositivo.

Preparar seu dispositivo para desenvolvimento e depuração

Antes de criar um aplicativo de exemplo em seu dispositivo do Azure Sphere ou desenvolver novos aplicativos para ele, você deve habilitar o desenvolvimento e o sideload. Por padrão, os dispositivos do Azure Sphere são "bloqueados"; ou seja, eles não permitem que aplicativos em desenvolvimento sejam carregados de um computador e não permitem a depuração de aplicativos. Preparar o dispositivo para sideload remove essa restrição.

O comando az sphere device enable-development configura o dispositivo para aceitar aplicativos para depuração, carrega o servidor de depuração no dispositivo e atribui o dispositivo a um grupo de dispositivos que não permite atualizações de aplicativos de nuvem. Durante o desenvolvimento e depuração do aplicativo, você deve deixar o dispositivo nesse grupo para que as atualizações de aplicativos de nuvem não substituam o aplicativo em desenvolvimento.

Verifique se o dispositivo do Azure Sphere está conectado ao computador e que o computador está conectado à Internet.
Abra uma interface de linha de comando usando o PowerShell, o Prompt de Comando do Windows ou o shell de comando do Linux.

Insira o seguinte comando:

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

Você deve ver uma saída semelhante à seguinte:

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.

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

Compilar e executar o aplicativo de alto nível com Visual Studio Code

Este tutorial usa o modelo blink do Azure Sphere, que faz parte da Extensão do Azure Sphere para Visual Studio Code. O modelo Blink pisca um LED para que você possa verificar se o dispositivo e as ferramentas do Azure Sphere estão instalados e configurados corretamente.

Inicie Visual Studio Code. Selecione Exibir>paleta de comandos e digite "Azure Sphere: Gerar Novo Projeto".
Selecione Piscar no menu Modelos.

Visual Studio Code exibe uma janela de Explorador de Arquivos. Navegue até a pasta em que você deseja colocar o aplicativo Blink. Visual Studio Code cria a pasta Blink em seu local selecionado e gera os arquivos de build para o aplicativo Blink. Você deve ver mensagens do CMake.
Abra o arquivo CMakeLists.txt e altere a configuração TARGET_DIRECTORY para especificar a pasta que contém definições para o hardware que você está usando. Por padrão, o TARGET_DIRECTORY especifica HardwareDefinitions/mt3620_rbd, que corresponde ao Kit de Desenvolvimento MT3620 do Seeed Azure Sphere:
```
azsphere_target_hardware_definition(${PROJECT_NAME} TARGET_DIRECTORY "HardwareDefinitions/mt3620_rdb" TARGET_DEFINITION "template_appliance.json")
```
Várias definições de hardware são fornecidas com o modelo. Por exemplo, se você estiver usando um SEEED MT3620 Mini Dev Board, especifique HardwareDefinitions/seeed_mt3620_mdb em vez disso.
Pressione F5 para criar e depurar o projeto. Se o projeto não tiver sido criado anteriormente ou se os arquivos tiverem sido alterados e a reconstrução for necessária, Visual Studio Code criará o projeto antes do início da depuração.
Aguarde vários segundos para Visual Studio Code criar o aplicativo, criar um pacote de imagem, implantá-lo no quadro e iniciá-lo no modo de depuração. Você verá status atualizações no painel Saída ao longo do caminho.

Primeiro, o CMake determina se o aplicativo precisa ser criado. Nesse caso, o foco muda para o painel de saída, que exibe a saída de CMake/Build.

Em seguida, o painel de saída mostra a saída à medida que implanta o pacote de imagem no dispositivo. Por fim, o Console de Depuração recebe o foco e mostra a saída do gdb.

Ponta

Anote a localização do pacote de imagens, pois você precisará dele quando criar uma implantação. Você deve ver uma mensagem como "Criar arquivos gravados no <caminho>" na janela Saída , em que <o caminho> é o caminho completo para a pasta de build do aplicativo Blink, normalmente terminando em "out\ARM-Debug" ou "out/ARM-Debug".
Depois de um pequeno atraso, você deve ver um piscar de LED.
Defina um ponto de interrupção em algum lugar no main.c e passe pelo aplicativo para que você possa explorar os recursos de depuração Visual Studio Code para o Azure Sphere.

Criar e executar o aplicativo de alto nível com o Visual Studio

Este tutorial usa o modelo blink do Azure Sphere, que faz parte da extensão do Azure Sphere para Visual Studio. O modelo Blink pisca um LED para que você possa verificar se o dispositivo e as ferramentas do Azure Sphere estão instalados e configurados corretamente.

Se você for novo no Visual Studio, considere o Início Rápido ou o Tour Guiado para saber mais sobre como navegar e usá-lo.
Abra o Visual Studio e selecione Criar um novo projeto. Na caixa Pesquisa, digite "azure sphere" para obter uma lista de modelos do Azure Sphere. Escolha Azure Sphere Blink na lista.
Insira um nome e local para o projeto e selecione Criar.
Abra o arquivo CMakeLists.txt e altere a configuração TARGET_DIRECTORY para especificar a pasta que contém definições para o hardware que você está usando. Por padrão, o TARGET_DIRECTORY especifica HardwareDefinitions/mt3620_rbd, que corresponde ao Kit de Desenvolvimento MT3620 do Seeed Azure Sphere:
```
azsphere_target_hardware_definition(${PROJECT_NAME} TARGET_DIRECTORY "HardwareDefinitions/mt3620_rdb" TARGET_DEFINITION "template_appliance.json")
```
Várias definições de hardware são fornecidas com o modelo. Por exemplo, se você estiver usando um SEEED MT3620 Mini Dev Board, especifique HardwareDefinitions/seeed_mt3620_mdb em vez disso.
No Visual Studio, selecione Exibir>Saída para exibir o painel Saída .
Verifique se o dispositivo está conectado ao computador por USB. No menu Definir item de inicialização, pressione F5 ou selecione Aplicativo do Azure Sphere (HLCore)* em que o Aplicativo Azure Sphere é o nome do aplicativo de alto nível atual.
Se você for solicitado a criar o projeto, selecione Sim. O Visual Studio compila o aplicativo, cria um pacote de imagem, o carrega de lado no quadro e inicia-o no modo de depuração. Sideloading significa que o aplicativo é entregue diretamente do computador por meio de uma conexão com fio, em vez de entregue pela nuvem.

Ponta

Anote a localização do pacote de imagens, pois você precisará dele ao criar uma implantação. Você deve ver uma mensagem como "Arquivo de saída está em: <caminho>" na saída em Exibir>Saída>Mostrar saída de: Build, onde <o caminho> é o caminho completo para a pasta de build do aplicativo Blink, normalmente terminando em "out/ARM-Debug".
Por padrão, o painel Saída mostra a saída da Saída do Dispositivo. Para ver as mensagens do depurador, selecione Depurar no menu mostrar saída de: menu suspenso. Você também pode inspecionar a desmontagem do programa, registros ou memória por meio do menu Depurar>Windows .
Ao executar o programa, você deverá ver um piscar de LED.

Baixar o aplicativo de exemplo

Você pode baixar o aplicativo HelloWorld da seguinte maneira:

Aponte seu navegador para o Microsoft Samples Browser.
Digite "Azure Sphere" na caixa Pesquisa.
Selecione Azure Sphere – Olá, Mundo nos resultados da pesquisa.
Selecione Baixar ZIP.
Abra o arquivo baixado e extraia para um diretório local.

Compilar o exemplo

Para criar os arquivos build e .imagepackage para o aplicativo de exemplo HelloWorld_HighLevelApp, siga estas etapas.

Atualize o exemplo para direcionar seu hardware, se necessário. Por padrão, os exemplos visam hardware que segue o RDB (design do quadro de referência) MT3620, como o Kit de Desenvolvimento MT3620 do Seeed Studios. Definições adicionais de hardware de destino para os aplicativos de exemplo estão disponíveis no diretório HardwareDefinitions do repositório Exemplos do Azure Sphere. Por exemplo, os arquivos de definição de hardware do Kit inicial do Avnet MT3620 estão no subdiretório HardwareDefinitions/avnet_mt3620_sk.
- Abra CMakeLists.txt e atualize o parâmetro TARGET_DIRECTORY na função azure_target_hardware_definition para apontar para o subdiretório do hardware. Por exemplo:
```
azsphere_target_hardware_definition(${PROJECT_NAME} TARGET_DIRECTORY "../../../HardwareDefinitions/avnet_mt3620_sk" TARGET_DEFINITION "sample_appliance.json")
```
Abra uma interface de linha de comando usando o PowerShell, o Prompt de Comando do Windows ou o shell de comando do Linux. Navegue até o diretório de build do projeto.
No diretório de build 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 predefinido de configuração de build, 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 de build será cmake --build out/ARM-Debug.
- <source-path>
  
  O caminho do diretório que contém os arquivos de origem do aplicativo de exemplo. No exemplo, o repositório de exemplos do Azure Sphere foi baixado em 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 linux ou ' para PowerShell) pode ser usado para legibilidade, mas não é necessário.
Os exemplos a seguir mostram os comandos CMake para o Olá, Mundo aplicativo de alto nível:
- Windows
- Linux
Prompt de Comando do 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"
```
```
cmake \
 --preset "ARM-Debug" \
 ./AzSphere/azure-sphere-samples/Samples/HelloWorld/HelloWorld_HighLevelApp
```
Execute o Ninja para criar o aplicativo e criar o arquivo de pacote de imagem:
```
ninja -C out/ARM-Debug
```
O Ninja coloca os arquivos de aplicativo e .imagepackage resultantes no diretório especificado.

Você também pode invocar o Ninja por meio do CMake com o seguinte comando:
```
cmake --build out/<binary-dir>
```
Defina <binary-dir> como 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 de build será cmake --build out/ARM-Debug.

Ao solucionar problemas, especialmente depois de fazer alterações nos comandos do CMake, exclua todo o build e tente novamente.

Executar o exemplo

Se o dispositivo já estiver executando um aplicativo, exclua o aplicativo:
```
az sphere device sideload delete
```
Altere para o diretório que contém os arquivos build e .imagepackage criados anteriormente.
Carregue o pacote de imagem em seu dispositivo executando o comando de implantação de sideload do dispositivo az sphere e especificando o pacote de imagem. Por exemplo:
```
az sphere device sideload deploy --image-package HelloWorld_HighLevelApp.imagepackage
```
Esse comando carrega o pacote de imagem e inicia o aplicativo. Você deve ver um piscar de LED.

Ponta

Observe o caminho do pacote de imagem. Você usará o pacote de imagem mais tarde no Início Rápido da Implantação.

Depurar o exemplo

Altere para o diretório que contém os arquivos build e .imagepackage criados anteriormente.

Obtenha a ID do componente se você ainda não tiver:

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

Se o aplicativo estiver em execução, interrompa-o e reinicie-o com a opção --debug-mode :

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

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

Você deve ver:

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

Use um cliente terminal para estabelecer uma conexão TCP telnet ou bruta para ler o fluxo de saída do processo. Especifique 192.168.35.2 como o endereço IP e 2342 como a porta.

Abra uma interface de linha de comando usando o PowerShell ou um prompt de comando padrão no Windows ou shell de comando no Linux e passe o binário do aplicativo .out do seu build como um parâmetro. Isso habilitará a depuração completa do código-fonte.

Windows
Linux

Prompt de Comando do 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

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

Nota

O SDK do Azure Sphere é fornecido com vários sysroots para que os aplicativos possam direcionar diferentes conjuntos de API, conforme descrito em Versão de runtime 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 como endereço IP 192.168.35.2 na porta 2345:

target remote 192.168.35.2:2345
Execute quaisquer outros comandos gdb que você escolher. Por exemplo, os comandos a seguir definem um ponto de interrupção na entrada como main() e, em seguida, continuam a execução após o ponto de interrupção, respectivamente.
```
break main
```
```
c
```
Para obter mais informações sobre a depuração com gdb, consulte GDB: o Depurador do Projeto GNU ou uma das outras inúmeras fontes sobre o assunto.

Próximas etapas

Você criou um aplicativo de alto nível para ser executado em seu dispositivo do Azure Sphere. Talvez você queira modificá-lo agora. As definições de hardware descrevem como editar um arquivo JSON de definição de hardware e gerar novamente o arquivo de cabeçalho associado.

Em seguida, saiba como implantar seu aplicativo de alto nível na nuvem.

Tutorial: Criar uma implantação na nuvem

Consulte também

Visite a Galeria do Azure Sphere, uma coleção de scripts, utilitários e funções inspiradores, não retidos e reutilizáveis do Azure Sphere.