Criar uma aplicação com capacidade em tempo real

Artigo
08/09/2023

Pode utilizar o Visual Studio, o Visual Studio Code ou a linha de comandos (CLI) para desenvolver e depurar aplicações com capacidade em tempo real (RTApps) da mesma forma que as aplicações de alto nível.

Pré-requisitos

Ligar o dispositivo do Azure Sphere ao seu computador
Instalar o Azure Sphere
Instalar a cadeia de ferramentas GNU Arm Embedded
Configure o hardware para apresentar a saída do UART dedicado, caso ainda não o tenha feito

Ativar o desenvolvimento e a 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 a depuração. 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 PC e não permitem a depuração de aplicações. Preparar o dispositivo para depuração remove esta restrição e carrega o software necessário para depurar e desbloqueia as capacidades do dispositivo.

Para depurar os núcleos em tempo real, utilize o comando az sphere device enable-development . Este comando configura o dispositivo para aceitar aplicações de um PC para depuração e atribui o dispositivo ao grupo de dispositivos de Desenvolvimento, 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.

No Windows, tem de adicionar o --enable-rt-core-debugging parâmetro , que carrega os servidores de depuração e os controladores 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:
```
az login
```
Abra uma interface de linha de comandos com o PowerShell ou a Linha de Comandos do Windows com privilégios de administrador. O --enable-rt-core-debugging parâmetro requer privilégios de administrador porque instala controladores USB para o depurador.

Introduza o seguinte comando:

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

Feche a janela após a conclusão do comando porque o privilégio de administrador já não é necessário. Como melhor prática, deve sempre utilizar o privilégio mais baixo que pode realizar uma tarefa.

Inicie sessão no Azure Sphere se ainda não o tiver feito:
```
az login
```

Introduza o seguinte comando:

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

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

Ativar o desenvolvimento e a depuração

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

Inicie sessão no Azure se ainda não o tiver feito:
```
az login
```
Abra uma interface de linha de comandos com o PowerShell, a Linha de Comandos do Windows ou a shell de comandos do Linux com privilégios de administrador. O --enable-rt-core-debugging parâmetro requer privilégios de administrador porque instala controladores USB para o depurador.

Introduza o seguinte comando:

az sphere device enable-development --enable-rt-core-debugging

Feche a janela após a conclusão do comando porque o privilégio de administrador já não é necessário. Como melhor prática, deve sempre utilizar o privilégio mais baixo que pode realizar uma tarefa.

Se o comando az sphere device enable-development falhar com a seguinte mensagem de erro, veja Resolver problemas do Azure Sphere para obter ajuda.

error: The device did not accept the device capability configuration. Please check the Azure Sphere OS on your device is up-to-date using 'az sphere device show-deployment-status'.

Criar o RTApp com o Visual Studio Code

Para criar uma RTApp:

No Visual Studio Code, abra a pasta HelloWorld_RTApp_MT3620_BareMetal no clone do repositório de exemplos do Azure Sphere. Se lhe for pedido para selecionar um kit, selecione "Não utilize um kit".
Prima F5 para iniciar o depurador. 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.
O emulador de terminal ligado deve apresentar a saída da aplicação. O programa envia as seguintes palavras em intervalos de um segundo:

Tick

Tock

Nota

O Visual Studio Code fornece o Intellisense, mas não será atualizado automaticamente quando modificar CMakeLists.txt. Tem de executar o comando CMake: Delete Cache e Reconfigure para atualizar o Intellisense. A vista de destinos CMake pode ser encontrada na vista de extensão CMake na barra esquerda.

Criar o RTApp com o Visual Studio

Para criar uma RTApp:

No Visual Studio, selecione Ficheiro>CMake e navegue para a pasta que contém o exemplo.
Se a geração CMake não iniciar automaticamente, selecione o ficheiro CMakeLists.txt.
No Visual Studio, veja a saída Mostrar>Saída>de: A saída CMake deve mostrar as mensagens CMake generation started. e CMake generation finished.
No menu CMake (se estiver presente), selecione Compilar Tudo. Se o menu não estiver presente, abra Explorador de Soluções, clique com o botão direito do rato no ficheiro CMakeLists.txt e selecione Compilar. A localização de saída da aplicação do Azure Sphere é apresentada na janela Saída .
Prima F5 para implementar a aplicação.
O emulador de terminal ligado deve apresentar a saída da aplicação. O programa envia as seguintes palavras em intervalos de um segundo:

Tick

Tock
Nota
- O Visual Studio fornece o Intellisense para o Azure Sphere RTApps ao recolher dados da respetiva cache CMake. O Visual Studio atualiza a cache sempre que o ficheiro CMakeLists.txt ou CMakeSettings.json no RTApp for alterado.
- Por predefinição, o Visual Studio utiliza a vista Pastas. Se preferir uma vista lógica do projeto CMake, pode alterar para a vista Destinos CMake. Em Explorador de Soluções, selecione o ícone de alternar de pasta:
  
  No menu pendente, selecione CMake Targets View (Vista de Destinos CMake).
