Descripción general Requisitos previos Introducción a ESP-IDF v3.3 Introducción a ESP-IDF v4.2 Monitorización de mensajes de MQTT en la nube Ejecución de las demostraciones de Bluetooth de bajo consumo Uso de Freertos en su propio CMake proyecto para ESP32 Solución de problemas Debugging

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

importante

Esta es una versión archivada de la Guía del usuario de FreeRTOS para su uso con la versión 202012.00 de FreeRTOS. Para obtener la última versión de este documento, consulte la Guía del usuario de FreeRTOS.

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

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

Para obtener más información sobre las últimas versiones de estas placas, consulte ESP32- DevKit C V4 o ESP-WROVER-KITv4.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).

Descripción general

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

Conexión de su placa a una máquina 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 empezar a usar Freertos en tu pizarra Espressif, debes configurar tu cuenta y tus permisos. AWS

Si no tiene uno Cuenta de AWS, complete los siguientes pasos para crearlo.

Para suscribirte a una Cuenta de AWS

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

Parte del procedimiento de registro implica recibir una llamada telefónica o un mensaje de texto e introducir un código de verificación en el teclado del teléfono.

Cuando te registras en un Cuenta de AWS, Usuario raíz de la cuenta de AWSse crea un. 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 y utilice únicamente el usuario raíz para realizar tareas que requieren acceso de usuario raíz.

AWS te envía un correo electrónico de confirmación una vez finalizado el proceso de registro. En cualquier momento, puede ver la actividad de su cuenta actual y administrarla accediendo a https://aws.amazon.com/y seleccionando Mi cuenta.

Creación de un usuario con acceso administrativo

Después de crear un usuario administrativo Cuenta de AWS, asegúrelo Usuario raíz de la cuenta de AWS AWS IAM Identity Center, habilite y cree un usuario administrativo para no usar el usuario root en las tareas diarias.

Proteja su Usuario raíz de la cuenta de AWS

Inicie sesión AWS Management Consolecomo propietario de la cuenta seleccionando el usuario root e introduciendo su dirección de Cuenta de AWS correo electrónico. En la siguiente página, escriba su contraseña.

Para obtener ayuda para iniciar sesión con el usuario raíz, consulte Iniciar sesión como usuario raíz 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 Cuenta de AWS raíz (consola) en la Guía del usuario de IAM.

Creación de un usuario con acceso administrativo

Activar IAM Identity Center.

Consulte las instrucciones en Activar AWS IAM Identity Center en la Guía del usuario de AWS IAM Identity Center .
En IAM Identity Center, conceda acceso administrativo a un usuario.

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

Inicio de sesión como usuario con acceso de administrador

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

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

Concesión de acceso a usuarios adicionales

En IAM Identity Center, cree un conjunto de permisos que siga la práctica recomendada de aplicar permisos de privilegios mínimos.

Para conocer las instrucciones, consulte Create a permission set en la Guía del usuario de AWS IAM Identity Center .
Asigne usuarios a un grupo y, a continuación, asigne el acceso de inicio de sesión único al grupo.

Para conocer las instrucciones, consulte Add groups en la Guía del usuario de AWS IAM Identity Center .

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 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) 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) Adjunte 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.

nota

La versión FreeRTOS 202012.00 es compatible con ESP-IDF v3.3. Si utilizas una versión posterior de FreeRTOS, sigue las instrucciones específicas de IDFv4 .2 at. Introducción a ESP-IDF v4.2

Introducción a ESP-IDF v3.3

En esta sección se muestra cómo utilizar la versión 3.3 de ESP-IDF en el hardware de Espressif. Para utilizar la versión 4.2 de ESP-IDF, consulte Introducción a ESP-IDF v4.2.

Configuración del hardware Espressif

Para obtener más información sobre cómo configurar el hardware de la placa de desarrollo ESP32 - DevKit C, consulte la Guía de introducción a ESP32 - DevKit C V4.

Para obtener información sobre la configuración del hardware de la placa de ESP-WROVER-KIT desarrollo, consulte la Guía de introducción a la ESP-WROVER-KIT versión 4.1.

importante

