Información general Requisitos previos Introducción Ejecución de las demostraciones de Bluetooth de bajo consumo Uso de FreeRTOS en su propio proyecto de CMake para ESP32 Solución de problemas Debugging

Cómo empezar con el Espressif ESP32- C y el ESP-WROVER-KIT DevKit

importante

Esta integración de referencia está alojada en el repositorio de Amazon-FreeRTOS, que está en desuso. Recomendamos empezar por aquí al crear un nuevo proyecto. Si ya tiene un proyecto FreeRTOS existente basado en el repositorio Amazon FreeRTOS, ahora obsoleto, consulte Guía de migración del repositorio Github de Amazon-FreeRTOS.

nota

Para explorar cómo integrar las bibliotecas modulares y demostraciones de FreeRTOS en su propio proyecto Espressif IDF, consulte nuestra integración de referencia destacada para la plataforma ESP32-C3.

Siga este tutorial para empezar a usar el Espressif ESP32- DevKit C equipado con los módulos ESP32-WROOM-32, ESP32-SOLO-1 o ESP-WROVER y el ESP-WROVER-KIT-VB. Para adquirir uno de nuestros socios en el Catálogo de dispositivos de socios de AWS, utilice los siguientes enlaces:

Estas versiones de las placas de desarrollo con compatibles con FreeRTOS.

Para obtener más información sobre las versiones más recientes de estas placas, consulte la DevKitESP32-C V4 o la ESP-WROVER-KIT v4.1 en el sitio web de Espressif.

nota

Actualmente, el puerto Freertos para ESP32-WROVER-KIT y ESP DevKit C no admite la función de multiprocesamiento simétrico (SMP).

Información general

Este tutorial le guiará a través de los siguientes pasos:

Conexión de su placa a un equipo host.
Instalación de software en el equipo host para desarrollar y depurar las aplicaciones integradas de la placa de su microcontrolador.
Compilación cruzada de una aplicación de demostración de FreeRTOS en una imagen binaria.
Carga de la imagen binaria de la aplicación en su placa y, a continuación, ejecución de la aplicación.
Interacción con la aplicación que se ejecuta en la placa con una conexión serie para fines de monitorización y depuración.

Requisitos previos

Antes de comenzar con FreeRTOS en la placa de Espressif, tiene que configurar la cuenta de AWS y los permisos.

Si no dispone de una Cuenta de AWS, siga estos pasos para crear una.

Cómo registrarse en una Cuenta de AWS

Abra https://portal.aws.amazon.com/billing/signup.
Siga las instrucciones que se le indiquen.

Parte del procedimiento de registro consiste en recibir una llamada telefónica e indicar un código de verificación en el teclado del teléfono.

Al registrarse en una Cuenta de AWS, se crea un Usuario raíz de la cuenta de AWS. El usuario raíz tendrá acceso a todos los Servicios de AWS y recursos de esa cuenta. Como práctica recomendada de seguridad, asigne acceso administrativo a un usuario administrativo y utilice únicamente el usuario raíz para realizar tareas que requieran acceso de usuario raíz.

AWS le enviará un correo electrónico de confirmación luego de completar el proceso de registro. Puede ver la actividad de la cuenta y administrar la cuenta en cualquier momento entrando en https://aws.amazon.com/ y seleccionando Mi cuenta.

Crear un usuario administrativo

Después de registrarse para obtener una Cuenta de AWS, proteja su Usuario raíz de la cuenta de AWS, habilite AWS IAM Identity Center y cree un usuario administrativo para no utilizar el usuario raíz en las tareas cotidianas.

Protección de su Usuario raíz de la cuenta de AWS

Inicie sesión en la AWS Management Console como propietario de cuenta, elija Usuario raíz e ingrese el email de su Cuenta de AWS. En la siguiente página, escriba su contraseña.

Para obtener ayuda para iniciar sesión con el usuario raíz, consulte Signing in as the root user en la Guía del usuario de AWS Sign-In.
Active la autenticación multifactor (MFA) para el usuario raíz.

Para obtener instrucciones, consulte Habilitar un dispositivo MFA virtual para el usuario raíz de la Cuenta de AWS (consola) en la Guía del usuario de IAM.

Creación de un usuario administrativo

Activar IAM Identity Center

Para conocer las instrucciones, consulte Habilitar AWS IAM Identity Center en la Guía del usuario de AWS IAM Identity Center.
En IAM Identity Center, otorga acceso administrativo a un usuario administrativo.

Para ver un tutorial sobre el uso de Directorio de IAM Identity Center como origen de identidad, consulte Configurar el acceso de los usuarios con la configuración predeterminada de Directorio de IAM Identity Center en la Guía del usuario de AWS IAM Identity Center.

Cómo iniciar sesión como usuario administrativo

Para iniciar sesión con el usuario del IAM Identity Center, utilice la URL de inicio de sesión que se envió a la dirección de correo electrónico cuando creó el usuario del IAM Identity Center.

Para obtener ayuda para iniciar sesión con un usuario del IAM Identity Center, consulte Iniciar sesión en el portal de acceso de AWS en la Guía del Usuario de AWS Sign-In.

Para dar acceso, añada permisos a los usuarios, grupos o roles:

Usuarios y grupos en AWS IAM Identity Center:

Cree un conjunto de permisos. Siga las instrucciones de Creación de un conjunto de permisos en la Guía del usuario de AWS IAM Identity Center.
Usuarios administrados en IAM a través de un proveedor de identidades:

Cree un rol para la federación de identidades. Siga las instrucciones de Creación de un rol para un proveedor de identidades de terceros (federación) en la Guía del usuario de IAM.
Usuarios de IAM:
- Cree un rol que el usuario pueda aceptar. Siga las instrucciones descritas en Creación de un rol para un usuario de IAM en la Guía del usuario de IAM.
- (No recomendado) Asocie una política directamente a un usuario o añada un usuario a un grupo de usuarios. Siga las instrucciones descritas en Adición de permisos a un usuario (consola) de la Guía del usuario de IAM.

