As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.
# Começando com o Espressif ESP32-S2
**Importante**
Essa integração de referência está hospedada no Amazon-FreeRTOS repositório que está obsoleto. Recomendamos [começar aqui](freertos-getting-started-modular.md) ao criar um novo projeto. Se você já tem um projeto FreeRTOS existente com base no repositório agora Amazon-FreeRTOS obsoleto, consulte o. [Amazon-FreeRTOS Guia de migração do repositório Github](github-repo-migration.md)
**nota**
[Para explorar como integrar bibliotecas modulares e demonstrações do FreeRTOS em seu próprio projeto Espressif IDF, veja nossa integração de referência em destaque para a plataforma. ESP32-C3 ](https://www.freertos.org/featured-freertos-iot-integration-targeting-an-espressif-esp32-c3-risc-v-mcu/)
Este tutorial mostra como começar a usar o ESP32-S2 SoC Espressif e as placas de desenvolvimento. [ESP32-S2-Saola-1](https://devices.amazonaws.com/detail/a3G0h00000AkFngEAF/ESP32-S2-Saola-1)
## Visão geral do
Este tutorial orienta você pelas seguintes etapas:
1. Conectar a placa a uma máquina host.
1. Instalar o software na máquina host para desenvolver e depurar aplicações incorporadas para a placa do microcontrolador.
1. Cross-compile um aplicativo de demonstração do FreeRTOS para uma imagem binária.
1. Carregar a imagem binária do aplicativo em na placa e executar o aplicativo.
1. Monitorar e depurar a aplicação em execução usando uma conexão serial.
## Pré-requisitos
Antes de começar a usar os FreeRTOS em seu quadro Espressif, você deve configurar sua conta e permissões. AWS
### Inscreva-se para um Conta da AWS
Para começar AWS, você precisa de um Conta da AWS. Para obter informações sobre como criar um Conta da AWS, consulte [Introdução a um Conta da AWS](https://docs.aws.amazon.com//accounts/latest/reference/getting-started.html) no *Guia de AWS Gerenciamento de contas referência*.
Para conceder acesso, adicione as permissões aos seus usuários, grupos ou perfis:
+ Usuários e grupos em Centro de Identidade do AWS IAM:
Crie um conjunto de permissões. Siga as instruções em [Criação de um conjunto de permissões](https://docs.aws.amazon.com//singlesignon/latest/userguide/howtocreatepermissionset.html) no *Guia do usuário do Centro de Identidade do AWS IAM *.
+ Usuários gerenciados no IAM com provedor de identidades:
Crie um perfil para a federação de identidades. Siga as instruções em [Criando um perfil para um provedor de identidades de terceiros (federação)](https://docs.aws.amazon.com//IAM/latest/UserGuide/id_roles_create_for-idp.html) no *Guia do Usuário do IAM*.
+ Usuários do IAM:
+ Crie um perfil que seu usuário possa assumir. Siga as instruções em [Criação de um perfil para um usuário do IAM](https://docs.aws.amazon.com//IAM/latest/UserGuide/id_roles_create_for-user.html) no *Guia do usuário do IAM*.
+ (Não recomendado) Vincule uma política diretamente a um usuário ou adicione um usuário a um grupo de usuários. Siga as instruções em [Adição de permissões a um usuário (console)](https://docs.aws.amazon.com//IAM/latest/UserGuide/id_users_change-permissions.html#users_change_permissions-add-console) no *Guia do usuário do IAM*.
## Conceitos básicos
**nota**
Os comandos do Linux neste tutorial exigem o uso do shell Bash.
1. **Configuração de hardware da Espressif.**
Para obter informações sobre como configurar o hardware da placa de ESP32-S2 desenvolvimento, consulte o [ ESP32-S2-Saola-1 Guia de introdução](https://docs.espressif.com/projects/esp-idf/en/release-v4.2/esp32s2/hw-reference/esp32s2/user-guide-saola-1-v1.2.html).
**Importante**
Ao chegar na seção **Começar a usar** dos guias do Espressif, pare e retorne para as instruções desta página.
1. Faça o download dos Amazon [GitHub](https://github.com/aws/amazon-freertos)FreeRTOS em. (Para obter instruções, consulte o [README.md](https://github.com/aws/amazon-freertos/blob/main/README.md)arquivo.)
1. **Configure o ambiente de desenvolvimento**.
Para se comunicar com sua placa, você deve instalar uma cadeia de ferramentas. A Espressif fornece o desenvolvimento ESP-IDF de software para suas placas. Como ESP-IDF tem sua própria versão do Kernel do FreeRTOS integrada como um componente, o Amazon FreeRTOS inclui uma versão personalizada da v4.2 que tem o Kernel do ESP-IDF FreeRTOS removido. Isso corrige problemas com arquivos duplicados durante a compilação. Para usar a versão personalizada da versão ESP-IDF 4.2 incluída no Amazon FreeRTOS, siga as instruções abaixo para o sistema operacional da sua máquina host.
**Windows**
1. Baixe ESP-IDF o [Universal Online Installer](https://dl.espressif.com/dl/esp-idf/?idf=4.2) para Windows.
1. Execute o **Instalador online universal**.
1. Ao chegar à etapa **Baixar ou usar ESP-IDF, selecione Usar** **um ESP-IDF diretório existente** e defina **Escolher ESP-IDF diretório existente** como`{{freertos}}/vendors/espressif/esp-idf`.
1. Concluir a instalação.
**macOS**
1. Siga as instruções na [Configuração padrão dos pré-requisitos do Toolchain (ESP-IDF v4.2)](https://docs.espressif.com/projects/esp-idf/en/release-v4.2/esp32s2/get-started/macos-setup.html) para macOS.
**Importante**
Ao acessar as instruções “Obter ESP-IDF” em **Próximas etapas**, pare e retorne às instruções nesta página.
1. Abra a janela de linha de comando.
1. Navegue até o diretório de download do FreeRTOS e, em seguida, execute o script a seguir para baixar e instalar a cadeia de ferramentas do espressif em sua plataforma.
```
vendors/espressif/esp-idf/install.sh
```
1. Adicione as ESP-IDF ferramentas do conjunto de ferramentas ao caminho do seu terminal com o comando a seguir.
```
source vendors/espressif/esp-idf/export.sh
```
**Linux**
1. Siga as instruções na [Configuração padrão dos pré-requisitos do Toolchain (ESP-IDF v4.2](https://docs.espressif.com/projects/esp-idf/en/release-v4.2/esp32s2/get-started/linux-setup.html)) para Linux.
**Importante**
Ao acessar as instruções “Obter ESP-IDF” em **Próximas etapas**, pare e retorne às instruções nesta página.
1. Abra a janela de linha de comando.
1. Navegue até o diretório de download do FreeRTOS e execute o script a seguir para baixar e instalar a cadeia de ferramentas do Espressif em sua plataforma.
```
vendors/espressif/esp-idf/install.sh
```
1. Adicione as ESP-IDF ferramentas do conjunto de ferramentas ao caminho do seu terminal com o comando a seguir.
```
source vendors/espressif/esp-idf/export.sh
```
1. **Estabelecimento de uma conexão serial**.
1. Para estabelecer uma conexão serial entre sua máquina host e o. ESP32-DevKitC, instale os drivers CP210x USB para UART Bridge VCP. Você pode fazer download desses drivers no [Silicon Labs](https://www.silabs.com/products/development-tools/software/usb-to-uart-bridge-vcp-drivers).
1. Siga as etapas para [ Estabelecer uma conexão serial com ESP32](https://docs.espressif.com/projects/esp-idf/en/release-v4.2/esp32/get-started/establish-serial-connection.html).
1. Depois de estabelecer uma conexão serial, anote a porta serial da conexão de sua placa. Você precisa disso para instalar a demonstração.
### Configuração das aplicações de demonstração do FreeRTOS
Para este tutorial, o arquivo de configuração do FreeRTOS está localizado em `{{freertos}}/vendors/espressif/boards/{{board-name}}/aws_demos/config_files/FreeRTOSConfig.h`. (Por exemplo, se `AFR_BOARD espressif.esp32_devkitc` for escolhido, o arquivo de configuração estará localizado em `{{freertos}}/vendors/espressif/boards/esp32/aws_demos/config_files/FreeRTOSConfig.h`.)
1. Se você estiver executando macOS ou Linux, abra um prompt de terminal. Se você estiver executando o Windows, abra o aplicativo "ESP-IDF 4.x CMD” (se você incluiu essa opção ao instalar o ESP-IDF conjunto de ferramentas) ou, caso contrário, o aplicativo “Prompt de comando”.
1. Para verificar se você tem o Python3 instalado, execute o seguinte:
```
python --version
```
A versão instalada é exibida. Se você não tiver o Python 3.0.1 ou posterior instalado, poderá instalá-lo a partir do site do [Python](https://www.python.org/downloads/).
1. Você precisa da interface de linha de AWS comando (CLI) para executar AWS IoT comandos. Se você estiver executando o Windows, use o `easy_install awscli` comando para instalar a AWS CLI no aplicativo “Command” ou "ESP-IDF 4.x CMD”.
Se você estiver executando o macOS ou o Linux, consulte [Instalação da CLI AWS](https://docs.aws.amazon.com/cli/latest/userguide/installing.html).
1. Executar
```
aws configure
```
e configure a AWS CLI com seu ID de chave de AWS acesso, chave de acesso secreta e região padrão AWS . Para obter mais informações, consulte [Configurar a CLI AWS](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-started.html).
1. Use o comando a seguir para instalar o AWS SDK para Python (boto3):
+ No Windows, no aplicativo “Command” ou "ESP-IDF 4.x CMD”, execute
```
easy_install boto3
```
+ No macOS ou Linux, execute
```
pip install tornado nose --user
```
e depois execute
```
pip install boto3 --user
```
O FreeRTOS inclui o script `SetupAWS.py` para facilitar a configuração da placa Espressif para conectar-se ao AWS IoT.
**Para executar o script de configuração**
1. Para configurar o script, abra `{{freertos}}/tools/aws_config_quick_start/configure.json` e defina os seguintes atributos:
**`afr_source_dir`**
O caminho completo para o diretório `{{freertos}}` no computador. Certifique-se de usar barras para especificar esse caminho.
**`thing_name`**
O nome que você deseja atribuir à AWS IoT coisa que representa seu quadro.
**`wifi_ssid`**
O SSID da sua Wi-Fi rede.
**`wifi_password`**
A senha da sua Wi-Fi rede.
**`wifi_security`**
O tipo de segurança da sua Wi-Fi rede. Os tipos de segurança válidos estão a seguir:
+ `eWiFiSecurityOpen` (Aberto, sem segurança)
+ `eWiFiSecurityWEP` (segurança WEP)
+ `eWiFiSecurityWPA` (segurança WPA)
+ `eWiFiSecurityWPA2` (segurança WPA2)
1. Se você estiver executando macOS ou Linux, abra um prompt de terminal. Se você estiver executando o Windows, abra o aplicativo "ESP-IDF 4.x CMD” ou “Command”.
1. Navegue até o diretório `{{freertos}}/tools/aws_config_quick_start` e execute
```
python SetupAWS.py setup
```
O script faz o seguinte:
+ Cria AWS IoT algo, certificado e política.
+ Anexa a AWS IoT política ao certificado e o certificado à AWS IoT coisa.
+ Preenche o `aws_clientcredential.h` arquivo com seu AWS IoT endpoint, Wi-Fi SSID e credenciais.
+ Formata o certificado e a chave privada e os grava no arquivo de cabeçalho `aws_clientcredential_keys.h`.
**nota**
O certificado é codificado apenas para fins de demonstração. Production-level os aplicativos devem armazenar esses arquivos em um local seguro.
Para obter mais informações sobre `SetupAWS.py`, consulte `README.md` no diretório `{{freertos}}/tools/aws_config_quick_start`.
### Monitorando mensagens MQTT no AWS Nuvem
Antes de executar o projeto de demonstração do FreeRTOS, você pode configurar o cliente MQTT no console para monitorar AWS IoT as mensagens que seu dispositivo envia para a nuvem. AWS
**Para assinar o tópico do MQTT com o AWS IoT Cliente MQTT**
1. Faça login no [console do AWS IoT](https://console.aws.amazon.com/iotv2/).
1. No painel de navegação, escolha **Teste** e, em seguida, escolha **Cliente de teste MQTT**.
1. Em **Tópico de inscrição**, insira `{{your-thing-name}}/example/topic` e selecione **Inscreva-se no tópico**.
Quando o projeto de demonstração for executado com êxito em seu dispositivo, você verá "Olá, mundo\!". enviado várias vezes para o tópico em que você assinou.
### Compilação, atualização e execução do projeto de demonstração do FreeRTOS usando o script idf.py
Você pode usar o utilitário Espressif do IDF para gerar os arquivos de compilação, compilar o binário da aplicação e instalar a placa.
#### Crie e atualize Freertos no Windows, Linux e macOS (v4.2) ESP-IDF
Use o script `idf.py` para compilar o projeto e instalar os binários em seu dispositivo.
**nota**
Algumas configurações podem exigir que você use a opção de porta `-p port-name` com`idf.py` para especificar a porta correta, como no exemplo a seguir.
```
idf.py -p /dev/cu.usbserial-00101301B flash
```
**Como compilar e instalar o projeto**
1. Navegue até a raiz do diretório de downloads do FreeRTOS.
1. Em uma janela de linha de comando, digite o seguinte comando para adicionar as ESP-IDF ferramentas ao PATH do seu terminal:
**Windows (aplicação "Comando")**
```
vendors\espressif\esp-idf\export.bat
```
**Windows (aplicativo “ESP-IDF 4.x CMD”)**
(Isso já foi feito quando você abriu a aplicação.)
**Linux / macOS**
```
source vendors/espressif/esp-idf/export.sh
```
1. Configure o cmake no diretório `build` e compile a imagem do firmware com o comando a seguir.
```
idf.py -DVENDOR=espressif -DBOARD=esp32s2_saola_1 -DCOMPILER=xtensa-esp32s2 build
```
A saída deverá ser parecida com a do exemplo a seguir.
```
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'
```
Se não houver erros, a compilação gera os arquivos.bin binários do firmware.
1. Apague a memória instalada da placa de desenvolvimento com o comando a seguir.
```
idf.py erase_flash
```
1. Use o script `idf.py` para instalar o binário da aplicação na placa.
```
idf.py flash
```
1. Monitore a saída da porta serial da placa com o comando a seguir.
```
idf.py monitor
```
**nota**
Você pode combinar esses comandos, como no exemplo a seguir.
```
idf.py erase_flash flash monitor
```
Para determinadas configurações da máquina host, você deve especificar a porta ao instalar a placa, como no exemplo a seguir.
```
idf.py erase_flash flash monitor -p /dev/ttyUSB1
```
### Compilação e instalação do FreeRTOS com o CMake
Além de usar o script `idf.py` fornecido pelo SDK do IDF para criar e executar seu código, você também pode compilar o projeto com o CMake. Atualmente, ele é compatível com o Makefile da Unix e o sistema de compilação Ninja.
**Como compilar e instalar o projeto**
1. Em uma janela da linha de comando, navegue até o diretório raiz de downloads do FreeRTOS.
1. Execute o script a seguir para adicionar as ESP-IDF ferramentas ao PATH do seu shell.
+ Windows
```
vendors\espressif\esp-idf\export.bat
```
+ Linux / macOS
```
source vendors/espressif/esp-idf/export.sh
```
1. Insira o comando a seguir para gerar os arquivos de compilação.
+ Com Makefiles da Unix
```
cmake -DVENDOR=espressif -DBOARD=esp32s2_saola_1 -DCOMPILER=xtensa-esp32s2 -S . -B ./{{YOUR_BUILD_DIRECTORY}} -DAFR_ENABLE_ALL_MODULES=1 -DAFR_ENABLE_TESTS=0
```
+ Com 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. Crie o projeto.
+ Com Makefiles da Unix
```
make -C ./{{YOUR_BUILD_DIRECTORY}} -j8
```
+ Com Ninja
```
ninja -C ./{{YOUR_BUILD_DIRECTORY}} -j8
```
1. Apague a instalada e depois instale a placa.
+ Com Makefiles da Unix
```
make -C ./{{YOUR_BUILD_DIRECTORY}} erase_flash
```
```
make -C ./{{YOUR_BUILD_DIRECTORY}} flash
```
+ Com Ninja
```
ninja -C ./{{YOUR_BUILD_DIRECTORY}} erase_flash
```
```
ninja -C ./{{YOUR_BUILD_DIRECTORY}} flash
```
## Mais informações
Para obter mais informações sobre o uso e a solução de problemas das placas Espressif ESP32, consulte os seguintes tópicos:
+ [Uso do FreeRTOS em seu próprio projeto CMake para ESP32](getting_started_espressif.md#getting_started_espressif_cmake_project)
+ [Solução de problemas](getting_started_espressif.md#getting_started_espressif_troubleshooting)
+ [Depuração](getting_started_espressif.md#getting_started_espressif_debugging)