Cuando llegue a la sección Introducción de la guía de Espressif, deténgase y siga los pasos que se indican a continuación.

Cómo configurar el entorno de desarrollo.

Debe descargar e instalar una cadena de herramientas para comunicarse con la placa.

Configuración de la cadena de herramientas

nota

La versión 3.3 de ESP-IDF no es compatible con la última versión del compilador. ESP32 Si ya ha instalado la última versión del ESP32 compilador, debe desinstalarla y utilizar la versión compatible del compilador que se incluye en la instalación de la cadena de herramientas. Consulte los enlaces de esta sección. Para comprobar la versión del compilador, ejecute el siguiente comando.


xtensa-esp32-elf-gcc --version

Para configurar la cadena de herramientas, siga las instrucciones correspondientes al sistema operativo de su máquina host:

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.

Si ha seguido las instrucciones de “Obtención de ESP-IDF” de la sección Siguientes pasos, justo ahora o en una ocasión anterior, debería borrar la variable de entorno IDF_PATH de su sistema antes de continuar. Esta variable de entorno se estableció automáticamente si siguió las instrucciones de “Obtención de ESP-IDF”.

Instalar CMake

El sistema de CMake compilación es necesario para crear las aplicaciones de demostración y prueba de FreeRTOS para este dispositivo. FreeRTOS admite las versiones 3.13 y posteriores.

Puede descargar la última versión de CMake desde CMake.org. Están disponibles tanto el código fuente como las distribuciones binarias.

Para obtener más información sobre el uso CMake con Freertos, consulte. Uso CMake con Freertos

Establecimiento de una conexión serie

Para establecer una conexión en serie entre su máquina host y la unidad ESP32 - DevKit C, debe instalar los controladores CP21 VCP 0x USB to UART Bridge. Puede descargar estos controladores de Silicon Labs.

Para establecer una conexión en serie entre su máquina host y el ESP32 -WROVER-KIT, debe instalar algunos controladores de puerto COM virtuales FTDI. Puede descargar el controlador desde FTDI.

Para obtener más información, consulte Establecer una conexión en serie con. ESP32 Después de establecer una conexión serie, anote el puerto serie de la conexión de la placa. Lo necesitará cuando compile la demostración.

Descarga y configuración de FreeRTOS

Tras configurar el entorno, puede descargar FreeRTOS desde. GitHubPara obtener instrucciones, consulte el archivo README.md en el sitio web. GitHub

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

Si ejecuta macOS o Linux, abra un símbolo del terminal. Si ejecuta Windows, abra mingw32.exe. MinGW es un entorno de desarrollo minimalista para aplicaciones nativas de Microsoft Windows.
Para verificar que tiene instalado Python 2.7.10 o una versión posterior, ejecute
```
python --version
```
Se muestra la versión instalada. Si no tiene instalado Python 2.7.10 o una versión posterior, puede instalarlo desde el sitio web de Python.
Necesita el AWS Command Line Interface () para ejecutar los comandos AWS CLI. AWS IoT Si utilizas Windows, úsalo easy_install awscli para instalarlo AWS CLI en el entorno mingw32.

Si ejecuta macOS o Linux, consulte Instalación de la AWS CLI.
Ejecútelo aws configure y configúrelo AWS CLI con su ID de clave de AWS acceso, clave de acceso secreta y AWS región. Para obtener más información, consulte Configuración de la AWS CLI.
Usa el siguiente comando para instalar el AWS SDK para Python (boto3):
- En Windows, en el entorno mingw32, ejecute
```
easy_install boto3
```
- 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 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(WPA2 seguridad)

Ejecución del script de configuración

Si ejecuta macOS o Linux, abra un símbolo del terminal. Si ejecuta Windows, abra mingw32.exe.
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 para el certificado y el certificado al objeto de AWS IoT
Rellena el aws_clientcredential.h archivo con el AWS IoT terminal, el SSID de la red inalámbrica 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.

Creación, instalación y ejecución del proyecto de demostración de FreeRTOS

Puede utilizarlos CMake para generar los archivos de compilación, Make para compilar el binario de la aplicación y la utilidad IDF de Espressif para flashear su placa.