Introducción

nota

Los comandos de Linux de este tutorial requieren que utilice el intérprete de comandos Bash.

Configure el hardware de Espressif.
- Para obtener información sobre cómo configurar el hardware de la placa de desarrollo ESP32-C, consulte la Guía de introducción al DevKit ESP32-C V4. DevKit
- Para obtener información sobre cómo configurar el hardware de la placa de desarrollo ESP-WROVER-KIT, consulte Guía de introducción a ESP-WROVER-KIT V4.1.
importante
Cuando llegue a la sección Introducción de las guías de Espressif, deténgase y vuelva a las instrucciones en esta página.
Descargue Amazon FreeRTOS desde. GitHub (Para ver las instrucciones, consulte el archivo README.md).
Configure el entorno de desarrollo.

Debe instalar una cadena de herramientas para comunicarse con la placa. Espressif proporciona el ESP-IDF para desarrollar software para sus placas. Dado que el ESP-IDF tiene su propia versión del kernel de FreeRTOS integrada como componente, Amazon FreeRTOS incluye una versión personalizada del ESP-IDF v4.2 en la que se ha eliminado el kernel de FreeRTOS. Esto soluciona los problemas relacionados con los archivos duplicados al compilar. Para usar la versión personalizada del ESP-IDF v4.2 incluida en Amazon FreeRTOS, siga las instrucciones que aparecen a continuación para el sistema operativo de su máquina host.

Windows
1. Descargue el instalador en línea universal de ESP-IDF para Windows.
2. Ejecute el instalador en línea universal.
3. Cuando llegue al paso Descargar o usar ESP-IDF, seleccione Usar un directorio ESP-IDF existente y establezca Elegir directorio ESP-IDF existente en freertos/vendors/espressif/esp-idf.
4. Complete la instalación.
macOS
1. Siga las instrucciones que se indican en Requisitos previos para la configuración estándar de la cadena de herramientas (ESP-IDF v4.2) para macOS.
  
  importante
  Cuando llegue a las instrucciones de “Obtención de ESP-IDF” en Pasos siguientes, deténgase y vuelva a las instrucciones de esta página.
2. Abra una ventana de línea de comandos.
3. Navegue hasta el directorio de descargas de FreeRTOS y ejecute el siguiente script para descargar e instalar la cadena de herramientas espressif para su plataforma.
```
vendors/espressif/esp-idf/install.sh
```
4. Añada las herramientas de la cadena de herramientas ESP-IDF a la ruta de su terminal con el siguiente comando.
```
source vendors/espressif/esp-idf/export.sh
```
Linux
1. Siga las instrucciones que se indican en Requisitos previos para la configuración estándar de la cadena de herramientas (ESP-IDF v4.2) para Linux.
  
  importante
  Cuando llegue a las instrucciones de “Obtención de ESP-IDF” en Pasos siguientes, deténgase y vuelva a las instrucciones de esta página.
2. Abra una ventana de línea de comandos.
3. Navegue hasta el directorio de descargas de FreeRTOS y ejecute el siguiente script para descargar e instalar la cadena de herramientas Espressif para su plataforma.
```
vendors/espressif/esp-idf/install.sh
```
4. Añada las herramientas de la cadena de herramientas ESP-IDF a la ruta de su terminal con el siguiente comando.
```
source vendors/espressif/esp-idf/export.sh
```
Establezca una conexión serie.
1. Para establecer una conexión en serie entre su máquina host y el DevKit ESP32-C, debe instalar los controladores VCP USB a UART Bridge del CP210x. Puede descargar estos controladores de Silicon Labs.
  
  Para establecer una conexión entre su máquina host y el ESP32-WROVER-KIT, debe instalar el controlador de puerto COM virtual FTDI. Puede descargar este controlador desde FTDI.
2. Siga los pasos para Establecer una conexión serie con ESP32.
3. Después de establecer una conexión serie, anote el puerto serie de la conexión de la placa. Lo necesita para instalar la demostración.

Configuración de las aplicaciones de demostración de FreeRTOS

Para este tutorial, el archivo de configuración de FreeRTOS se encuentra en freertos/vendors/espressif/boards/board-name/aws_demos/config_files/FreeRTOSConfig.h. (Por ejemplo, si se elige AFR_BOARD espressif.esp32_devkitc, el archivo de configuración se encuentra en freertos/vendors/espressif/boards/esp32/aws_demos/config_files/FreeRTOSConfig.h).

Si ejecuta macOS o Linux, abra un símbolo del terminal. Si utiliza Windows, abra la aplicación “ESP-IDF 4.x CMD” (si incluyó esta opción al instalar la cadena de herramientas de ESP-IDF) o la aplicación de “símbolo del sistema” en caso contrario.
Para verificar que tiene instalado Python3, ejecute
```
python --version
```
Se muestra la versión instalada. Si no tiene instalado Python 3.0.1 o una versión posterior, puede instalarlo desde el sitio web de Python.
Necesita la interfaz de la línea de comandos (CLI) de AWS para ejecutar los comandos de AWS IoT. Si ejecuta Windows, utilice el comando easy_install awscli para instalar la CLI de AWS en la aplicación de “Comando” o “ESP-IDF 4.x CMD”.

