Tutorial: Crear y depurar aplicaciones de partners

Artículo
08/09/2023

Este tutorial muestra cómo crear y depurar un proyecto de ejemplo que incluye una aplicación de alto nivel y una aplicación compatible con el tiempo real, donde las dos aplicaciones se comunican entre el núcleo A7 de alto nivel y el núcleo M4 en tiempo real. Consulte Información general sobre las aplicaciones de Azure Sphere para obtener información básica sobre aplicaciones de alto nivel y aplicaciones compatibles con el tiempo real.

En este tutorial, aprenderá a:

Instalar la cadena de herramientas GNU Arm
Configurar hardware para mostrar la salida
Habilitar desarrollo y depuración
Clonar el repositorio de ejemplo de Azure Sphere
Iniciar un emulador de terminal para ver la salida
Crear, ejecutar y depurar un par de aplicaciones de asociados

Importante

Estas instrucciones asumen que usa hardware que sigue el hardware de diseño de la placa de referencia (RDB) MT3620, como el kit de desarrollo MT3620 de Seeed Studios. Si usas otro hardware de Azure Sphere, consulta la documentación del fabricante para averiguar si el UART está expuesto y cómo acceder a él. Es posible que tenga que configurar hardware para mostrar los resultados de forma diferente y actualizar el código de muestra y el campo Uarts del archivo app_manifest.json para usar un UART diferente.

Requisitos previos

Instala CMake y Ninja para Windows o para Linux.

Instala Visual Studio Code para Windows o para Linux.
Instala CMake y Ninja para Windows o para Linux.

Instala Visual Studio y la extensión Azure Sphere.

Instale Azure Sphere SDK para Windows o para Linux.
Elige un catálogo y reclama tu dispositivo.
Configura la red y actualiza el sistema operativo del dispositivo.

Instalar el sistema GNU Arm Embedded Toolchain

Visual Studio 2022: Si estás usando Visual Studio 2022, instala GNU Arm Embedded Toolchain (arm-none-eabi) desde el sitio web de desarrolladores de Arm.
Visual Studio 2019: La cadena de herramientas se instala automáticamente con la extensión Azure Sphere para Visual Studio en Visual Studio 2019. Si usa Visual Studio 2019, vaya a Configurar hardware para mostrar la salida. Sin embargo, si has instalado el GNU Arm Embedded Toolchain manualmente, Visual Studio utilizará la versión que hayas instalado.

Para instalar el toolchain en el sitio web del desarrollador arm, busca el GNU Arm Embedded Toolchain (arm-none-eabi) que incluye el compilador para el procesador ARM Cortex-M4. Siga las instrucciones para descargar e instalar el compilador para su plataforma del sistema operativo.

De forma predeterminada, Visual Studio Code busca la cadena de herramientas y debería encontrar la versión que instaló. Si encuentras problemas de compilación relacionados con la cadena de herramientas, compruebaExtensionesdeconfiguración> de Preferencias>>AzureSphere para asegurarte de que "Azure Sphere: Arm Gnu Path" identifique el directorio de instalación GNU Arm Embedded Toolchain.

Configurar hardware para mostrar la salida

Actualmente, cada núcleo en tiempo real admite un UART solo TX. RTApps puede usar este UART para enviar salida de registro desde el dispositivo. Durante el desarrollo y depuración de aplicaciones, normalmente se necesita una forma de leer y mostrar el resultado. El HelloWorld_RTApp_MT3620_BareMetal muestra cómo una aplicación puede escribir en el UART.

Utilice un adaptador USB a serie, como el amigo FTDI, para conectar el UART en el núcleo en tiempo real a un puerto USB de su equipo. También necesitarás un emulador de terminal para establecer una conexión serial con la configuración de terminales 115200-8-N-1 (115200 bps, 8 bits, sin bits de paridad, un bit de parada) para mostrar la salida.

Para configurar el hardware para mostrar la salida de una RTApp, sigue estos pasos. Tendrás que consultar la documentación del fabricante del hardware para determinar las ubicaciones de los anclajes. Si usas hardware que sigue el hardware de diseño de la placa de referencia (RDB) MT3620, como el kit de desarrollo MT3620 de Seeed Studios, puede que mirar los encabezados de interfaz RDB te ayude a determinar las ubicaciones de los pines.

