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-S2 **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 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 Este tutorial le muestra cómo empezar a utilizar el SoC y las placas de desarrollo de Espressif ESP32-S2 . [ESP32-S2-Saola-1](https://devices.amazonaws.com/detail/a3G0h00000AkFngEAF/ESP32-S2-Saola-1) ## Descripción general de Este tutorial le guiará a través de los siguientes pasos: 1. Conecte la placa a un equipo host. 1. Instale el software en su equipo host para desarrollar y depurar las aplicaciones integradas de la placa del microcontrolador. 1. Cross-compile una aplicación de demostración de Freertos para una imagen binaria. 1. Cargue la imagen binaria de la aplicación en su placa y, a continuación, ejecute la aplicación. 1. Monitorice y depure la aplicación en ejecución mediante una conexión serie. ## Requisitos previos Antes de empezar a usar Freertos en tu pizarra Espressif, debes configurar tu cuenta y tus permisos. AWS ### Inscríbase en 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-S2 desarrollo, consulte la [ ESP32-S2-Saola-1 Guía de introducción](https://docs.espressif.com/projects/esp-idf/en/release-v4.2/esp32s2/hw-reference/esp32s2/user-guide-saola-1-v1.2.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/esp32s2/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/esp32s2/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, instale 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). 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 lo siguiente: ``` 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 ``` 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. **Ejecución del script de configuración** 1. 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. 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 una AWS IoT cosa, un certificado y una política. + Adjunta la AWS IoT política al certificado y el certificado a la AWS IoT cosa. + 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`. ### Supervisión de los mensajes MQTT en el AWS Cloud 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. Inicie sesión en 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 utilizar la utilidad IDF de Espressif para generar los archivos de creación, crear el binario de la aplicación e instalar la placa. #### Cree y actualice 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** 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=esp32s2_saola_1 -DCOMPILER=xtensa-esp32s2 build ``` Debería ver un resultado como el del siguiente ejemplo. ``` Executing action: all (aliases: build) Running cmake in directory /path/to/hello_world/build Executing "cmake -G Ninja -DPYTHON_DEPS_CHECKED=1 -DESP_PLATFORM=1 -DVENDOR=espressif -DBOARD=esp32s2_saola_1 -DCOMPILER=xtensa-esp32s2 -DCCACHE_ENABLE=0 /path/to/hello_world"... -- The C compiler identification is GNU 8.4.0 -- The CXX compiler identification is GNU 8.4.0 -- The ASM compiler identification is GNU ... (more lines of build system output) [1628/1628] Generating binary image from built executable esptool.py v3.0 Generated /path/to/hello_world/build/aws_demos.bin Project build complete. To flash, run this command: esptool.py -p (PORT) -b 460800 --before default_reset --after hard_reset --chip esp32s2 write_flash --flash_mode dio --flash_size detect --flash_freq 80m 0x1000 build/bootloader/bootloader.bin 0x8000 build/partition_table/partition-table.bin 0x16000 build/ota_data_initial.bin 0x20000 build/aws_demos.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 Makefile 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=esp32s2_saola_1 -DCOMPILER=xtensa-esp32s2 -S . -B ./{{YOUR_BUILD_DIRECTORY}} -DAFR_ENABLE_ALL_MODULES=1 -DAFR_ENABLE_TESTS=0 ``` + Con Ninja ``` cmake -DVENDOR=espressif -DBOARD=esp32s2_saola_1 -DCOMPILER=xtensa-esp32s2 -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 ``` ## Información adicional Para obtener más información sobre cómo utilizar y solucionar problemas de las placas Espressif ESP32, consulte los siguientes temas: + [Uso de FreeRTOS en su propio proyecto de CMake para ESP32](getting_started_espressif.md#getting_started_espressif_cmake_project) + [Resolución de problemas](getting_started_espressif.md#getting_started_espressif_troubleshooting) + [Debugging](getting_started_espressif.md#getting_started_espressif_debugging)