Creación de FreeRTOS en Linux y macOS (ESP-IDF v3.3)

Si usa Windows, consulte Creación de FreeRTOS en Windows (ESP-IDF v3.3).

Se usa CMake para generar los archivos de compilación y, a continuación, se usa Make para compilar la aplicación.

Para generar los archivos de compilación de la aplicación de demostración con CMake

Cambie los directorios a la raíz de su directorio de descargas de FreeRTOS.
Utilice el siguiente comando para generar los archivos de creación.
```
cmake -DVENDOR=espressif -DBOARD=esp32_wrover_kit -DCOMPILER=xtensa-esp32 -S . -B your-build-directory 
```
nota
Si desea compilar la aplicación para la depuración, añada la marca -DCMAKE_BUILD_TYPE=Debug a este comando.
Si desea generar los archivos de compilación de la aplicación de prueba, añada la marca -DAFR_ENABLE_TESTS=1.
El código proporcionado por Espressif utiliza la pila de IP ligera (lwIP) como pila de red predeterminada. Para usar la pila de redes FreeRTOS+TCP en su lugar, añada la –DAFR_ESP_FREERTOS_TCP marca al comando. CMake
Para añadir la dependencia de LWiP para el código no proporcionado por el proveedor, añada las siguientes líneas CMake al archivo de dependenciasCMakeLists.txt, para su componente Wi-Fi personalizado.
```
# Add a dependency on the bluetooth espressif component to the common component
set(COMPONENT_REQUIRES lwip)
```

Creación de la aplicación con Make

Cambie los directorios al directorios build.
Utilice el siguiente comando para crear la aplicación con Make.
```
make all -j4
```
nota
Debe generar los archivos de compilación con el comando cmake cada vez que cambie entre el proyecto aws_demos y el proyecto aws_tests.

Creación de FreeRTOS en Windows (ESP-IDF v3.3)

En Windows, debe especificar un generador de compilaciones para. CMake De lo contrario, el CMake valor predeterminado es Visual Studio. Espressif recomienda oficialmente el sistema de compilación Ninja porque funciona en Windows, Linux y MacOS. Debe ejecutar CMake los comandos en un entorno nativo de Windows, como cmd o. PowerShell No se admite la ejecución de CMake comandos en un entorno Linux virtual, como MSYS2 WSL.

CMake Utilícelo para generar los archivos de compilación y, a continuación, utilice Make para compilar la aplicación.

Para generar los archivos de compilación de la aplicación de demostración con CMake

Cambie los directorios a la raíz de su directorio de descargas de FreeRTOS.
Utilice el siguiente comando para generar los archivos de creación.
```
cmake -DVENDOR=espressif -DBOARD=esp32_wrover_kit -DCOMPILER=xtensa-esp32 -GNinja -S . -B build-directory
```
nota
Si desea compilar la aplicación para la depuración, añada la marca -DCMAKE_BUILD_TYPE=Debug a este comando.
Si desea generar los archivos de compilación de la aplicación de prueba, añada la marca -DAFR_ENABLE_TESTS=1.
El código proporcionado por Espressif utiliza la pila de IP ligera (lwIP) como pila de red predeterminada. Para usar la pila de redes FreeRTOS+TCP en su lugar, añada la –DAFR_ESP_FREERTOS_TCP marca al comando. CMake
Para añadir la dependencia de LWiP para el código no proporcionado por el proveedor, añada las siguientes líneas CMake al archivo de dependenciasCMakeLists.txt, para su componente Wi-Fi personalizado.
```
# Add a dependency on the bluetooth espressif component to the common component
set(COMPONENT_REQUIRES lwip)
```

Creación de la aplicación

Cambie los directorios al directorios build.
Invoque Ninja para crear la aplicación.
```
ninja
```
O bien, utilice la CMake interfaz genérica para crear la aplicación.
```
cmake --build build-directory
```
nota
Debe generar los archivos de compilación con el comando cmake cada vez que cambie entre el proyecto aws_demos y el proyecto aws_tests.

Instalación y ejecución de FreeRTOS (ESP-IDF v3.3)