Conecta GND en el adaptador usb a serie a GND en el kit de desarrollo. En el hardware MT3620 RDB, GND es encabezado 3, pin 2.
Conecte RX en el adaptador usb a serie a IOM4-0 TX en su kit de desarrollo. En el hardware MT3620 RDB, IOM4-0 TX es encabezado 3, pin 6.
Conecta el adaptador USB a serie a un puerto USB gratuito de la máquina de desarrollo y determina a qué puerto está conectado el dispositivo serie.
- En Windows, inicie Administrador de dispositivos, seleccione Ver>dispositivos por contenedor y busque "USB UART". Por ejemplo, FT232R USB UART indica el adaptador de amigo FTDI.
- En Linux, escriba el siguiente comando:
```
dmesg | grep ttyUSB
```
  El puerto debe llamarse ttyUSBn, donde n indica el número de puerto. Si el dmesg comando enumera varios puertos USB, el que está conectado a la típicamente el último notificado como conectado. Por ejemplo, en lo siguiente, usaría 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 un programa emulador de terminales y abra un terminal 115200-8-N-1 al puerto COM utilizado por el adaptador. Consulte la documentación del emulador de terminal para averiguar cómo especificar el puerto y la velocidad.

Habilitar desarrollo y depuración

Antes de poder crear una aplicación de muestra en su dispositivo Azure Sphere o desarrollar nuevas aplicaciones para él, debe habilitar el desarrollo y la depuración. De forma predeterminada, los dispositivos Azure Sphere están "bloqueados"; es decir, no permiten que las aplicaciones en desarrollo se carguen desde un equipo y no permiten la depuración de aplicaciones. Al preparar el dispositivo para la depuración se elimina esta restricción y se carga el software necesario para depurar y desbloquear las capacidades del dispositivo.

Para depurar en los núcleos en tiempo real, utilice el comando az sphere device enable-development . Este comando configura el dispositivo para que acepte aplicaciones de un equipo para la depuración y asigna el dispositivo al grupo Dispositivo de desarrollo, que no permite las actualizaciones de aplicaciones en la nube. Durante el desarrollo y depuración de aplicaciones, debes dejar el dispositivo en este grupo para que las actualizaciones de aplicaciones en la nube no sobrescriban la aplicación en desarrollo.

En Windows, debe agregar el --enable-rt-core-debugging parámetro, que carga los servidores de depuración y los controladores necesarios para cada tipo de núcleo en el dispositivo.

Windows
Linux

Inicie sesión en Azure Sphere si aún no lo ha hecho:
```
az login
```
Abre una interfaz de línea de comandos con PowerShell o símbolo del sistema de Windows con privilegios de administrador. El --enable-rt-core-debugging parámetro requiere privilegios de administrador porque instala controladores USB para el depurador.

Escriba el siguiente comando:

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

Cierre la ventana cuando finalice el comando porque ya no se requiere privilegio de administrador. Como procedimiento recomendado, siempre debe usar el privilegio más bajo que puede llevar a cabo una tarea.

Inicie sesión en Azure Sphere si aún no lo ha hecho:
```
az login
```

Escriba el siguiente comando:

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

Si se produce un error en el comando az sphere device enable-development , consulte Solucionar problemas de Azure Sphere para obtener ayuda.

Descargar la aplicación de ejemplo

Puede descargar las aplicaciones de InterCore Communications de la siguiente manera:

Apunta el explorador al explorador de muestras de Microsoft.
Escriba "Azure Sphere" en el cuadro de Búsqueda.
Seleccione Azure Sphere - Inter-core Communications en los resultados de búsqueda.
Selecciona Descargar ZIP.
Abra el archivo descargado y extraiga el archivo a un directorio local.

Crear y ejecutar las aplicaciones asociadas

Iniciar Visual Studio. Seleccione Abrir una carpeta local y vaya a la carpeta donde extrajo las aplicaciones de IntercoreComms.

Importante

Si usa Visual Studio 2022 versión 17.1 o posterior y extrajo la muestra de IntercoreComms antes de la versión 22.02 Azure Sphere, debe agregar un archivo de CMakeWorkspaceSettings.json a la carpeta del proyecto de nivel superior.
Si no usa un archivo MT3620 RDB, actualice los archivos de app_manifest.json tanto para las aplicaciones como para el archivo de definición de hardware y CMakeLists.txt archivo para que la aplicación de alto nivel coincida con su hardware.
Si la generación de CMake no se inicia automáticamente, seleccione el archivo de CMakeLists.txt.
En Visual Studio, Ver>salida>Mostrar salida de: CMake salida debe mostrar los mensajes CMake generation started y CMake generation finished.
Seleccione Compilar>todo. Si el menú no está presente, abre Explorador de soluciones, haz clic con el botón derecho en el archivo CMakeLists.txt y selecciona Compilar. La ubicación de salida de las aplicaciones IntercoreComms_HL & IntercoreComms RT aparece en la ventana Salida .
Selecciona Seleccionar elemento de> inicioIntercoreComms (Todos los núcleos).
Seleccione Depurar> o presione F5 para implementar y depurar las aplicaciones.

