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 ESP32 Espressif -S2 **Importante** Essa integração de referência está hospedada no repositório Amazon-FreeRTOS, que está preterido. Recomendamos [começar aqui](freertos-getting-started-modular.md) ao criar um novo projeto. Se você já tem um projeto FreeRTOS existente baseado no repositório Amazon-FreeRTOS que está preterido, consulte o [Guia de migração do repositório Github do Amazon FreeRTOS](github-repo-migration.md). **nota** [Para explorar como integrar bibliotecas modulares e demonstrações do FreeRTOS em seu próprio projeto Espressif IDF, consulte nossa integração de referência em destaque para a plataforma -C3. ESP32](https://www.freertos.org/featured-freertos-iot-integration-targeting-an-espressif-esp32-c3-risc-v-mcu/) [Este tutorial mostra como começar a usar as placas de desenvolvimento Espressif ESP32 -S2 SoC e -S2-Saola-1. ESP32](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. Fazer a compilação cruzada de uma aplicação 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 Se você não tiver um Conta da AWS, conclua as etapas a seguir para criar um. **Para se inscrever em um Conta da AWS** 1. Abra a [https://portal.aws.amazon.com/billing/inscrição.](https://portal.aws.amazon.com/billing/signup) 1. Siga as instruções online. Parte do procedimento de inscrição envolve receber uma chamada telefônica ou uma mensagem de texto e inserir um código de verificação pelo teclado do telefone. Quando você se inscreve em um Conta da AWS, um *Usuário raiz da conta da AWS*é criado. O usuário-raiz tem acesso a todos os Serviços da AWS e recursos na conta. Como prática recomendada de segurança, atribua o acesso administrativo a um usuário e use somente o usuário-raiz para executar [tarefas que exigem acesso de usuário-raiz](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_root-user.html#root-user-tasks). AWS envia um e-mail de confirmação após a conclusão do processo de inscrição. A qualquer momento, você pode visualizar a atividade atual da sua conta e gerenciar sua conta acessando [https://aws.amazon.com/e](https://aws.amazon.com/) escolhendo **Minha conta**. ### Criar um usuário com acesso administrativo Depois de se inscrever em um Conta da AWS, proteja seu Usuário raiz da conta da AWS Centro de Identidade do AWS IAM, habilite e crie um usuário administrativo para que você não use o usuário root nas tarefas diárias. **Proteja seu Usuário raiz da conta da AWS** 1. Faça login [Console de gerenciamento da AWS](https://console.aws.amazon.com/)como proprietário da conta escolhendo **Usuário raiz** e inserindo seu endereço de Conta da AWS e-mail. Na próxima página, insira a senha. Para obter ajuda ao fazer login usando o usuário-raiz, consulte [Fazer login como usuário-raiz](https://docs.aws.amazon.com/signin/latest/userguide/console-sign-in-tutorials.html#introduction-to-root-user-sign-in-tutorial) no *Guia do usuário do Início de Sessão da AWS *. 1. Habilite a autenticação multifator (MFA) para o usuário-raiz. Para obter instruções, consulte [Habilitar um dispositivo de MFA virtual para seu usuário Conta da AWS raiz (console) no Guia](https://docs.aws.amazon.com/IAM/latest/UserGuide/enable-virt-mfa-for-root.html) do *usuário do IAM*. **Criar um usuário com acesso administrativo** 1. Habilita o Centro de Identidade do IAM. Para obter instruções, consulte [Habilitar o Centro de Identidade do AWS IAM](https://docs.aws.amazon.com//singlesignon/latest/userguide/get-set-up-for-idc.html) no *Guia do usuário do Centro de Identidade do AWS IAM *. 1. No Centro de Identidade do IAM, conceda o acesso administrativo a um usuário. Para ver um tutorial sobre como usar o Diretório do Centro de Identidade do IAM como fonte de identidade, consulte [Configurar o acesso do usuário com o padrão Diretório do Centro de Identidade do IAM](https://docs.aws.amazon.com//singlesignon/latest/userguide/quick-start-default-idc.html) no *Guia Centro de Identidade do AWS IAM do usuário*. **Iniciar sessão como o usuário com acesso administrativo** + Para fazer login com o seu usuário do Centro de Identidade do IAM, use o URL de login enviado ao seu endereço de e-mail quando o usuário do Centro de Identidade do IAM foi criado. Para obter ajuda para fazer login usando um usuário do IAM Identity Center, consulte Como [fazer login no portal de AWS acesso](https://docs.aws.amazon.com/signin/latest/userguide/iam-id-center-sign-in-tutorial.html) no *Guia Início de Sessão da AWS do usuário*. **Atribuir acesso a usuários adicionais** 1. No Centro de Identidade do IAM, crie um conjunto de permissões que siga as práticas recomendadas de aplicação de permissões com privilégio mínimo. Para obter instruções, consulte [Criar um conjunto de permissões](https://docs.aws.amazon.com//singlesignon/latest/userguide/get-started-create-a-permission-set.html) no *Guia do usuário do Centro de Identidade do AWS IAM *. 1. Atribua usuários a um grupo e, em seguida, atribua o acesso de logon único ao grupo. Para obter instruções, consulte [Adicionar grupos](https://docs.aws.amazon.com//singlesignon/latest/userguide/addgroups.html) no *Guia do usuário do Centro de Identidade do AWS IAM *. 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 desenvolvimento ESP32 -S2, consulte o Guia de introdução do [ ESP32-S2-Saola-1](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 arquivo [README.md](https://github.com/aws/amazon-freertos/blob/main/README.md).) 1. **Configure o ambiente de desenvolvimento**. Para se comunicar com sua placa, você deve instalar uma cadeia de ferramentas. A Espressif fornece o ESP-IDF para desenvolver software para suas placas. Como o ESP-IDF tem a própria versão do kernel do FreeRTOS integrada como um componente, o Amazon FreeRTOS inclui uma versão personalizada do ESP-IDF v4.2 que tem o kernel do FreeRTOS removido. Isso corrige problemas com arquivos duplicados durante a compilação. Para usar a versão personalizada do ESP-IDF v4.2 incluída no Amazon FreeRTOS, siga as instruções abaixo para o sistema operacional da sua máquina host. **Windows** 1. Faça download do [Instalador online universal](https://dl.espressif.com/dl/esp-idf/?idf=4.2) do ESP-IDF para Windows. 1. Execute o **Instalador online universal**. 1. Ao chegar à etapa **Fazer download ou usar ESP-IDF**, selecione **Usar um diretório ESP-IDF existente** e defina **Escolher diretório ESP-IDF existente como `{{freertos}}/vendors/espressif/esp-idf`**. 1. Concluir a instalação. **macOS** 1. Siga as instruções nos [Pré-requisitos de configuração padrão da cadeia de ferramentas (ESP-IDF v4.2) para macOS](https://docs.espressif.com/projects/esp-idf/en/release-v4.2/esp32s2/get-started/macos-setup.html). **Importante** Quando você chegar nas instruções de "Obter ESP-IDF" em **Próximas etapas**, pare e retorne para as instruções desta 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 ferramentas da cadeia de ferramentas ESP-IDF ao caminho do seu terminal com o comando a seguir. ``` source vendors/espressif/esp-idf/export.sh ``` **Linux** 1. Siga as instruções nos [Pré-requisitos da configuração padrão da cadeia de ferramentas (ESP-IDF v4.2) para Linux](https://docs.espressif.com/projects/esp-idf/en/release-v4.2/esp32s2/get-started/linux-setup.html). **Importante** Quando você chegar nas instruções de "Obter ESP-IDF" em **Próximas etapas**, pare e retorne para as instruções desta 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 ferramentas da cadeia de ferramentas ESP-IDF 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 - DevKit C, 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 a aplicação "ESP-IDF 4.x CMD" (se você incluiu essa opção ao instalar a cadeia de ferramentas ESP-IDF) ou, caso contrário, a aplicação "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, na aplicação "Comando" 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 rede Wi-Fi. **`wifi_password`** A senha da rede Wi-Fi. **`wifi_security`** O tipo de segurança da rede Wi-Fi. 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`(WPA2 segurança) 1. Se você estiver executando macOS ou Linux, abra um prompt de terminal. Se você estiver executando o Windows, abra a aplicação "ESP-IDF 4.x CMD" ou "Comando". 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 arquivo `aws_clientcredential.h` com o endpoint, o SSID Wi-Fi e as credenciais da AWS IoT . + 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. Por este motivo, as aplicações 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 na nuvem AWS 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 MQTT com o cliente AWS IoT 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. #### Compilação e instalação do FreeRTOS no Windows, Linux e macOS (ESP-IDF v4.2) 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. Na janela da linha de comando, insira o comando a seguir para adicionar as ferramentas de ESP-IDF ao PATH do seu terminal: **Windows (aplicação "Comando")** ``` vendors\espressif\esp-idf\export.bat ``` **Windows (aplicação "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 ``` ### Crie e atualize Freertos com CMake Além de usar o `idf.py` script fornecido pelo SDK do IDF para criar e executar seu código, você também pode criar o projeto com. 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 ferramentas ESP-IDF ao PATH do 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 como usar e solucionar problemas de ESP32 placas Espressif, consulte os tópicos a seguir: + [Usando FreeRTOS em seu próprio projeto para CMake 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)