En esta sección se muestra cómo utilizar la versión 3.3 de ESP-IDF en el hardware de Espressif. Para utilizar la versión 4.2 de ESP-IDF, consulte Introducción a ESP-IDF v4.2.

Use la utilidad IDF de Espressif (freertos/vendors/espressif/esp-idf/tools/idf.py) para instalar la placa, ejecutar la aplicación y ver los registros.

Para borrar la instalación de la placa, vaya al directorio freertos y utilice el siguiente comando.


./vendors/espressif/esp-idf/tools/idf.py erase_flash -B build-directory

Para instalar el archivo binario de la aplicación en la placa, utilice make.


make flash

También puede utilizar el script de IDF para actualizar la placa:


./vendors/espressif/esp-idf/tools/idf.py flash -B build-directory

Para la monitorización:


./vendors/espressif/esp-idf/tools/idf.py monitor -p /dev/ttyUSB1 -B build-directory

nota

Puede combinar estos comandos. Por ejemplo:


./vendors/espressif/esp-idf/tools/idf.py erase_flash flash monitor -p /dev/ttyUSB1 -B build-directory

Introducción a 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. Para utilizar la versión 3.3 de ESP-IDF, consulte Introducción a ESP-IDF v3.3.

nota

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

Configuración del hardware Espressif

Para obtener información sobre la configuración del ESP32 hardware de la placa de desarrollo DevKit C, consulte la ESP32Guía de introducción a la DevKit C V4.

Para obtener información sobre cómo configurar el hardware de la placa de ESP-WROVER-KIT desarrollo, consulte la Guía de ESP-WROVER-KIT introducción a la versión 4.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.

Cómo configurar el entorno de desarrollo.

Debe descargar e instalar una cadena de herramientas para comunicarse con la placa.

Configuración de la cadena de herramientas

Para configurar la cadena de herramientas, siga las instrucciones correspondientes al sistema operativo de su máquina host:

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.

Finalización de la instalación (Linux o MacOS)

El instalador ESP-IDF para Windows instala todas las herramientas necesarias. Las plataformas Linux y MacOS requieren un paso adicional para completar la instalación.

Abra una ventana de línea de comandos
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
```
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
```

Establecimiento de una conexión serie

Para establecer una conexión en serie entre su máquina host y la unidad ESP32 - DevKit C, debe instalar los controladores CP21 0x USB to UART Bridge VCP. Puede descargar estos controladores de Silicon Labs.

Para establecer una conexión en serie entre su máquina host y el ESP32 -WROVER-KIT, debe instalar el controlador del puerto COM virtual FTDI. Puede descargar este controlador desde FTDI.

Descarga y configuración de FreeRTOS

Después de configurar el entorno, puede descargar FreeRTOS desde. GitHub Para obtener instrucciones, consulte el archivo README.md en el sitio web. GitHub

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

Si ejecuta macOS o Linux, abra un símbolo del terminal. Si ejecuta Windows, abra mingw32.exe. ( MinGW es un entorno de desarrollo minimalista para aplicaciones nativas de Microsoft Windows).
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 el AWS Command Line Interface (AWS CLI) para ejecutar los comandos. AWS IoT Si utilizas Windows, úsalo easy_install awscli para instalarlo AWS CLI en el entorno mingw32.

Si ejecuta macOS o Linux, consulte Instalación de la AWS CLI.
Ejecute
```
aws configure
```
y configúrelo AWS CLI con su ID de clave de AWS acceso, clave de acceso secreta y región predeterminada AWS . Para obtener más información, consulte Configuración de la AWS CLI.
Usa el siguiente comando para instalar el AWS SDK para Python (boto3):
- En Windows, en el entorno mingw32, ejecute
```
easy_install boto3
```
- En macOS o Linux, ejecute
```
pip install tornado nose --user
```
  y, a continuación, ejecute
```
pip install boto3 --user
```

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 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(WPA2 seguridad)

Ejecución del script de configuración

Si ejecuta macOS o Linux, abra un símbolo del terminal. Si ejecuta Windows, abra el archivo mingw32.exe.
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 para el certificado y el certificado al objeto de AWS IoT
Rellena el aws_clientcredential.h archivo con el AWS IoT terminal, el SSID de la red inalámbrica 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.

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