En la ventana Salida , seleccione salida del menú, seleccione Salida de dispositivo. La ventana Salida debe mostrar la salida de aplicación de alto nivel:

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

El emulador de terminal conectado debe mostrar la salida desde el programa compatible en tiempo 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 el depurador para establecer puntos de interrupción, inspeccionar variables e intentar otras tareas de depuración.

En Visual Studio Code, abra la carpeta donde extrajo las aplicaciones IntercoreComms. Visual Studio Code detecta el archivo intercore.code-workspace y pregunta si quieres abrir el área de trabajo. Selecciona Abrir área de trabajo para abrir la aplicación en tiempo real y la aplicación de alto nivel a la vez.
Si no usa un archivo MT3620 RDB, actualice los archivos de app_manifest.json tanto para las aplicaciones como para el archivo de definición de hardware y CMakeLists.txt archivo para que la aplicación de alto nivel coincida con su hardware.
Presione F5 para iniciar el depurador. Si el proyecto no se ha creado anteriormente, o si los archivos han cambiado y recompilar es necesario, Visual Studio Code creará el proyecto antes de que se inicie la depuración.
La ventana de salida de Azure Sphere debería mostrar "Implementing image..." seguido de las rutas de acceso al SDK y al compilador.

La ventana de salida debe mostrar la salida de aplicación de alto nivel:

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

El emulador de terminal conectado debe mostrar la salida desde el programa compatible en tiempo 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 Visual Studio Code características de depuración para establecer puntos de interrupción, inspeccionar variables e intentar otras tareas de depuración.

Solución de problemas

Es posible que la aplicación empiece a ejecutarse antes de que OpenOCD realice una conexión. Como resultado, es posible que se falten los puntos de interrupción establecidos al principio del código. Una solución alternativa sencilla para esto es retrasar el inicio de la aplicación hasta que Se conecte OpenOCD.

Inserta el siguiente código al principio del punto de entrada de la aplicación RTCoreMain. Esto hará que la aplicación entre y permanezca en un while bucle hasta que la variable f se establezca en true.
```
static _Noreturn void RTCoreMain(void)
{
  .
  .
  .
 volatile bool f = false;
 while (!f) {
    // empty.
 }
  .
  .
  .
}
```
Presione F5 para iniciar la aplicación con depuración y, a continuación, inicie la ejecución.
En el panel de depuración Locales , cambie el valor de f cero a uno.
Sigue el código como de costumbre.

Al crear con la CLI, primero crea e implementa la aplicación compatible con tiempo real y, a continuación, crea e implementa la aplicación de alto nivel.

Crear e implementar la aplicación compatible con tiempo real

Vaya a la carpeta donde extrajo las aplicaciones de IntercoreComms y, a continuación, seleccione la carpeta IntercoreComms/IntercoreComms_RTApp_MT3620_BareMetal.
Abra el archivo de app_manifest.json y compruebe que el id. del componente de la aplicación de alto nivel se muestra en la funcionalidad AllowedApplicationConnections.
Abre una interfaz de línea de comandos con PowerShell, símbolo del sistema de Windows o shell de comandos de Linux. Vaya al directorio de compilación del proyecto.
Desde el directorio de compilación del proyecto, en el símbolo del sistema, ejecute CMake con los siguientes parámetros:
```
cmake --preset <preset-name> <source-path>
```
- --preset <preset-name>
  
  El nombre preestablecido de configuración de compilación según se define en CMakePresets.json.
- --build <cmake-path>
  
  El directorio binario que contiene la caché de CMake. Por ejemplo, si ejecuta CMake en un ejemplo de Azure Sphere, el comando de compilación sería cmake --build out/ARM-Debug.
