Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés. # Cómo empezar con el Espressif ESP32-DevKitC y el ESP-WROVER-KIT **importante** Esta integración de referencia está alojada en el Amazon-FreeRTOS repositorio, que está en desuso. Recomendamos [empezar por aquí](freertos-getting-started-modular.md) al crear un nuevo proyecto. Si ya tiene un proyecto de Freertos existente basado en el Amazon-FreeRTOS repositorio ahora obsoleto, consulte la. [Amazon-FreeRTOS Guía de migración del repositorio de Github](github-repo-migration.md) **nota** Para explorar cómo integrar las bibliotecas modulares y demostraciones de FreeRTOS en su propio proyecto de Espressif IDF, consulte nuestra [destacada](https://www.freertos.org/featured-freertos-iot-integration-targeting-an-espressif-esp32-c3-risc-v-mcu/) integración de referencia para plataformas. ESP32-C3 Sigue este tutorial para empezar a usar el Espressif ESP32-DevKitC equipado con ESP32-WROOM-32, o módulos y el. ESP32-SOLO-1 ESP-WROVER ESP-WROVER-KIT-VB Para comprar uno de nuestros socios en el catálogo de dispositivos AWS asociados, utilice los siguientes enlaces: + [ESP32-WROOM-32 DevKitC](https://devices.amazonaws.com/detail/a3G0L00000AANtjUAH/ESP32-DevKitC) + [ESP32-SOLO-1](https://devices.amazonaws.com/detail/a3G0h0000076lSMEAY) + [ ESP32-WROVER-KIT](https://devices.amazonaws.com/detail/a3G0L00000AANtlUAH/ESP-WROVER-KIT) 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 las versiones [ ESP32-DevKitC ESP-WROVER-KIT V4](https://docs.espressif.com/projects/esp-idf/en/release-v4.2/esp32/hw-reference/modules-and-boards.html#esp32-devkitc-v4) [o 4.1 en el sitio web](https://docs.espressif.com/projects/esp-idf/en/release-v4.2/esp32/hw-reference/modules-and-boards.html#esp-wrover-kit-v4-1) de Espressif. **nota** Actualmente, el puerto Freertos para ESP DevKit C ESP32-WROVER-KIT y ESP no admite la función de multiprocesamiento simétrico (SMP). ## Descripción general de Este tutorial le guiará a través de los siguientes pasos: 1. Conexión de su placa a un equipo host. 1. Instalación de software en el equipo host para desarrollar y depurar las aplicaciones integradas de la placa de su microcontrolador. 1. Compilación cruzada de una aplicación de demostración de FreeRTOS en una imagen binaria. 1. Carga de la imagen binaria de la aplicación en su placa y, a continuación, ejecución de la aplicación. 1. 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 empezar a usar Freertos en tu pizarra Espressif, debes configurar tu cuenta y tus permisos. AWS ### Inscríbase para obtener una Cuenta de AWS Para empezar AWS, necesitas un Cuenta de AWS. Para obtener información sobre cómo crear un Cuenta de AWS, consulte [Cómo empezar con un Cuenta de AWS](https://docs.aws.amazon.com//accounts/latest/reference/getting-started.html) en la *Guía de AWS Account Management referencia*. Para dar acceso, agregue 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](https://docs.aws.amazon.com//singlesignon/latest/userguide/howtocreatepermissionset.html) en la *Guía del usuario de AWS IAM Identity Center *. + Usuarios gestionados en IAM a través de un proveedor de identidades: Cree un rol para la federación de identidades. Siga las instrucciones descritas en [Creación de un rol para un proveedor de identidad de terceros (federación)](https://docs.aws.amazon.com//IAM/latest/UserGuide/id_roles_create_for-idp.html) 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](https://docs.aws.amazon.com//IAM/latest/UserGuide/id_roles_create_for-user.html) en la *Guía del usuario de IAM*. + (No recomendado) Adjunte una política directamente a un usuario o agregue un usuario a un grupo de usuarios. Siga las instrucciones descritas en [Adición de permisos a un usuario (consola)](https://docs.aws.amazon.com//IAM/latest/UserGuide/id_users_change-permissions.html#users_change_permissions-add-console) 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. 1. **Configure el hardware de Espressif.** + Para obtener información sobre cómo configurar el hardware de la placa de ESP32-DevKitC desarrollo, consulte la [Guía de ESP32-DevKitC introducción a](https://docs.espressif.com/projects/esp-idf/en/release-v4.2/esp32/hw-reference/esp32/get-started-devkitc.html) la versión 4. + Para obtener información sobre cómo configurar el hardware de la placa de ESP-WROVER-KIT desarrollo, consulte la [ ESP-WROVER-KIT V4.1 Guía de introducción](https://docs.espressif.com/projects/esp-idf/en/release-v4.2/esp32/hw-reference/esp32/get-started-wrover-kit.html). **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. 1. Descargue Amazon FreeRTOS desde. [GitHub](https://github.com/aws/amazon-freertos) (Para obtener instrucciones, consulte el [README.md](https://github.com/aws/amazon-freertos/blob/main/README.md)archivo). 1. **Configure el entorno de desarrollo**. Debe instalar una cadena de herramientas para comunicarse con la placa. Espressif proporciona el software necesario ESP-IDF para desarrollar sus placas. Dado que ESP-IDF tiene su propia versión del núcleo de FreeRTOS integrada como componente, Amazon FreeRTOS incluye una versión personalizada de la versión 4.2 en la que se ha eliminado ESP-IDF el núcleo de FreeRTOS. Esto soluciona los problemas relacionados con los archivos duplicados al compilar. Para usar la versión personalizada de la ESP-IDF versión 4.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 ESP-IDF el [instalador universal en línea para Windows](https://dl.espressif.com/dl/esp-idf/?idf=4.2). 1. Ejecute el **instalador en línea universal**. 1. Cuando llegues al paso **Descargar o usar ESP-IDF**, selecciona **Usar un ESP-IDF directorio existente** y establece **Elegir ESP-IDF directorio existente** en`{{freertos}}/vendors/espressif/esp-idf`. 1. Complete la instalación. **macOS** 1. Siga las instrucciones de la [configuración estándar de los requisitos previos de la cadena de herramientas (ESP-IDF v4.2) para macOS](https://docs.espressif.com/projects/esp-idf/en/release-v4.2/esp32/get-started/macos-setup.html). **importante** Cuando llegue a las instrucciones «Obtener ESP-IDF» de la sección **Próximos pasos**, deténgase y, a continuación, vuelva a las instrucciones de esta página. 1. Abra una ventana de línea de comandos. 1. 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 ``` 1. Añada las ESP-IDF herramientas de la cadena de herramientas a la ruta de su terminal con el siguiente comando. ``` source vendors/espressif/esp-idf/export.sh ``` **Linux** 1. Siga las instrucciones de la [configuración estándar de los requisitos previos de la cadena de herramientas (ESP-IDF v4.2](https://docs.espressif.com/projects/esp-idf/en/release-v4.2/esp32/get-started/linux-setup.html)) para Linux. **importante** Cuando llegue a las instrucciones «Obtener ESP-IDF» de la sección «**Próximos pasos**», deténgase y, a continuación, vuelva a las instrucciones de esta página. 1. Abra una ventana de línea de comandos. 1. 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 ``` 1. Añada las ESP-IDF herramientas de la cadena de herramientas a la ruta de su terminal con el siguiente comando. ``` source vendors/espressif/esp-idf/export.sh ``` 1. **Establezca una conexión serie.** 1. Para establecer una conexión en serie entre su máquina host y la ESP32-DevKitC, debe instalar los controladores VCP USB a UART Bridge del CP210x. Puede descargar estos controladores de [Silicon Labs](https://www.silabs.com/products/development-tools/software/usb-to-uart-bridge-vcp-drivers). Para establecer una conexión en serie entre su máquina host y la ESP32-WROVER-KIT, debe instalar el controlador de puerto COM virtual FTDI. Puede descargar este controlador desde [FTDI](https://www.ftdichip.com/Drivers/VCP.htm). 1. Siga los pasos para [ Establecer una conexión serie con ESP32](https://docs.espressif.com/projects/esp-idf/en/release-v4.2/esp32/get-started/establish-serial-connection.html). 1. 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`). 1. 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 ESP-IDF cadena de herramientas) o la aplicación «Command Prompt» en caso contrario. 1. 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](https://www.python.org/downloads/). 1. Necesita la interfaz de línea de AWS comandos (CLI) para ejecutar AWS IoT los comandos. Si ejecuta Windows, utilice el `easy_install awscli` comando para instalar la AWS CLI en la aplicación «Command» o «ESP-IDF 4.x CMD». Si utilizas macOS o Linux, consulta [Instalación de la AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/installing.html). 1. Ejecutar ``` aws configure ``` y configure la AWS CLI con su AWS ID de clave de acceso, clave de acceso secreta y AWS región predeterminada. Para obtener más información, consulte [Configuración de la CLI de AWS](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-started.html). 1. Usa el siguiente comando para instalar el AWS SDK para Python (boto3): + En Windows, en la aplicación «Command» o «ESP-IDF 4.x CMD», ejecute ``` pip install boto3 --user ``` **nota** Consulte la [Documentación de Boto3](https://boto3.amazonaws.com/v1/documentation/api/latest/guide/quickstart.html) 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 quieres asignar a la AWS IoT cosa que representa tu tablero. **`wifi_ssid`** El SSID de su Wi-Fi red. **`wifi_password`** La contraseña de su Wi-Fi red. **`wifi_security`** El tipo de seguridad de Wi-Fi la red. Los siguientes son tipos de seguridad válidos: + `eWiFiSecurityOpen` (abierta, sin seguridad) + `eWiFiSecurityWEP` (seguridad WEP) + `eWiFiSecurityWPA` (seguridad WPA) + `eWiFiSecurityWPA2` (seguridad WPA2) 1. Ejecute el script de configuración. 1. Si ejecuta macOS o Linux, abra un símbolo del terminal. Si utilizas Windows, abre la aplicación «ESP-IDF 4.x CMD» o «Command». 1. 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 `aws_clientcredential.h` archivo con el AWS IoT punto de conexión, el Wi-Fi SSID 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 está codificado únicamente con fines de demostración. Production-level las aplicaciones 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 MQTT en la AWS IoT consola para supervisar los mensajes que su dispositivo envía a la nube. AWS **Para suscribirse al tema MQTT con el AWS IoT Cliente MQTT** 1. Vaya a la [consola de AWS IoT](https://console.aws.amazon.com/iotv2/). 1. En el panel de navegación, seleccione **Probar** y, a continuación, seleccione el **cliente de prueba MQTT**. 1. 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 ``` **Cree y actualice FreeRTOS en Windows, Linux y macOS (ESP-IDF v4.2)** 1. Desplácese hasta la raíz del directorio de descargas de FreeRTOS. 1. En una ventana de línea de comandos, introduce el siguiente comando para añadir ESP-IDF las herramientas a la ruta de tu 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 ``` 1. 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. 1. Borre la memoria flash de la placa de desarrollo con el siguiente comando. ``` idf.py erase_flash ``` 1. Utilice el script `idf.py` para instalar el archivo binario de la aplicación en la placa. ``` idf.py flash ``` 1. 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. **Creación e instalación del proyecto** 1. En una ventana de línea de comandos, navegue hasta el directorio de descargas de FreeRTOS. 1. Ejecute el siguiente script para añadir las ESP-IDF herramientas al PATH de su shell. **Windows** ``` vendors\espressif\esp-idf\export.bat ``` **Linux/macOS** ``` source vendors/espressif/esp-idf/export.sh ``` 1. 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 ``` 1. Compilar el proyecto. **Con Unix Makefiles** ``` make -C ./YOUR_BUILD_DIRECTORY -j8 ``` **Con Ninja** ``` ninja -C ./YOUR_BUILD_DIRECTORY -j8 ``` 1. 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](freertos-ble-library.md). 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. **Configuración de la aplicación de demostración del SDK para móviles de Bluetooth de bajo consumo de FreeRTOS** 1. Siga las instrucciones de [SDK para móviles para dispositivos Bluetooth de FreeRTOS](freertos-ble-mobile.md) para descargar e instalar los SDK para su plataforma móvil en su equipo host. 1. Siga las instrucciones en [Aplicación de demostración de SDK para móviles de Bluetooth de bajo consumo de FreeRTOS](ble-demo.md#ble-sdk-app) 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](ble-demo.md#ble-demo-mqtt). Para obtener instrucciones sobre cómo ejecutar la demostración de Wi-Fi aprovisionamiento en tu placa, consulta[Wi-Fi aprovisionamiento](ble-demo.md#ble-demo-wifi). ## 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](https://github.com/aws/amazon-freertos) 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 "/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.). ### Añada componentes personalizados mediante ESP-IDF Puede añadir más componentes mientras los usa 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 [Project Configuration](https://docs.espressif.com/projects/esp-idf/en/v4.2-beta1/esp32s2/api-reference/kconfig.html) en la *Referencia de la API* de Espressif y, si encuentra problemas después de haber compilado correctamente, consulte la sección [Deprecated options and their replacements](https://docs.espressif.com/projects/esp-idf/en/v4.2-beta1/esp32s2/api-reference/kconfig.html#deprecated-options-and-their-replacements) 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) ``` ## Resolución de problemas + Si utilizas macOS y el sistema operativo no te reconoce ESP-WROVER-KIT, asegúrate de no tener instalados los controladores D2XX. Para desinstalarlos, siga las instrucciones de la [guía de instalación de controladores FTDI para macOS X](http://www.ftdichip.com/Support/Documents/AppNotes/AN_134_FTDI_Drivers_Installation_Guide_for_MAC_OSX.pdf). + La utilidad de monitorización proporcionada por ESP-IDF (e invocada mediante make monitor) te ayuda a decodificar 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](https://docs.espressif.com/projects/esp-idf/en/release-v4.2/esp32/api-guides/tools/idf-monitor.html#automatic-address-decoding) 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](https://docs.espressif.com/projects/esp-idf/en/release-v4.2/esp32/api-guides/tools/idf-monitor.html#launching-gdb-with-gdbstub) en el sitio web de Espressif. + Para obtener información sobre cómo configurar un OpenOCD-based entorno si se requiere una depuración JTAG basada en hardware, consulte la depuración de [JTAG](https://docs.espressif.com/projects/esp-idf/en/latest/esp32/api-guides/jtag-debugging/index.html) en el sitio web de Espressif. + Si no es posible instalar `pyserial` utilizando `pip` en macOS, descárguelo del [sitio web de pyserial](https://pypi.org/simple/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 obligatorias de ESP-IDF están incluidas en FreeRTOS, por lo que no es necesario descargarlas externamente. 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 su dispositivo tiene problemas para conectarse AWS IoT, abra el `aws_clientcredential.h` archivo y compruebe que las variables de configuración estén definidas correctamente en el archivo. `clientcredentialMQTT_BROKER_ENDPOINT[]`debería tener este aspecto`1234567890123-ats.iot.us-east-1.amazonaws.com`. + Si sigue los pasos de [Uso de FreeRTOS en su propio proyecto de CMake para ESP32](#getting_started_espressif_cmake_project) 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`. + ESP-IDF La versión 4.2 admite el uso de la *xtensa\\ -esp32\\ -elf\\ -gcc 8\\ .2\\ .0\\*. cadena de herramientas. Si utiliza una versión anterior de la cadena de herramientas de Xtensa, descargue la versión necesaria. + Si ves un registro de errores como el siguiente sobre las dependencias de Python que no se cumplen en la versión 4.2: 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](gsg-troubleshooting.md). ## Debugging ### Código de depuración en ESP32-DevKitC Espressif y (v4.2) ESP-WROVER-KIT ESP-IDF En esta sección, se muestra cómo depurar el hardware de Espressif mediante la versión 4.2. ESP-IDF Necesita un cable que vaya de JTAG al USB. [Usamos un cable USB a MPSSE (por ejemplo, el FTDI). C232HM-DDHSL-0](http://www.ftdichip.com/Products/Cables/USBMPSSE.htm) **ESP-DevKitC Configuración JTAG** Para el C232HM-DDHSL-0 cable FTDI, estas son 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 | ``` **ESP-WROVER-KIT Configuración de JTAG** Para el C232HM-DDHSL-0 cable FTDI, estas son 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 desarrollaron a partir de la hoja de datos del [FTDI C232HM-DDHSL-0 ](https://www.ftdichip.com/Support/Documents/DataSheets/Cables/DS_C232HM_MPSSE_CABLE.pdf). 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 activar el JTAG en ESP-WROVER-KIT, coloque puentes en los pines TMS, TDO, TDI, TCK y S\_TDI, tal y como se muestra aquí. ![Colocación del puente](http://docs.aws.amazon.com/es_es/freertos/latest/userguide/images/JP8-jumpers.png) **Depuración en Windows (v4.2) ESP-IDF ** **Configuración para la depuración en Windows** 1. Conecte el lado USB del FTDI C232HM-DDHSL-0 al ordenador y el otro lado como se describe en[Código de depuración en ESP32-DevKitC Espressif y (v4.2) ESP-WROVER-KIT ESP-IDF](#debugging-espressif-idf42). El C232HM-DDHSL-0 dispositivo FTDI debería aparecer en el **Administrador de dispositivos**, en la sección Controladores de **bus serie universales**. 1. En la lista de dispositivos de bus serie universales, haga clic con el botón secundario en el **C232HM-DDHSL-0**dispositivo y, a continuación, seleccione **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 FTDI C232HM-DDHSL-0](http://www.ftdichip.com/Drivers/D2XX.htm). 1. 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 ``` 1. Descargue [OpenOCD para Windows](https://github.com/espressif/openocd-esp32/releases). 1. Descomprima el archivo en `C:\` y añada `C:\openocd-esp32\bin` a la ruta del sistema. 1. OpenOCD requiere libusb, que no está instalado de forma predeterminada en Windows. Para instalar libusb: 1. Descargue [zadig.exe](https://zadig.akeo.ie). 1. Ejecute `zadig.exe`. Desde el menú **Options (Opciones)**, seleccione **List All Devices (Lista de todos los dispositivos)**. 1. En el menú desplegable, selecciona. **C232HM-DDHSL-0** 1. En el campo del controlador de destino, que se encuentra a la derecha de la flecha verde, elija **WinUSB**. 1. 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)**. 1. 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. 1. Abra un nuevo símbolo del sistema, vaya a la raíz del directorio de descargas de FreeRTOS y ejecute ``` idf.py flash monitor ``` 1. 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)** 1. Descargue el [controlador FTDI para macOS](http://www.ftdichip.com/Drivers/VCP.htm). 1. Descargue [OpenOCD](https://github.com/espressif/openocd-esp32/releases). 1. Extraiga el archivo.tar descargado y establezca la ruta de `.bash_profile` en `OCD_INSTALL_DIR/openocd-esp32/bin`. 1. Utilice el siguiente comando para instalar `libusb` en macOS. ``` brew install libusb ``` 1. Utilice el siguiente comando para descargar el controlador de puerto serie. ``` sudo kextunload -b com.FTDI.driver.FTDIUSBSerialDriver ``` 1. Utilice el siguiente comando para descargar el controlador de puerto serie. ``` sudo kextunload -b com.FTDI.driver.FTDIUSBSerialDriver ``` 1. 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 ``` 1. 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) ``` 1. 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. 1. 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. 1. Abra un nuevo terminal y utilice el siguiente comando para cargar el controlador de puerto serie FTDI. ``` sudo kextload -b com.FTDI.driver.FTDIUSBSerialDriver ``` 1. Desplácese hasta la raíz del directorio de descargas de FreeRTOS y ejecute ``` idf.py flash monitor ``` 1. 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 (v4.2) ESP-IDF ** 1. Descargue [OpenOCD](https://github.com/espressif/openocd-esp32/releases). Extraiga el archivo tarball y siga las instrucciones de instalación en el archivo readme. 1. Para instalar libusb en Linux, use el siguiente comando. ``` sudo apt-get install libusb-1.0 ``` 1. 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 ``` 1. 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. 1. 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 ``` 1. Abra otro terminal, vaya a la raíz del directorio de descargas de FreeRTOS y ejecute el siguiente comando. ``` idf.py flash monitor ``` 1. 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()`.