Puede utilizar la utilidad IDF de Espressif para generar los archivos de creación, crear el binario de la aplicación e instalar la placa.

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

Use el script 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 del proyecto

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
```
vendors\espressif\esp-idf\export.bat
```
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

nota

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

Cree y flashee Freertos con CMake

Además del idf.py script que proporciona el SDK de IDF para compilar y ejecutar el código, también puede compilar el proyecto con CMake él. Actualmente es compatible con Unix Makefiles y el sistema de creación Ninja.

Creación e instalación del 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

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

Monitorización de mensajes de MQTT en la nube

Puede usar el cliente MQTT de la AWS IoT consola para monitorear los mensajes que su dispositivo envía a la AWS nube.

Para suscribirse al tema MQTT con el AWS IoT cliente MQTT

Vaya a la consola de AWS IoT.
En el panel de navegación principal, elija Test (Pruebas) para abrir el cliente de MQTT.
En Tema de suscripción, escriba your-thing-name/example/topic y, a continuación, elija Suscribirse al tema.

Ejecución de las demostraciones de Bluetooth de bajo consumo

FreeRTOS admite conectividad con 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.

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

Siga las instrucciones de Mobile SDKs for FreeRTOS Bluetooth Devices para descargar e instalar el SDK para su plataforma móvil en su ordenador host.
Siga las instrucciones de Aplicación de demostración del SDK para móviles de Bluetooth de bajo consumo de FreeRTOS para configurar la aplicación de demostración para móviles en su dispositivo móvil.

Para obtener instrucciones sobre cómo ejecutar la demostración de MQTT sobre Bluetooth de bajo consumo en la placa, consulte Aplicación de demostración de 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 Aplicación de demostración de aprovisionamiento wifi.

Uso de Freertos en su propio CMake proyecto para ESP32

Si quieres usar Freertos en tu propio CMake proyecto, puedes configurarlo como un subdirectorio y compilarlo junto con tu 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.

Para compilar el proyecto, ejecute los siguientes CMake comandos. Asegúrese de que el ESP32 compilador 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

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


cmake --build build-directory --target flash

Uso de los componentes de FreeRTOS

Tras ejecutarlo CMake, podrá encontrar todos los componentes disponibles en el resultado resumido. Debería parecerse al siguiente ejemplo.


====================Configuration for FreeRTOS====================
  Version:                 201910.00
  Git version:             201910.00-388-gcb3612cb7

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:        ble, ble_hal, ble_wifi_provisioning, common, crypto, defender,
                           dev_mode_key_provisioning, freertos_plus_tcp, greengrass,
                           https, kernel, mqtt, ota, pkcs11, pkcs11_implementation,
                           platform, secure_sockets, serializer, shadow, tls, wifi
  Enabled by user:         ble, ble_hal, ble_wifi_provisioning, defender, greengrass,
                           https, mqtt, ota, pkcs11, pkcs11_implementation, platform,
                           secure_sockets, shadow, wifi
  Enabled by dependency:   common, crypto, demo_base, dev_mode_key_provisioning,
                           freertos, freertos_plus_tcp, kernel, pkcs11_mbedtls,
                           secure_sockets_freertos_plus_tcp, serializer, tls, utils
  3rdparty dependencies:   http_parser, jsmn, mbedtls, pkcs11, tinycbor
  Available demos:         demo_ble, demo_ble_numeric_comparison, demo_defender,
                           demo_greengrass_connectivity, demo_https, demo_mqtt, demo_ota,
                           demo_shadow, demo_tcp, demo_wifi_provisioning
  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::mqtt, AFR::ota, etc.).

Añadir componentes personalizados a ESP-IDF

Puede añadir más componentes al entorno de compilación de 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.

También puede especificar las dependencias mediante la CMake función estándar. target_link_libraries Tenga en cuenta que el nombre de destino del componente se almacena en la variable COMPONENT_TARGET, definida por el ESP-IDF.

En el caso de los componentes de ESP, esto se hace estableciendo dos variables: COMPONENT_REQUIRES y COMPONENT_PRIV_REQUIRES. Consulte Build System (CMake) en la Guía de programación del ESP-IDF, versión 4.2.