Si ejecuta macOS o Linux, consulte Instalación de la CLI de AWS.
Ejecute
```
aws configure
```
y configure la CLI de AWS con su ID de clave de acceso de AWS, la clave de acceso secreta y la región predeterminada de AWS. Para obtener más información, consulte Configuración de la CLI de AWS.
Utilice el comando siguiente para instalar el SDK de AWS para Python (boto3):
- En Windows, en la aplicación de “Comando” o “ESP-IDF 4.x CMD”, ejecute
```
pip install boto3 --user
```
  nota
  Consulte la Documentación de Boto3 para obtener más detalles.
- En macOS o Linux, ejecute
```
pip install tornado nose --user
```
  y, a continuación, ejecute
```
pip install boto3 --user
```
FreeRTOS incluye el script SetupAWS.py para facilitar la configuración de su placa Espressif para conectar a AWS IoT. Para configurar el script, abra freertos/tools/aws_config_quick_start/configure.json y defina los siguientes atributos:
afr_source_dir

Ruta completa del directorio freertos de su equipo. Asegúrese de que utiliza barras diagonales para especificar esta ruta.

thing_name

El nombre que desea asignar al objeto de AWS IoT que representa la placa.

wifi_ssid

El SSID de su red wifi.

wifi_password

La contraseña para su red wifi.

wifi_security
El tipo de seguridad para su red wifi.

Los siguientes son tipos de seguridad válidos:
eWiFiSecurityOpen (abierta, sin seguridad)

eWiFiSecurityWEP (seguridad WEP)

eWiFiSecurityWPA (seguridad WPA)

eWiFiSecurityWPA2 (seguridad WPA2)
Ejecute el script de configuración.
1. Si ejecuta macOS o Linux, abra un símbolo del terminal. Si ejecuta Windows, abra la aplicación de “ESP-IDF 4.x CMD” o “Comando”.
2. Vaya al directorio freertos/tools/aws_config_quick_start y ejecute
```
python SetupAWS.py setup
```
  El script hace lo siguiente:
  - Crea un objeto de IoT, un certificado y una política.
  - Asocia la política de IoT al certificado y el certificado al objeto de AWS IoT.
  - Rellena el archivo aws_clientcredential.h con su punto de conexión de AWS IoT, el SSID de la red wifi y las credenciales.
  - Formatea el certificado y la clave privada y los escribe en el archivo de encabezado aws_clientcredential_keys.h.
  nota
  El certificado tiene codificación fija únicamente con fines ilustrativos. Las aplicaciones de producción deben almacenar estos archivos en un lugar seguro.
  
  Para obtener más información sobre SetupAWS.py, consulte el archivo README.md en el directorio freertos/tools/aws_config_quick_start.

Monitorización de mensajes de MQTT en la nube

Antes de ejecutar el proyecto de demostración de FreeRTOS, puede configurar el cliente de MQTT en la consola de AWS IoT para monitorizar los mensajes que envía el dispositivo a la nube de AWS.

Para suscribirse al tema de MQTT con el cliente de MQTT de AWS IoT

Vaya a la consola de AWS IoT.
En el panel de navegación, seleccione Probar y, a continuación, seleccione el cliente de prueba MQTT.
En Tema de suscripción, escriba your-thing-name/example/topic y, a continuación, elija Suscribirse al tema.

Cuando el proyecto de demostración se ejecute correctamente en su dispositivo, verá el mensaje “¡Hola, mundo!” enviado varias veces al tema al que se ha suscrito.

Creación, instalación y ejecución del proyecto de demostración de FreeRTOS con el script idf.py

Puede usar la utilidad de IDF de Espressif (idf.py) para crear el proyecto e instalar los archivos binarios en su dispositivo.

nota

Algunas configuraciones pueden requerir que utilice la opción de puerto "-p port-name" con idf.py para especificar el puerto correcto, como en el siguiente ejemplo.


idf.py -p /dev/cu.usbserial-00101301B flash

Creación e instalación de FreeRTOS en Windows, Linux y macOS (ESP-IDF v4.2)

Desplácese hasta la raíz del directorio de descargas de FreeRTOS.
En una ventana de línea de comandos, introduzca el siguiente comando para añadir las herramientas ESP-IDF a la ruta del terminal.
Windows (aplicación “Comando”)
```
vendors\espressif\esp-idf\export.bat
```
Windows (aplicación “ESP-IDF 4.x CMD”)

(Esto ya se hizo cuando abrió aplicación).

Linux/macOS
```
source vendors/espressif/esp-idf/export.sh
```

Configure cmake en el directorio build y cree la imagen del firmware con el siguiente comando.


idf.py -DVENDOR=espressif -DBOARD=esp32_wrover_kit -DCOMPILER=xtensa-esp32 build

Debería ver un resultado como el siguiente.


   Running cmake in directory /path/to/hello_world/build
   Executing "cmake -G Ninja --warn-uninitialized /path/to/hello_world"...
   Warn about uninitialized values.
   -- Found Git: /usr/bin/git (found version "2.17.0")
   -- Building empty aws_iot component due to configuration
   -- Component names: ...
   -- Component paths: ...

   ... (more lines of build system output)

   [527/527] Generating hello-world.bin
   esptool.py v2.3.1

   Project build complete. To flash, run this command:
   ../../../components/esptool_py/esptool/esptool.py -p (PORT) -b 921600 write_flash --flash_mode dio --flash_size detect --flash_freq 40m 0x10000 build/hello-world.bin  build 0x1000 build/bootloader/bootloader.bin 0x8000 build/partition_table/partition-table.bin
   or run 'idf.py -p PORT flash'

Si no hay errores, la creación generará los archivos .bin binarios del firmware.