- A aplicação pode começar a ser executada antes de o OpenOCD efetuar uma ligação. Como resultado, os pontos de interrupção definidos no início do código podem não ser apresentados. Uma solução simples para isto é atrasar o início da aplicação até que o OpenOCD se ligue.
  1. Insira o seguinte código no início do ponto de entrada da aplicação RTCoreMain. Isto fará com que a aplicação introduza e permaneça num while ciclo até que a variável f esteja definida como true.
```
  volatile bool f = false;
  while (!f) {
    // empty.
  }
```
  2. Prima F5 para iniciar a aplicação com a depuração e, em seguida, invada a execução.
  3. No painel Depuração Locais , altere o valor de f zero para um.
  4. Siga o código normalmente.

Criar o RTApp com a CLI

As instruções que se seguem partem do princípio de que está a utilizar o CMake. Se preferir criar na linha de comandos sem utilizar o CMake, pode determinar as opções adequadas de compilador e linker ao observar os ficheiros AzureSphereToolchainBase.cmake e AzureSphereRTCoreToolchain.cmake, que estão instalados com o SDK do Azure Sphere.

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 para o HelloWorld RTApp:
- Windows
- Linux
Linha de Comandos do Windows
```
cmake ^
--preset "ARM-Debug" ^
"C:\AzSphere\azure-sphere-samples\Samples\HelloWorld\HelloWorld_RTApp_MT3620_BareMetal"
```
Windows PowerShell
```
cmake `
--preset "ARM-Debug" `
"C:\AzSphere\azure-sphere-samples\Samples\HelloWorld\HelloWorld_RTApp_MT3620_BareMetal"
```
```
cmake \
--preset "ARM-Debug" \
./AzSphere/azure-sphere-samples/Samples/HelloWorld/HelloWorld_RTApp_MT3620_BareMetal
```
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.
Elimine todas as aplicações que já estejam implementadas no dispositivo:
```
az sphere device sideload delete
```

Implemente o pacote de imagem que o Ninja criou:

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

Obtenha o ID do componente da imagem:
```
az sphere image-package show --image-package <path-to-imagepackage>
```
O comando devolve todos os metadados do pacote de imagem. O ID do componente da aplicação é apresentado na secção Identidade do Tipo de Imagem da Aplicação. Por exemplo:
```
...
  "Identity": {
    "ComponentId": "<component-id>",
    "ImageId": "<image-id>",
    "ImageType": "Application"
  },
...
```
Determine em que núcleo a sua aplicação está a ser executada.

Por predefinição, o RTApp é implementado no primeiro núcleo em tempo real disponível no dispositivo; Atualmente, não pode especificar um núcleo específico. Para saber em que núcleo a aplicação está a ser executada, utilize o comando az sphere device app para parar e, em seguida, reiniciar a aplicação. Forneça o ID do componente da aplicação nos comandos. Por exemplo:
```
az sphere device app stop --component-id <component id>
<component id>: App state: stopped
```
```
az sphere device app start --component-id <component id>
<component id>
App state: running
Core     : Real-time 0
```
O emulador de terminal ligado deve apresentar a saída da aplicação. O programa envia as seguintes palavras em intervalos de um segundo:

Tick

Tock

Registar a saída de uma RTApp

Cada núcleo em tempo real no MT3620 tem um UART dedicado que se destina à saída de registo. Os núcleos em tempo real também podem aceder aos UARTs da ISU. O RDB MT3620 expõe apenas o pin TX, que pode utilizar para apresentar a saída de registo da aplicação. Outro hardware pode expor isto de forma diferente ou não. Para ver a saída do registo, configure o hardware para apresentar esta saída, conforme descrito no início rápido. O UART dedicado não requer o requisito de manifesto da aplicação Uart . No entanto, não deve ser utilizado para fins que não o resultado de registo de uma RTApp.

Desenvolver com aplicações de parceiros

Quando carrega uma aplicação para o dispositivo do Azure Sphere, as ferramentas de implementação do Azure Sphere eliminam todas as aplicações existentes por predefinição. Para impedir que isto aconteça quando desenvolve aplicações que comunicam entre si, tem de marcar as aplicações como parceiros. Quando implementa uma das aplicações, os respetivos parceiros não serão eliminados. Veja Marcar aplicações como parceiros para obter detalhes.

Resolução de problemas

Se tiver problemas, veja Resolução de problemas de aplicações com capacidade em tempo real.

Recursos adicionais

Estão disponíveis controladores e exemplos adicionais para RTApps que visam os núcleos M4 em tempo real no chip MT3620 no GitHub a partir de parceiros do Azure Sphere: