Tutorial: Criar uma aplicação de alto nível

Artigo
08/09/2023

Uma aplicação de alto nível é executada no SO do Azure Sphere, utiliza as bibliotecas de aplicações do Azure Sphere e pode comunicar com a Internet e com serviços baseados na cloud. Veja Descrição geral das aplicações do Azure Sphere para obter informações básicas sobre aplicações de alto nível.

Neste tutorial, irá aprender a:

Preparar o dispositivo para desenvolvimento e depuração

Criar, executar e depurar uma aplicação de alto nível

Pré-requisitos

Instale o CMake e o Ninja para Windows ou para Linux.

Instale o Visual Studio Code para Windows ou para Linux.
Instale o CMake e o 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 o seu dispositivo.
Configure a rede e atualize o SO do dispositivo.

Preparar o dispositivo para desenvolvimento e depuração

Antes de poder criar uma aplicação de exemplo no seu dispositivo do Azure Sphere ou desenvolver novas aplicações para o mesmo, tem de ativar o desenvolvimento e o sideload. Por predefinição, os dispositivos do Azure Sphere estão "bloqueados"; ou seja, não permitem que as aplicações em desenvolvimento sejam carregadas a partir de um computador e não permitem a depuração de aplicações. Preparar o dispositivo para sideload remove esta restrição.

O comando az sphere device enable-development configura o dispositivo para aceitar aplicações para depuração, carrega o servidor de depuração para o dispositivo e atribui o dispositivo a um grupo de dispositivos que não permite atualizações de aplicações na cloud. Durante o desenvolvimento e depuração de aplicações, deve deixar o dispositivo neste grupo para que as atualizações da aplicação na cloud não substituam a aplicação em desenvolvimento.

Certifique-se de que o dispositivo do Azure Sphere está ligado ao computador e de que o computador está ligado à Internet.
Abra uma interface de linha de comandos com o PowerShell, a Linha de Comandos do Windows ou a shell de comandos do Linux.

Introduza o seguinte comando:

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

Deverá ver um resultado semelhante ao 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, veja Resolver problemas do Azure Sphere para obter ajuda.

Criar e executar a aplicação de alto nível com o Visual Studio Code

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

Inicie o Visual Studio Code. Selecione Ver>Paleta de comandos e, em seguida, escreva "Azure Sphere: Gerar Novo Projeto".
Selecione Piscar no menu Modelos.

Em seguida, o Visual Studio Code apresenta uma janela Explorador de Ficheiros. Navegue para a pasta onde pretende colocar a aplicação Blink. O Visual Studio Code cria a pasta Blink na sua localização selecionada e gera os ficheiros de compilação para a aplicação Blink. Deverá ver mensagens do CMake.
Abra o ficheiro CMakeLists.txt e altere a definição TARGET_DIRECTORY para especificar a pasta que contém definições para o hardware que está a utilizar. Por predefinição, o TARGET_DIRECTORY especifica HardwareDefinitions/mt3620_rbd, que corresponde ao Kit de Desenvolvimento Seeed Azure Sphere MT3620:
```
azsphere_target_hardware_definition(${PROJECT_NAME} TARGET_DIRECTORY "HardwareDefinitions/mt3620_rdb" TARGET_DEFINITION "template_appliance.json")
```
São fornecidas várias definições de hardware com o modelo. Por exemplo, se estiver a utilizar um MiniDev Board SEEED MT3620, especifique HardwareDefinitions/seeed_mt3620_mdb em alternativa.
Prima F5 para compilar e depurar o projeto. Se o projeto não tiver sido criado anteriormente ou se os ficheiros tiverem sido alterados e a reconstrução for necessária, o Visual Studio Code compilará o projeto antes do início da depuração.
Aguarde vários segundos para que o Visual Studio Code crie a aplicação, crie um pacote de imagem, implemente-o no quadro e inicie-o no modo de depuração. Verá atualizações de estado no painel Saída ao longo do caminho.

Primeiro, o CMake determina se a aplicação precisa de ser criada. Em caso afirmativo, o foco muda para o painel de saída, que apresenta a saída de CMake/Build.

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

Sugestão