Borre la memoria flash de la placa de desarrollo con el siguiente comando.
```
idf.py erase_flash
```
Utilice el script idf.py para instalar el archivo binario de la aplicación en la placa.
```
idf.py flash
```
Supervise la salida del puerto serie de la placa con el siguiente comando.
```
idf.py monitor
```
nota
Puede combinar estos comandos como se muestra en el siguiente ejemplo.
```
idf.py erase_flash flash monitor
```
Para determinadas configuraciones de máquinas host, debe especificar el puerto en el que se va a instalar la placa, como en el siguiente ejemplo.
```
idf.py erase_flash flash monitor -p /dev/ttyUSB1
```

Creación e instalación de FreeRTOS con CMake

Además de usar el script idf.py proporcionado por el SDK de IDF para crear y ejecutar su código, también puede crear el proyecto con CMake. Actualmente es compatible con Unix Makefiles y el sistema de creación Ninja.

Para crear e instalar el proyecto

En una ventana de línea de comandos, navegue hasta el directorio de descargas de FreeRTOS.
Ejecute el siguiente script para añadir las herramientas ESP-IDF a la ruta de su intérprete de comandos.
Windows
```
vendors\espressif\esp-idf\export.bat
```
Linux/macOS
```
source vendors/espressif/esp-idf/export.sh
```

Utilice el siguiente comando para generar los archivos de creación.

Con Unix Makefiles


cmake -DVENDOR=espressif -DBOARD=esp32_wrover_kit -DCOMPILER=xtensa-esp32 -S . -B ./YOUR_BUILD_DIRECTORY -DAFR_ENABLE_ALL_MODULES=1 -DAFR_ENABLE_TESTS=0

Con Ninja


cmake -DVENDOR=espressif -DBOARD=esp32_wrover_kit -DCOMPILER=xtensa-esp32 -S . -B ./YOUR_BUILD_DIRECTORY -DAFR_ENABLE_ALL_MODULES=1 -DAFR_ENABLE_TESTS=0 -GNinja

Compilar el proyecto.

Con Unix Makefiles


make -C ./YOUR_BUILD_DIRECTORY -j8

Con Ninja


ninja -C ./YOUR_BUILD_DIRECTORY -j8

Borre la instalación y, a continuación, instale la placa.

Con Unix Makefiles


make -C ./YOUR_BUILD_DIRECTORY erase_flash


make -C ./YOUR_BUILD_DIRECTORY flash

Con Ninja


ninja -C ./YOUR_BUILD_DIRECTORY erase_flash


ninja -C ./YOUR_BUILD_DIRECTORY flash

Ejecución de las demostraciones de Bluetooth de bajo consumo

Freertos admite la conectividad Biblioteca de Bluetooth de bajo consumo.

Para ejecutar el proyecto de demostración de FreeRTOS en Bluetooth de bajo consumo, debe ejecutar la aplicación de demostración de SDK para móviles de Bluetooth de bajo consumo de FreeRTOS en su dispositivo móvil iOS o Android.

Para configurar la aplicación de demostración del SDK para móviles de Bluetooth de bajo consumo de FreeRTOS

Siga las instrucciones de SDK para móviles para dispositivos Bluetooth de FreeRTOS para descargar e instalar los SDK para su plataforma móvil en su equipo host.
Siga las instrucciones en Aplicación de demostración de SDK para móviles de Bluetooth de bajo consumo de FreeRTOS para configurar la aplicación móvil de demostración en su dispositivo móvil.

Para obtener instrucciones sobre cómo ejecutar la demostración de Bluetooth de bajo consumo de MQTT en la placa, consulte MQTT a través de Bluetooth de bajo consumo.

Para obtener instrucciones sobre cómo ejecutar la demostración de aprovisionamiento wifi en la placa, consulte Aprovisionamiento Wi-Fi.

Uso de FreeRTOS en su propio proyecto de CMake para ESP32

Si desea usar FreeRTOS en su propio proyecto de CMake, puede configurarlo como un subdirectorio y crearlo junto con su aplicación. En primer lugar, obtenga una copia de FreeRTOS en. GitHub También puede configurarlo como un submódulo git con el siguiente comando para que sea más fácil actualizarlo en el futuro.


git submodule add -b release https://github.com/aws/amazon-freertos.git freertos

Si se publica una versión más reciente, puede actualizar su copia local con estos comandos.


# Pull the latest changes from the remote tracking branch.
git submodule update --remote -- freertos


# Commit the submodule change because it is pointing to a different revision now.
git add freertos


git commit -m "Update FreeRTOS to a new release"

Si el proyecto tiene la siguiente estructura de directorios:


- freertos (the copy that you obtained from GitHub or the AWS IoT console)
- src
  - main.c (your application code)
- CMakeLists.txt

A continuación, se muestra un ejemplo del archivo CMakeLists.txt de nivel superior que se puede utilizar para crear la aplicación junto con FreeRTOS.


cmake_minimum_required(VERSION 3.13)

project(freertos_examples)

# Tell IDF build to link against this target.
set(IDF_EXECUTABLE_SRCS "<complete_path>/src/main.c")
set(IDF_PROJECT_EXECUTABLE my_app)

# Add FreeRTOS as a subdirectory. AFR_BOARD tells which board to target.
set(AFR_BOARD espressif.esp32_devkitc CACHE INTERNAL "")
add_subdirectory(freertos)

# Link against the mqtt library so that we can use it. Dependencies are transitively
# linked.
target_link_libraries(my_app PRIVATE AFR::core_mqtt)

Para generar el proyecto, ejecute los siguientes comandos de CMake. Asegúrese de que el compilador ESP32 está en la variable de entorno PATH.


cmake -S . -B build-directory -DCMAKE_TOOLCHAIN_FILE=freertos/tools/cmake/toolchains/xtensa-esp32.cmake -GNinja


cmake --build build-directory

Para instalar la aplicación en su placa, ejecute el siguiente comando.


cmake --build build-directory --target flash

Uso de los componentes de FreeRTOS

Después de ejecutar CMake, puede encontrar todos los componentes disponibles en la salida de resumen. Debería parecerse al siguiente ejemplo.


====================Configuration for FreeRTOS====================
  Version:                 202107.00
  Git version:             202107.00-g79ad6defb

Target microcontroller:
  vendor:                  Espressif
  board:                   ESP32-DevKitC
  description:             Development board produced by Espressif that comes in two
                           variants either with ESP-WROOM-32 or ESP32-WROVER module
  family:                  ESP32
  data ram size:           520KB
  program memory size:     4MB

Host platform:
  OS:                      Linux-4.15.0-66-generic
  Toolchain:               xtensa-esp32
  Toolchain path:          /opt/xtensa-esp32-elf
  CMake generator:         Ninja

FreeRTOS modules:
  Modules to build:        backoff_algorithm, common, common_io, core_http,
                           core_http_demo_dependencies, core_json, core_mqtt,
                           core_mqtt_agent, core_mqtt_agent_demo_dependencies,
                           core_mqtt_demo_dependencies, crypto, defender, dev_mode_key_
                           provisioning, device_defender, device_defender_demo_
                           dependencies, device_shadow, device_shadow_demo_dependencies,
                           freertos_cli_plus_uart, freertos_plus_cli, greengrass,
                           http_demo_helpers, https, jobs, jobs_demo_dependencies,
                           kernel, logging, mqtt, mqtt_agent_interface, mqtt_demo_
                           helpers, mqtt_subscription_manager, ota, ota_demo_
                           dependencies, ota_demo_version, pkcs11, pkcs11_helpers,
                           pkcs11_implementation, pkcs11_utils, platform, secure_sockets,
                           serializer, shadow, tls, transport_interface_secure_sockets,
                           wifi
  Enabled by user:         common_io, core_http_demo_dependencies, core_json,
                           core_mqtt_agent_demo_dependencies, core_mqtt_demo_
                           dependencies, defender, device_defender, device_defender_demo_
                           dependencies, device_shadow, device_shadow_demo_dependencies,
                           freertos_cli_plus_uart, freertos_plus_cli, greengrass, https,
                           jobs, jobs_demo_dependencies, logging, ota_demo_dependencies,
                           pkcs11, pkcs11_helpers, pkcs11_implementation, pkcs11_utils,
                           platform, secure_sockets, shadow, wifi
  Enabled by dependency:   backoff_algorithm, common, core_http, core_mqtt,
                           core_mqtt_agent, crypto, demo_base, dev_mode_key_provisioning,
                           freertos, http_demo_helpers, kernel, mqtt, mqtt_agent_
                           interface, mqtt_demo_helpers, mqtt_subscription_manager, ota,
                           ota_demo_version, pkcs11_mbedtls, serializer, tls,
                           transport_interface_secure_sockets, utils
  3rdparty dependencies:   jsmn, mbedtls, pkcs11, tinycbor
  Available demos:         demo_cli_uart, demo_core_http, demo_core_mqtt, demo_core_mqtt_
                           agent, demo_device_defender, demo_device_shadow,
                           demo_greengrass_connectivity, demo_jobs, demo_ota_core_http,
                           demo_ota_core_mqtt, demo_tcp
  Available tests:
=========================================================================

Puede hacer referencia a cualquier componente de la lista Modules to build. Para vincularlos a su aplicación, coloque el espacio de nombres AFR:: delante del nombre (por ejemplo AFR::core_mqtt, AFR::ota, etc.).

Adición de componentes personalizados a ESP-IDF

Puede añadir más componentes mientras utiliza ESP-IDF. Por ejemplo, suponiendo que desea añadir un componente llamado example_component y su proyecto tiene el siguiente aspecto:


- freertos
- components
  - example_component
    - include
      - example_component.h
    - src
      - example_component.c
    - CMakeLists.txt
- src
  - main.c
- CMakeLists.txt

A continuación, se muestra un ejemplo del archivo CMakeLists.txt de su componente.



add_library(example_component src/example_component.c)
target_include_directories(example_component PUBLIC include)

A continuación, en el archivo CMakeLists.txt de nivel superior, añada el componente insertando la siguiente línea justo después de add_subdirectory(freertos).


add_subdirectory(component/example_component)

A continuación, modifique target_link_libraries para incluir su componente.


target_link_libraries(my_app PRIVATE AFR::core_mqtt PRIVATE example_component)

Este componente ahora se vincula automáticamente al código de la aplicación de forma predeterminada. Ahora puede incluir sus archivos de encabezado y llamar a las funciones que define.

Anulación de las configuraciones para FreeRTOS

Actualmente no hay un enfoque bien definido para redefinir las configuraciones fuera del árbol de código fuente de FreeRTOS. De forma predeterminada, CMake buscará los directorios freertos/vendors/espressif/boards/esp32/aws_demos/config_files/ y freertos/demos/include/. Sin embargo, puede usar una solución alternativa para indicar al compilador que busque primero en otros directorios. Por ejemplo, puede añadir otra carpeta para las configuraciones de FreeRTOS.


- freertos
- freertos-configs
  - aws_clientcredential.h
  - aws_clientcredential_keys.h
  - iot_mqtt_agent_config.h
  - iot_config.h
- components
- src
- CMakeLists.txt

Los archivos de freertos-configs se copian de los directorios freertos/vendors/espressif/boards/esp32/aws_demos/config_files/ y freertos/demos/include/. A continuación, en el archivo de nivel superior CMakeLists.txt, agregue esta línea delante de add_subdirectory(freertos) para que el compilador busque primero en este directorio.


include_directories(BEFORE freertos-configs)

Proporcionar su propio sdkconfig para ESP-IDF

En caso de que desee proporcionar su propio sdkconfig.default, puede establecer la variable de CMake IDF_SDKCONFIG_DEFAULTS desde la línea de comandos:


cmake -S . -B build-directory -DIDF_SDKCONFIG_DEFAULTS=path_to_your_sdkconfig_defaults -DCMAKE_TOOLCHAIN_FILE=freertos/tools/cmake/toolchains/xtensa-esp32.cmake -GNinja

Si no especifica una ubicación para su propio archivo sdkconfig.default, FreeRTOS utilizará el archivo predeterminado ubicado en freertos/vendors/espressif/boards/esp32/aws_demos/sdkconfig.defaults.

Para obtener más información, consulte Configuración del proyecto en la Referencia de la API de Espressif y, si encuentra problemas después de haber compilado correctamente, consulte la sección sobre Opciones obsoletas y sus sustituciones en esa página.

Resumen

Si tiene un proyecto con un componente llamado example_component y desea invalidar algunas configuraciones, aquí tiene un ejemplo completo del archivo CMakeLists.txt de nivel superior.


cmake_minimum_required(VERSION 3.13)

project(freertos_examples)

set(IDF_PROJECT_EXECUTABLE my_app)
set(IDF_EXECUTABLE_SRCS "src/main.c")

# Tell IDF build to link against this target.
set(IDF_PROJECT_EXECUTABLE my_app)

# Add some extra components. IDF_EXTRA_COMPONENT_DIRS is a variable used by ESP-IDF
# to collect extra components.
get_filename_component(
    EXTRA_COMPONENT_DIRS
    "components/example_component" ABSOLUTE
)
list(APPEND IDF_EXTRA_COMPONENT_DIRS ${EXTRA_COMPONENT_DIRS})

# Override the configurations for FreeRTOS.
include_directories(BEFORE freertos-configs)

# Add FreeRTOS as a subdirectory. AFR_BOARD tells which board to target.
set(AFR_BOARD espressif.esp32_devkitc CACHE INTERNAL "")
add_subdirectory(freertos)

# Link against the mqtt library so that we can use it. Dependencies are transitively
# linked.
target_link_libraries(my_app PRIVATE AFR::core_mqtt)

Solución de problemas

Si ejecuta macOS y el sistema operativo no reconoce su ESP-WROVER-KIT, asegúrese de que no tiene los controladores D2XX instalados. Para desinstalarlos, siga las instrucciones de la guía de instalación de controladores FTDI para macOS X.
La utilidad de monitorización proporcionada por ESP-IDF (e invocada mediante la supervisión de creación) le ayuda a descodificar las direcciones. Por este motivo, puede ayudarle a obtener algunos rastreos inversos significativos en caso de que se produzca el bloqueo de la aplicación. Para obtener más información, consulte Descodificación automática de direcciones en el sitio web de Espressif.
También es posible habilitar GDBstub para la comunicación con gdb sin necesidad de hardware JTAG especial. Para obtener más información, consulte Inicio de GDB para GDBStub en el sitio web de Espressif.
Para obtener información acerca de cómo configurar un entorno basado en OpenOCD si fuera necesario realizar la depuración basada en hardware JTAG, consulte Depuración de JTAG en el sitio web de Espressif.
Si no es posible instalar pyserial utilizando pip en macOS, descárguelo del sitio web de pyserial.
Si la placa se restablece de forma continua, intente borrar la instalación escribiendo el siguiente comando en el terminal.
```
make erase_flash
```
Si ve errores al ejecutar idf_monitor.py, utilice Python 2.7.
Las bibliotecas necesarias de ESP-IDF se incluyen en FreeRTOS, por lo que no es necesario descargarlas de forma externa. Si se ha establecido la variable del entorno IDF_PATH, le recomendamos que la elimine antes de la creación de FreeRTOS.
En Windows, el proyecto puede tardar entre 3 y 4 minutos en compilarse. Para reducir el tiempo de creación, puede utilizar el conmutador -j4 del comando make.
```
make flash monitor -j4
```
Si el dispositivo tiene dificultades para conectarse a AWS IoT, abra el archivo aws_clientcredential.h y compruebe que las variables de configuración estén correctamente definidas en el archivo. clientcredentialMQTT_BROKER_ENDPOINT[] debe tener un aspecto similar al siguiente: 1234567890123-ats.iot.us-east-1.amazonaws.com.
Si sigue los pasos de Uso de FreeRTOS en su propio proyecto de CMake para ESP32 y ve errores de referencias no definidas del vinculador, generalmente se debe a que faltan bibliotecas o demostraciones dependientes. Para agregarlas, actualice el archivo CMakeLists.txt (en el directorio raíz) usando la función CMake estándar target_link_libraries.
La versión 4.2 de ESP-IDF admite el uso de la cadena de herramientas xtensa\-esp32\-elf\-gcc 8\.2\.0\.. Si utiliza una versión anterior de la cadena de herramientas de Xtensa, descargue la versión necesaria.

Si ve un registro de errores como el siguiente sobre las dependencias de Python que no se cumplen en la versión 4.2 de ESP-IDF:


The following Python requirements are not satisfied:
  click>=5.0
  pyserial>=3.0
  future>=0.15.2
  pyparsing>=2.0.3,<2.4.0
  pyelftools>=0.22
  gdbgui==0.13.2.0
  pygdbmi<=0.9.0.2
  reedsolo>=1.5.3,<=1.5.4
  bitstring>=3.1.6
  ecdsa>=0.16.0
  Please follow the instructions found in the "Set up the tools" section of ESP-IDF Getting Started Guide

Instale las dependencias de Python en su plataforma mediante el siguiente comando de Python:


root/vendors/espressif/esp-idf/requirements.txt

Para obtener más información sobre cómo solucionar problemas, consulte Introducción a solución de problemas.

Debugging

Código de depuración en Espressif ESP32- DevKit C y ESP-WROVER-KIT (ESP-IDF v4.2)

En esta sección se muestra cómo utilizar la versión 4.2 de ESP-IDF en el hardware de Espressif. Necesita un cable que vaya de JTAG al USB. Utilizamos un cable de USB a MPSSE (por ejemplo, el C232HM-DDHSL-0 de FTDI).

Configuración DevKit del ESP-C JTAG

Para el cable C232HM-DDHSL-0 de FTDI, se trata de las conexiones al ESP32 DevkitC.


| C232HM-DDHSL-0 Wire Color | ESP32 GPIO Pin | JTAG Signal Name |
| ------------------------- | -------------- | ---------------- |
|  Brown (pin 5)            |  IO14          |  TMS             |
|  Yellow (pin 3)           |  IO12          |  TDI             |
|  Black (pin 10)           |  GND           |  GND             |
|  Orange (pin 2)           |  IO13          |  TCK             |
|  Green (pin 4)            |  IO15          |  TDO             |

Configuración de JTAG de ESP-WROVER-KIT

Para el cable C232HM-DDHSL-0 de FTDI, se trata de las conexiones al ESP32-WROVER-KIT.


| C232HM-DDHSL-0 Wire Color | ESP32 GPIO Pin | JTAG Signal Name |
| ------------------------- | -------------- | ---------------- |
|  Brown (pin 5)            |  IO14          |  TMS             |
|  Yellow (pin 3)           |  IO12          |  TDI             |
|  Orange (pin 2)           |  IO13          |  TCK             |
|  Green (pin 4)            |  IO15          |  TDO             |

Estas tablas se han desarrollado a partir de lahoja de datos de C232HM-DDHSL-0 de FTDI. Para obtener más información, consulte la sección Conexión del cable C232HM MPSSE y detalles mecánicos en la hoja de datos.

Para habilitar JTAG en el ESP-WROVER-KIT, coloque puentes en los pines TMS, TDO, TDI, TCK y S_TDI tal y como se muestra aquí.

Depuración en Windows (ESP-IDF v4.2)

Para configurar para la depuración en Windows

Conecte el lado del USB de C232HM-DDHSL-0 de FTDI en su equipo y el otro lado tal y como se describe en Código de depuración en Espressif ESP32- DevKit C y ESP-WROVER-KIT (ESP-IDF v4.2). El dispositivo C232HM-DDHSL-0 de FTDI debe aparecer en Device Manager (Administrador de dispositivos) bajo Universal Serial Bus Controllers (Controladores de bus serie universales).
En la lista de dispositivos de bus serie universal, haga clic con el botón derecho en el dispositivo C232HM-DDHSL-0 y elija Propiedades.

nota
El dispositivo podría aparecer como USB Serial Port (Puerto serie USB).

En la ventana de propiedades, elija la pestaña Detalles para ver las propiedades del dispositivo. Si el dispositivo no aparece en la lista, instale el controlador de Windows para C232HM-DDHSL-0 de FTDI.
En la pestaña Details (Detalles), elija Property (Propiedad) y, a continuación, elija Hardware IDs (ID de hardware). Debería ver algo similar a lo siguiente en el campo Valor.
```
FTDIBUS\COMPORT&VID_0403&PID_6014
```
En este ejemplo, el ID de proveedor es 0403 y el ID de producto es 6014.

Compruebe que estos ID coinciden con los ID de projects/espressif/esp32/make/aws_demos/esp32_devkitj_v1.cfg. Los ID se especifican en una línea que comienza con ftdi_vid_pid seguida de un ID de proveedor y un ID de producto.
```
ftdi_vid_pid 0x0403 0x6014
```
Descargue OpenOCD para Windows.
Descomprima el archivo en C:\ y añada C:\openocd-esp32\bin a la ruta del sistema.
OpenOCD requiere libusb, que no está instalado de forma predeterminada en Windows. Para instalar libusb:
1. Descargue zadig.exe.
2. Ejecute zadig.exe. Desde el menú Options (Opciones), seleccione List All Devices (Lista de todos los dispositivos).
3. En el menú desplegable, elija C232HM-DDHSL-0.
4. En el campo del controlador de destino, que se encuentra a la derecha de la flecha verde, elija WinUSB.
5. En la lista que hay bajo el campo del controlador de destino, elija la flecha y, a continuación, haga elija Instalar controlador. Elija Replace Driver (Reemplazar controlador).
Abra un símbolo del sistema, vaya a la raíz del directorio de descargas de FreeRTOS y ejecute el siguiente comando.
```
idf.py openocd
```
Deje este símbolo del sistema abierto.
Abra un nuevo símbolo del sistema, vaya a la raíz del directorio de descargas de FreeRTOS y ejecute
```
idf.py flash monitor
```
Abra otra línea de comandos, navegue hasta la raíz de su directorio de descargas de FreeRTOS y espere a que la demostración comience a ejecutarse en su placa. Cuando esto suceda, ejecute
```
idf.py gdb
```
El programa debe detenerse en la función main.

nota
El ESP32 admite un máximo de dos puntos de interrupción.

Depuración en macOS (ESP-IDF v4.2)

Descargue el controlador FTDI para macOS.
Descargue OpenOCD.
Extraiga el archivo.tar descargado y establezca la ruta de .bash_profile en OCD_INSTALL_DIR/openocd-esp32/bin.
Utilice el siguiente comando para instalar libusb en macOS.
```
brew install libusb
```
Utilice el siguiente comando para descargar el controlador de puerto serie.
```
sudo kextunload -b com.FTDI.driver.FTDIUSBSerialDriver
```
Utilice el siguiente comando para descargar el controlador de puerto serie.
```
sudo kextunload -b com.FTDI.driver.FTDIUSBSerialDriver
```
Si ejecuta una versión de macOS posterior a 10.9, utilice el siguiente comando para descargar el controlador FTDI de Apple.
```
sudo kextunload -b com.apple.driver.AppleUSBFTDI
```
Utilice el siguiente comando para obtener el ID del producto y el ID de proveedor ID del cable FTDI. Enumera los dispositivos USB conectados.
```
system_profiler SPUSBDataType
```
La salida de system_profiler debería ser similar a la siguiente.
```
   DEVICE:

   Product ID: product-ID
   Vendor ID: vendor-ID (Future Technology Devices International Limited) 
```
Abra el archivo projects/espressif/esp32/make/aws_demos/esp32_devkitj_v1.cfg. El ID del proveedor y el ID del producto de su dispositivo se especifican en una línea que comienza por ftdi_vid_pid. Cambie los ID para que coincidan con los del resultado de system_profiler del paso anterior.
Abra una ventana de terminal, navegue hasta la raíz de su directorio de descargas de FreeRTOS y utilice el comando siguiente para ejecutar OpenOCD.
```
idf.py openocd
```
Deje abierta esta ventana de terminal.
Abra un nuevo terminal y utilice el siguiente comando para cargar el controlador de puerto serie FTDI.
```
sudo kextload -b com.FTDI.driver.FTDIUSBSerialDriver
```
Desplácese hasta la raíz del directorio de descargas de FreeRTOS y ejecute
```
idf.py flash monitor
```
Abra un nuevo terminal, vaya a la raíz del directorio de descargas de FreeRTOS y ejecute
```
idf.py gdb
```
El programa debe detenerse en main.

Depuración en Linux (ESP-IDF v4.2)

Descargue OpenOCD. Extraiga el archivo tarball y siga las instrucciones de instalación en el archivo readme.
Para instalar libusb en Linux, use el siguiente comando.
```
sudo apt-get install libusb-1.0
```
Abra un terminal e introduzca USB ls -l /dev/ttyUSB* para crear una lista de todos los dispositivos conectados a su equipo. Esto le ayuda a comprobar si el sistema operativo reconoce los puertos USB de la placa. Debería ver un resultado como el siguiente.
```
   $ls -l /dev/ttyUSB*
   crw-rw----    1    root    dialout    188,    0    Jul    10    19:04    /dev/ttyUSB0
   crw-rw----    1    root    dialout    188,    1    Jul    10    19:04    /dev/ttyUSB1 
```
Cierre la sesión y, a continuación, inicie sesión y realice un ciclo de encendido y apagado para la placa para que los cambios surtan efecto. En un símbolo del terminal, enumere los dispositivos USB. Asegúrese de que el responsable del grupo ha cambiado de dialout a plugdev.
```
   $ls -l /dev/ttyUSB*
   crw-rw----    1    root    plugdev    188,    0    Jul    10    19:04    /dev/ttyUSB0
   crw-rw----    1    root    plugdev    188,    1    Jul    10    19:04    /dev/ttyUSB1 
```
La interfaz /dev/ttyUSBn con el número más bajo se utiliza para la comunicación JTAG. La otra interfaz se dirige al puerto serie de ESP32 (UART) y se utiliza para cargar el código en la memoria flash del ESP32.
En una ventana de terminal, navegue hasta la raíz de su directorio de descargas de FreeRTOS y utilice el comando siguiente para ejecutar OpenOCD.
```
idf.py openocd 
```
Abra otro terminal, vaya a la raíz del directorio de descargas de FreeRTOS y ejecute el siguiente comando.
```
idf.py flash monitor 
```
Abra otro terminal, vaya a la raíz del directorio de descargas de FreeRTOS y ejecute el siguiente comando:
```
idf.py gdb
```
El programa debe detenerse en main().

Aviso JavaScript está desactivado o no está disponible en su navegador.

Para utilizar la documentación de AWS, debe estar habilitado JavaScript. Para obtener más información, consulte las páginas de ayuda de su navegador.

Convenciones del documento

Microchip ATECC608A Secure Element con simulador de Windows

Introducción a Espressif ESP32-WROOM-32SE

Cómo empezar con el Espressif ESP32- C y el ESP-WROVER-KIT DevKit

importante

nota

nota

Información general

Requisitos previos

Registro para obtener una Cuenta de AWS

Cómo registrarse en una Cuenta de AWS

Crear un usuario administrativo

Protección de su Usuario raíz de la cuenta de AWS

Creación de un usuario administrativo

Cómo iniciar sesión como usuario administrativo

Introducción

nota

importante

importante

importante

Configuración de las aplicaciones de demostración de FreeRTOS

nota

nota

Monitorización de mensajes de MQTT en la nube

Para suscribirse al tema de MQTT con el cliente de MQTT de AWS IoT

Creación, instalación y ejecución del proyecto de demostración de FreeRTOS con el script idf.py

nota

Creación e instalación de FreeRTOS en Windows, Linux y macOS (ESP-IDF v4.2)

nota

Creación e instalación de FreeRTOS con CMake

Para crear e instalar el proyecto

Ejecución de las demostraciones de Bluetooth de bajo consumo

Para configurar la aplicación de demostración del SDK para móviles de Bluetooth de bajo consumo de FreeRTOS

Uso de FreeRTOS en su propio proyecto de CMake para ESP32

Uso de los componentes de FreeRTOS

Adición de componentes personalizados a ESP-IDF

Anulación de las configuraciones para FreeRTOS

Proporcionar su propio sdkconfig para ESP-IDF

Resumen

Solución de problemas

Debugging

Código de depuración en Espressif ESP32- DevKit C y ESP-WROVER-KIT (ESP-IDF v4.2)

Para configurar para la depuración en Windows

nota

nota