A continuación, en el archivo CMakeLists.txt de nivel superior, indique a ESP-IDF dónde encontrar estos componentes. Añada las siguientes líneas en cualquier lugar delante de add_subdirectory(freertos).

Este componente ahora se vincula automáticamente al código de la aplicación de forma predeterminada. Debería poder 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 y. freertos/vendors/espressif/boards/esp32/aws_demos/config_files/ 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 quieras proporcionar la tuya propiasdkconfig.default, puedes configurar la CMake variableIDF_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.

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.

ESP-IDF v3.3


cmake_minimum_required(VERSION 3.13)

project(freertos_examples)

add_executable(my_app 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::mqtt)

ESP-IDF v4.2


cmake_minimum_required(VERSION 3.13)

project(freertos_examples)

# Pull in ESP-IDF defined CMake build infrastructure logic to configure the project, discover all the components, etc
set(esp_idf_dir "${CMAKE_CURRENT_LIST_DIR}/freertos/vendors/espressif/esp-idf")
include(${esp_idf_dir}/tools/cmake/idf.cmake)
# Tell IDF build to link against this target.
set(IDF_PROJECT_EXECUTABLE my_app)
get_filename_component(
    IDF_EXECUTABLE_SRCS
    "src/main.c" ABSOLUTE
    )
# Add some extra components. IDF_EXTRA_COMPONENT_DIRS is an variable used by ESP-IDF
# to collect extra components.
get_filename_component(
    EXTRA_COMPONENT_DIRS
    "components/foo" ABSOLUTE
)
idf_build_component(${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::mqtt)

Para obtener más información sobre el sistema de compilación de Espressif con CMake, consulte Build System en las guías de API de Espressif

Solució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.
La utilidad de monitoreo proporcionada por ESP-IDF (e invocada mediante make monitor) 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 la comunicación con gdb sin necesidad de ningún hardware JTAG especial. Para obtener más información, consulte Lanzar GDB con 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. Puede utilizar el modificador -j4 en el comando make para reducir el tiempo de compilación:
```
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 aspecto1234567890123-ats.iot.us-east-1.amazonaws.com.
Si sigue los pasos de Uso de Freertos en su propio CMake proyecto para ESP32 y ve errores de referencias no definidas del vinculador, generalmente se debe a que faltan bibliotecas o demostraciones dependientes. Para añadirlos, actualice el CMakeLists.txt archivo (en el directorio raíz) utilizando la CMake función estándartarget_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 v3.3)

En esta sección se muestra cómo utilizar la versión 3.3 de ESP-IDF en el hardware de Espressif. Para depurar con la versión 4.2 de ESP-IDF, consulte Código de depuración en Espressif - C y (ESP-IDF v4.2) ESP32 DevKit ESP-WROVER-KIT.

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 ESP- C JTAG

Para el cable FTDI C232HM-DDHSL-0, estas son las conexiones al DevKitc. ESP32

Color del cable C232HM-DDHSL-0	ESP32 Pin GPIO	Nombre de la señal JTAG
Marrón (pin 5)	IO14	TMS
Amarillo (pin 3)	IO12	TDI
Negro (pin 10)	GND	GND
Naranja (pin 2)	IO13	TCK
Verde (pin 4)	IO15	TDO

ESP-WROVER-KIT Configuración JTAG

Para el cable FTDI C232HM-DDHSL-0, estas son las conexiones al -WROVER-KIT. ESP32

Color del cable C232HM-DDHSL-0	ESP32 Pin GPIO	Nombre de la señal JTAG
Marrón (pin 5)	IO14	TMS
Amarillo (pin 3)	IO12	TDI
Naranja (pin 2)	IO13	TCK
Verde (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 activar el JTAG en ESP-WROVER-KIT, coloque puentes en los pines TMS, TDO, TDI, TCK y S_TDI, como se muestra aquí.

Depuración en Windows (ESP-IDF v3.3)

Configuración 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 v3.3). 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 Properties (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 Detalles, elija Propiedad y, a continuación, Hardware. IDs 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 IDs coincidan con IDs la entradaprojects/espressif/esp32/make/aws_demos/esp32_devkitj_v1.cfg. IDs Se especifican en una línea que comienza por ftdi_vid_pid seguida de un identificador de proveedor y un identificador 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. Desde el menú desplegable bajo el campo del controlador de destino, elija la flecha y, a continuación, haga clic en Instalar controlador. Elija Replace Driver (Reemplazar controlador).
Abra un símbolo del sistema, acceda a projects/espressif/esp32/make/aws_demos y ejecute el siguiente comando.

Para ESP32 -WROOM-32 y -WROVER ESP32
```
openocd.exe -f esp32_devkitj_v1.cfg -f esp-wroom-32.cfg
```
Para ESP32 -SOLO-1
```
openocd.exe -f esp32_devkitj_v1.cfg -f esp-solo-1.cfg
```
Deje este símbolo del sistema abierto.
Abra un nuevo símbolo del sistema, desplácese hasta su directorio msys32 y ejecute mingw32.exe.
En el terminal mingw32, vaya a projects/espressif/esp32/make/aws_demos y ejecute
```
make flash monitor
```
Abra otro terminal de mingw32, acceda a projects/espressif/esp32/make/aws_demos y espere hasta que la demostración comience a ejecutarse en la placa. Cuando esto suceda, ejecute xtensa-esp32-elf-gdb -x gdbinit build/aws_demos.elf. El programa debe detenerse en la función main.

nota

ESP32 Soporta un máximo de dos puntos de rotura.

Depuración en macOS (ESP-IDF v3.3)

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
```
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 el IDs valor para que IDs coincida con el system_profiler resultado del paso anterior.
Abra una ventana de terminal, vaya a projects/espressif/esp32/make/aws_demos y utilice el siguiente comando para ejecutar OpenOCD.

Para ESP32 -WROOM-32 y -WROVER: ESP32
```
openocd -f esp32_devkitj_v1.cfg -f esp-wroom-32.cfg
```
Para ESP32 -SOLO-1:
```
openocd -f esp32_devkitj_v1.cfg -f esp-solo-1.cfg
```
Abra un nuevo terminal y utilice el siguiente comando para cargar el controlador de puerto serie FTDI.
```
sudo kextload -b com.FTDI.driver.FTDIUSBSerialDriver
```
Vaya a projects/espressif/esp32/make/aws_demos y ejecute el comando siguiente.
```
make flash monitor
```
Abra otro terminal nuevo, vaya a projects/espressif/esp32/make/aws_demos y ejecute el siguiente comando.
```
xtensa-esp32-elf-gdb -x gdbinit build/aws_demos.elf
```
El programa debe detenerse en main().

Depuración en Linux (ESP-IDF v3.3)

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 enruta al puerto serie (UART) ESP32 del dispositivo y se utiliza para cargar el código en la memoria flash del dispositivo. ESP32
En una ventana de terminal, vaya a projects/espressif/esp32/make/aws_demos y utilice el siguiente comando para ejecutar OpenOCD.

Para ESP32 -WROOM-32 y -WROVER: ESP32
```
openocd -f esp32_devkitj_v1.cfg -f esp-wroom-32.cfg
```
Para ESP32 -SOLO-1:
```
openocd -f esp32_devkitj_v1.cfg -f esp-solo-1.cfg
```
Abra otro terminal, vaya a projects/espressif/esp32/make/aws_demos y ejecute el siguiente comando.
```
make flash monitor
```
Abra otro terminal, vaya a projects/espressif/esp32/make/aws_demos y ejecute el siguiente comando:
```
xtensa-esp32-elf-gdb -x gdbinit build/aws_demos.elf
```
El programa debe detenerse en main().

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

En esta sección se muestra cómo utilizar la versión 4.2 de ESP-IDF en el hardware de Espressif. Para depurar con la versión 3.3 de ESP-IDF, consulte Código de depuración en Espressif ESP32 - DevKit C y ESP-WROVER-KIT (ESP-IDF v3.3).

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 ESP- C JTAG

Para el cable FTDI C232HM-DDHSL-0, estas son las conexiones al DevKitc. ESP32

Color del cable C232HM-DDHSL-0	ESP32 Pin GPIO	Nombre de la señal JTAG
Marrón (pin 5)	IO14	TMS
Amarillo (pin 3)	IO12	TDI
Negro (pin 10)	GND	GND
Naranja (pin 2)	IO13	TCK
Verde (pin 4)	IO15	TDO

ESP-WROVER-KIT Configuración JTAG

Para el cable FTDI C232HM-DDHSL-0, estas son las conexiones al -WROVER-KIT. ESP32

Color del cable C232HM-DDHSL-0	ESP32 Pin GPIO	Nombre de la señal JTAG
Marrón (pin 5)	IO14	TMS
Amarillo (pin 3)	IO12	TDI
Naranja (pin 2)	IO13	TCK
Verde (pin 4)	IO15	TDO

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

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

Configuración 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 - C y (ESP-IDF v4.2) ESP32 DevKit ESP-WROVER-KIT. 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 Properties (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 Detalles, elija Propiedad y, a continuación, Hardware. IDs 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 IDs coincidan con IDs la entradaprojects/espressif/esp32/make/aws_demos/esp32_devkitj_v1.cfg. IDs Se especifican en una línea que comienza por ftdi_vid_pid seguida de un identificador de proveedor y un identificador 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. Desde el menú desplegable bajo el campo del controlador de destino, elija la flecha y, a continuación, haga clic en 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

ESP32 Admite un máximo de dos puntos de ruptura.

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
```
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 el IDs valor para que IDs coincida con el system_profiler resultado 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 enruta al puerto serie (UART) ESP32 del dispositivo y se utiliza para cargar el código en la memoria flash ESP32 del dispositivo.
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 ATECC6 08A Secure Element con simulador de Windows

Espressif -WROOM-32SE ESP32

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

importante

nota

Descripción general

Requisitos previos

Inscríbase en una Cuenta de AWS

Para suscribirte a una Cuenta de AWS

Creación de un usuario con acceso administrativo

Proteja su Usuario raíz de la cuenta de AWS

Creación de un usuario con acceso administrativo

Inicio de sesión como usuario con acceso de administrador

Concesión de acceso a usuarios adicionales

nota

Introducción a ESP-IDF v3.3

Configuración del hardware Espressif

importante

Cómo configurar el entorno de desarrollo.

Configuración de la cadena de herramientas

nota

importante

Instalar CMake

Establecimiento de una conexión serie

Descarga y configuración de FreeRTOS

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

Ejecución del script de configuración

nota

Creación, instalación y ejecución del proyecto de demostración de FreeRTOS

Creación de FreeRTOS en Linux y macOS (ESP-IDF v3.3)

Para generar los archivos de compilación de la aplicación de demostración con CMake

nota

Creación de la aplicación con Make

nota

Creación de FreeRTOS en Windows (ESP-IDF v3.3)

Para generar los archivos de compilación de la aplicación de demostración con CMake

nota

Creación de la aplicación

nota

Instalación y ejecución de FreeRTOS (ESP-IDF v3.3)

nota

Introducción a ESP-IDF v4.2

nota

Configuración del hardware Espressif

importante

Cómo configurar el entorno de desarrollo.

Configuración de la cadena de herramientas

importante

Finalización de la instalación (Linux o MacOS)

Establecimiento de una conexión serie

Descarga y configuración de FreeRTOS

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

Ejecución del script de configuración

nota

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

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

nota

Creación e instalación del proyecto

nota

nota

Cree y flashee Freertos con CMake

Creación e instalación del proyecto

Monitorización de mensajes de MQTT en la nube

Para suscribirse al tema MQTT con el AWS IoT cliente MQTT

Ejecución de las demostraciones de Bluetooth de bajo consumo

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

Uso de Freertos en su propio CMake proyecto para ESP32

Uso de los componentes de FreeRTOS

Añadir 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 v3.3)

Configuración DevKit ESP- C JTAG

ESP-WROVER-KIT Configuración JTAG

Depuración en Windows (ESP-IDF v3.3)

Configuración para la depuración en Windows

nota

nota

Depuración en macOS (ESP-IDF v3.3)