- <source-path>
  
  La ruta de acceso del directorio que contiene los archivos de origen de la aplicación de ejemplo. En el ejemplo, el repositorio de muestras de Azure Sphere se descargó en un directorio llamado AzSphere.
  
  Los parámetros CMake están separados por espacios. El carácter de continuación de línea (^ para la línea de comandos de Windows, \ para la línea de comandos de Linux o ' para PowerShell) puede usarse para facilitar la lectura, pero no es necesario.
Los ejemplos siguientes muestran los comandos CMake para la RTApp de IntercoreComms:
- Windows
- Linux
Símbolo del sistema de 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
```
Desde el directorio de compilación del proyecto, en el símbolo del sistema, ejecuta Ninja para crear la aplicación y crear el archivo de paquete de imagen.
```
ninja -C out/ARM-Debug
```
Ninja coloca los archivos resultantes de application y .imagepackage en el directorio especificado.

También puedes invocar Ninja a través de CMake con el siguiente comando:
```
cmake --build out/<binary-dir>
```
Establecido <binary-dir> en el directorio binario que contiene la caché de CMake. Por ejemplo, si ejecuta CMake en un ejemplo de Azure Sphere, el comando de compilación sería cmake --build out/ARM-Debug.

Al solucionar problemas, especialmente después de realizar cambios en los comandos de CMake, elimine toda la compilación e inténtelo de nuevo.
Elimine todas las aplicaciones que ya estén implementadas en el dispositivo:
```
az sphere device sideload delete
```
Desde el directorio de compilación del proyecto, en el símbolo del sistema, carga el paquete de imagen que ninja ha creado:
```
az sphere device sideload deploy --image-package <path-to-imagepackage>
```
La aplicación comenzará a ejecutarse poco después de cargarse.
Obtener el id. de componente para la imagen:
```
az sphere image-package show --image-package <path-to-imagepackage>
```
El comando devuelve todos los metadatos del paquete de imagen. El id. del componente de la aplicación aparece en la sección Identidad del tipo de imagen de la aplicación. Por ejemplo:
```
...
  "Identity": {
    "ComponentId": "<component-id>",
    "ImageId": "<image-id>",
    "ImageType": "Application"
  },
...
```

Crear e implementar la aplicación de alto nivel

Vaya a la carpeta donde extrajo las aplicaciones de IntercoreComms y, a continuación, seleccione la carpeta IntercoreComms/IntercoreComms_HighLevelApp.
Abra el archivo de app_manifest.json y compruebe que el id. del componente de RTApp se muestra en la funcionalidad AllowedApplicationConnections.
Abre una interfaz de línea de comandos con PowerShell, símbolo del sistema de Windows o shell de comandos de Linux. Vaya al directorio de compilación del proyecto.
Desde el directorio de compilación del proyecto, en el símbolo del sistema, ejecute CMake con los siguientes parámetros:
```
cmake --preset <preset-name> <source-path>
```
- --preset <preset-name>
  
  El nombre preestablecido de configuración de compilación según se define en CMakePresets.json.
- --build <cmake-path>
  
  El directorio binario que contiene la caché de CMake. Por ejemplo, si ejecuta CMake en un ejemplo de Azure Sphere, el comando de compilación sería cmake --build out/ARM-Debug.
- <source-path>
  
  La ruta de acceso del directorio que contiene los archivos de origen de la aplicación de ejemplo. En el ejemplo, el repositorio de muestras de Azure Sphere se descargó en un directorio llamado AzSphere.
  
  Los parámetros CMake están separados por espacios. El carácter de continuación de línea (^ para la línea de comandos de Windows, \ para la línea de comandos de Linux o ' para PowerShell) puede usarse para facilitar la lectura, pero no es necesario.
En los ejemplos siguientes se muestran los comandos CMake para la aplicación de alto nivel de IntercoreComms.
- Windows
- Linux
Símbolo del sistema de 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
```
Desde el directorio de compilación del proyecto, en el símbolo del sistema, ejecuta Ninja para crear la aplicación y crear el archivo de paquete de imagen.
```
ninja -C out/ARM-Debug
```
Ninja coloca los archivos resultantes de application y .imagepackage en el directorio especificado.

También puedes invocar Ninja a través de CMake con el siguiente comando:
```
cmake --build out/<binary-dir>
```
Establecido <binary-dir> en el directorio binario que contiene la caché de CMake. Por ejemplo, si ejecuta CMake en un ejemplo de Azure Sphere, el comando de compilación sería cmake --build out/ARM-Debug.

Al solucionar problemas, especialmente después de realizar cambios en los comandos de CMake, elimine toda la compilación e inténtelo de nuevo.
Desde el directorio de compilación del proyecto, en el símbolo del sistema, carga el paquete de imagen que ninja ha creado:
```
az sphere device sideload deploy --image-package <package-name>
```
La aplicación comenzará a ejecutarse poco después de cargarse.
Obtener el id. de componente para la imagen:
```
az sphere image-package show --image-package <path-to-imagepackage>
```
El comando devuelve todos los metadatos del paquete de imagen. El id. del componente de la aplicación aparece en la sección Identidad del tipo de imagen de la aplicación. Por ejemplo:
```
...
  "Identity": {
    "ComponentId": "<component-id>",
    "ImageId": "<image-id>",
    "ImageType": "Application"
  },
...
```

Ejecutar las aplicaciones asociadas con la depuración habilitada

Detenga la aplicación en tiempo real si se está ejecutando.
```
az sphere device app stop --component-id <component id>
```

Vuelva a iniciar la aplicación para la depuración.

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

Este comando devuelve el núcleo en el que se está ejecutando la aplicación.

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

Vaya a la carpeta Openocd de la sysroot con la que se creó la aplicación. La sysroots se instala en la carpeta de instalación del SDK de Azure Sphere. Por ejemplo, en Windows, la carpeta se instala de forma predeterminada en C:\Program Files (x86)\Microsoft Azure Sphere SDK\Sysroots\*sysroot*\tools\openocd y en Linux, en /opt/azurespheresdk/Sysroots/*sysroot*/tools/sysroots/x86_64-pokysdk-linux.

Ejecute openocd como se muestra en el ejemplo siguiente. En el ejemplo se supone que la aplicación se ejecuta en el núcleo 0. Si la aplicación se ejecuta en el núcleo 1, reemplaza "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"

Abre una nueva ventana de símbolo del sistema de Azure Sphere (CLI clásica de Windows Azure Sphere), un símbolo del sistema estándar o PowerShell (CLI de Windows Azure) o una ventana terminal (Linux).
Navega a la carpeta que contiene el archivo .out de la aplicación en tiempo real e inicia arm-none-eabi-gdb, que forma parte del GNU Arm Embedded Toolchain:
- Windows
- Linux
Símbolo del sistema de 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
El servidor OpenOCD proporciona una interfaz de servidor GDB en :4444. Establecer el destino para la depuración.

target remote :4444
Ahora puede ejecutar comandos gdb en la aplicación compatible con tiempo real. Agregue un punto de interrupción en la función HandleSendTimerDeferred:
```
break HandleSendTimerDeferred
```
El emulador de terminal conectado debe mostrar la salida desde la aplicación compatible en tiempo real.
Abre una nueva ventana de símbolo del sistema de Azure Sphere (CLI clásica de Windows Azure Sphere), un símbolo del sistema estándar o PowerShell (CLI de Windows Azure) o una ventana terminal (Linux).
Vaya a la carpeta que contiene el archivo .imagepackage de aplicación de alto nivel.
Detenga la aplicación de alto nivel si se está ejecutando.
```
az sphere device app stop --component-id <component id>
```

Vuelva a iniciar la aplicación de alto nivel con depuración.

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

Abra un emulador de terminal y establezca una conexión Telnet o TCP a 192.168.35.2 en el puerto 2342 para ver la salida de la aplicación de alto nivel.

Inicie gdb con el siguiente comando:

Windows
Linux

Símbolo del sistema de 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

El SDK de Azure Sphere se distribuye con varias sysroots para que las aplicaciones puedan dirigirse a diferentes conjuntos de API, como se describe en La versión en tiempo de ejecución de aplicaciones, sysroots y API beta. La sysroots se instala en la carpeta de instalación azure Sphere SDK en Sysroots.

Establezca el destino de depuración remota en la dirección IP 192.168.35.2 en el puerto 2345:

target remote 192.168.35.2:2345
Agregue un punto de interrupción en la función SendMessageToRTApp:

break SendMessageToRTApp
Escriba c para continuar, observe la salida en su terminal Telnet/TCP y, a continuación, cambie a la ventana del símbolo del sistema o terminal que contiene la sesión de depuración de aplicaciones en tiempo real.
Escribe c para continuar y observar la salida en la sesión serial conectada.

Puede trabajar entre sesiones de depuración, cambiando entre la aplicación compatible con tiempo real y la aplicación de alto nivel. Debería ver una salida similar a la siguiente en las dos ventanas de salida:

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 finalizar cada sesión de depuración, escriba q en el símbolo del sistema gdb.

Pasos siguientes

Explorar muestras adicionales para aplicaciones compatibles con alto nivel y en tiempo real
Más información sobre las aplicaciones Azure Sphere
Más información sobre el entorno de desarrollo de Azure Sphere