Tome nota da localização do pacote de imagens, pois irá precisar dele quando criar uma implementação. Deverá ver uma mensagem como "Criar ficheiros escritos no <caminho>" na janela Saída , em <que caminho> é o caminho completo para a pasta de compilação da aplicação Blink, que normalmente termina em "out\ARM-Debug" ou "out/ARM-Debug".
Após um curto período de tempo, deverá ver um LED a piscar.
Defina um ponto de interrupção algures em main.c e percorra a aplicação para que possa explorar as funcionalidades de depuração do Visual Studio Code para o Azure Sphere.

Criar e executar a aplicação de alto nível com o Visual Studio

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

Se não estiver familiarizado com o Visual Studio, considere o Início Rápido ou a Visita Guiada para saber mais sobre como navegar e utilizá-lo.
Abra o Visual Studio e selecione Criar um novo projeto. Na caixa Pesquisa, escreva "azure sphere" para obter uma lista de modelos do Azure Sphere. Selecione Azure Sphere Blink na lista.
Introduza um nome e uma localização para o projeto e, em seguida, selecione Criar.
Abra o ficheiro CMakeLists.txt e altere a definição TARGET_DIRECTORY para especificar a pasta que contém definições para o hardware que está a utilizar. Por predefinição, o TARGET_DIRECTORY especifica HardwareDefinitions/mt3620_rbd, que corresponde ao Kit de Desenvolvimento Seeed Azure Sphere MT3620:
```
azsphere_target_hardware_definition(${PROJECT_NAME} TARGET_DIRECTORY "HardwareDefinitions/mt3620_rdb" TARGET_DEFINITION "template_appliance.json")
```
São fornecidas várias definições de hardware com o modelo. Por exemplo, se estiver a utilizar um MiniDev Board SEEED MT3620, especifique HardwareDefinitions/seeed_mt3620_mdb em alternativa.
No Visual Studio, selecione Ver>Saída para apresentar o painel Saída .
Certifique-se de que o dispositivo está ligado ao PC por USB. No menu Definir item de arranque , prima F5 ou selecione Aplicação do Azure Sphere (HLCore)* em que a Aplicação do Azure Sphere é o nome da sua aplicação de alto nível atual.
Se lhe for pedido para criar o projeto, selecione Sim. O Visual Studio compila a aplicação, cria um pacote de imagem, faz o sideload para o quadro e inicia-o no modo de depuração. O sideload significa que a aplicação é fornecida diretamente a partir do PC através de uma ligação com fios, em vez de ser fornecida através da cloud.

Sugestão

Tome nota da localização do pacote de imagens, pois irá precisar dele ao criar uma implementação. Deverá ver uma mensagem como "O ficheiro de saída está em: <caminho>" na saída em Ver>>Saída Mostrar saída de: Compilação, em <que caminho> é o caminho completo para a pasta de compilação da aplicação Blink, que normalmente termina em "out/ARM-Debug".
Por predefinição, o painel Saída mostra a saída da Saída do Dispositivo. Para ver mensagens do depurador, selecione Depurar no menu pendente Mostrar saída de: . Também pode inspecionar a desmontagem, registos ou memória do programa através do menu Depurar>o Windows .
Quando executar o programa, deverá ver um LED a piscar.

Transferir a aplicação de exemplo

Pode transferir a aplicação HelloWorld da seguinte forma:

Aponte o browser para o Browser de Exemplos da Microsoft.
Escreva "Azure Sphere" na caixa Pesquisa.
Selecione Azure Sphere - Hello World nos resultados da pesquisa.
Selecione Transferir ZIP.
Abra o ficheiro transferido e extraia para um diretório local.

Criar o exemplo

Para criar os ficheiros build e .imagepackage para o HelloWorld_HighLevelApp aplicação de exemplo, siga estes passos.

Atualize o exemplo para direcionar o hardware, se necessário. Por predefinição, os exemplos de hardware de destino que seguem o design do quadro de referência (RDB) MT3620, como o Development Kit MT3620 da Seeed Studios. Estão disponíveis definições de hardware de destino adicionais para as aplicações de exemplo no diretório HardwareDefinitions do repositório de Exemplos do Azure Sphere. Por exemplo, os ficheiros de definição de hardware do Avnet MT3620 Starter Kit 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 comandos com o PowerShell, a Linha de Comandos do Windows ou a shell de comandos do Linux. Navegue para o diretório de compilação do projeto.
No diretório de compilação do projeto, na linha de comandos, execute CMake com os seguintes parâmetros:
```
cmake --preset <preset-name> <source-path>
```
- --preset <preset-name>
  
  O nome predefinido da configuração da compilação, conforme definido no CMakePresets.json.
- --build <cmake-path>
  
  O diretório binário que contém a cache CMake. Por exemplo, se executar o CMake num exemplo do Azure Sphere, o comando build será cmake --build out/ARM-Debug.
- <source-path>
  
  O caminho do diretório que contém os ficheiros de origem da aplicação de exemplo. No exemplo, o repositório de exemplos do Azure Sphere foi transferido para um diretório chamado AzSphere.
  
  Os parâmetros CMake são separados por espaços. O caráter de continuação da linha (^ para a linha de comandos do Windows, \ para a linha de comandos do Linux ou ' para o PowerShell) pode ser utilizado para legibilidade, mas não é necessário.
Os exemplos seguintes mostram os comandos CMake da Hello World aplicação de alto nível:
- Windows
- Linux
Linha de Comandos 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 Ninja para criar a aplicação e criar o ficheiro de pacote de imagem:
```
ninja -C out/ARM-Debug
```
Ninja coloca a aplicação resultante e os ficheiros .imagepackage no diretório especificado.

Também pode invocar Ninja através de CMake com o seguinte comando:
```
cmake --build out/<binary-dir>
```
Defina <binary-dir> como o diretório binário que contém a cache CMake. Por exemplo, se executar o CMake num exemplo do Azure Sphere, o comando build será cmake --build out/ARM-Debug.

Ao resolver problemas, especialmente depois de efetuar alterações aos comandos CMake, elimine toda a sua criação e tente novamente.

Executar o exemplo

Se o dispositivo já estiver a executar uma aplicação, elimine a aplicação:
```
az sphere device sideload delete
```
Altere para o diretório que contém os ficheiros build e .imagepackage criados anteriormente.
Carregue o pacote de imagem para o seu dispositivo ao executar o comando az sphere device sideload deploy e especificar o pacote de imagem. Por exemplo:
```
az sphere device sideload deploy --image-package HelloWorld_HighLevelApp.imagepackage
```
Este comando carrega o pacote de imagem e inicia a aplicação. Deverá ver um LED a piscar.

Sugestão

Tenha em atenção o caminho do pacote de imagem. Irá utilizar o pacote de imagem mais tarde no Início Rápido de Implementação.

Depurar o exemplo

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

Obtenha o ID do componente se ainda não o tiver:

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

Se a aplicação estiver em execução, pare-a e, em seguida, reinicie-a com a opção --debug-mode :

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

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

Deverá ver:

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

Utilize um cliente de terminal para estabelecer uma ligação Telnet ou TCP não processada 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 comandos com o PowerShell ou uma linha de comandos padrão no Windows ou a shell de comandos no Linux e transmita o binário da aplicação .out a partir da sua compilação como um parâmetro. Isto irá ativar a depuração completa do código fonte.

Windows
Linux

Linha de Comandos 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 as aplicações possam visar diferentes conjuntos de API, conforme descrito em Versão do runtime da aplicação, 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
Execute quaisquer outros comandos gdb que escolher. Por exemplo, os seguintes comandos definem um ponto de interrupção após a entrada para main() e, em seguida, continuam a execução após o ponto de interrupção, respetivamente.
```
break main
```
```
c
```
Para obter mais informações sobre a depuração com gdb, veja GDB: O Depurador do Projeto GNU ou uma das outras origens sobre o assunto.

Passos seguintes

Criou uma aplicação de alto nível para ser executada no seu dispositivo do Azure Sphere. Poderá querer modificá-lo agora. As definições de hardware descrevem como editar um ficheiro JSON de definição de hardware e voltar a gerar o ficheiro de cabeçalho associado.

Em seguida, saiba como implementar a sua aplicação de alto nível a partir da cloud.

Tutorial: Criar uma implementação na cloud

Consulte também

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