Visão geral Pré-requisitos Conceitos básicos do ESP-IDF v3.3 Conceitos básicos do ESP-IDF v4.2 Monitoramento de mensagens MQTT na nuvem Execução das demonstrações de Bluetooth Low-Energy Usando FreeRTOS em seu próprio projeto para CMake ESP32 Solução de problemas Depuração

Começando com o Espressif ESP32 - DevKit C e o ESP-WROVER-KIT

Importante

Esta é uma versão arquivada do Guia do usuário do FreeRTOS para usar com a versão 202012.00 do FreeRTOS. Para obter a versão mais recente deste documento, consulte o Guia do usuário do FreeRTOS.

Siga este tutorial para começar a usar o Espressif ESP32 - DevKit C equipado com os módulos ESP32 -WROOM-32, -SOLO-1 ou ESP-WROVER e ESP32 o. ESP-WROVER-KIT-VB Para comprar um de nosso AWS parceiro no catálogo de dispositivos parceiros, use os links a seguir:

Essas versões das placas de desenvolvimento são compatíveis com o FreeRTOS.

Para obter mais informações sobre as versões mais recentes dessas placas, consulte ESP32- DevKit C V4 ou ESP-WROVER-KITv4.1 no site da Espressif.

nota

Atualmente, a porta FreeRTOS ESP32 para -WROVER-KIT e DevKit ESP C não suporta o recurso de multiprocessamento simétrico (SMP).

Visão geral

Este tutorial orienta você pelas seguintes etapas:

Conectar sua placa a uma máquina host
Instalar software na máquina host para desenvolver e depurar aplicativos incorporados para a placa do microcontrolador
Fazer a compilação cruzada de um aplicativo de demonstração do FreeRTOS para uma imagem binária
Carregar a imagem binária do aplicativo em sua placa e executar o aplicativo
Interagir com o aplicativo em execução na placa em uma conexão serial para fins de monitoramento e depuração

Pré-requisitos

Antes de começar a usar os FreeRTOS em seu quadro Espressif, você deve configurar sua conta e permissões. 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

Abra a https://portal.aws.amazon.com/billing/inscrição.
Siga as instruções online.

Parte do procedimento de inscrição envolve receber uma ligação ou mensagem de texto e inserir um código de verificação no 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.

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 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 AWS IAM Identity Center, 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

Faça login AWS Management Consolecomo 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 no Guia do usuário do Início de Sessão da AWS .
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 do usuário do IAM.

Criar um usuário com acesso administrativo

Habilita o Centro de Identidade do IAM.

Para obter instruções, consulte Habilitar o AWS IAM Identity Center no Guia do usuário do AWS IAM Identity Center .
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 no Guia AWS IAM Identity Center 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 no Guia Início de Sessão da AWS do usuário.

Atribuir acesso a usuários adicionais

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 no Guia do usuário do AWS IAM Identity Center .
Atribua usuários a um grupo e, em seguida, atribua o acesso de autenticação única ao grupo.

Para obter instruções, consulte Adicionar grupos no Guia do usuário do AWS IAM Identity Center .

Para conceder acesso, adicione as permissões aos seus usuários, grupos ou perfis:

Usuários e grupos em AWS IAM Identity Center:

Crie um conjunto de permissões. Siga as instruções em Criação de um conjunto de permissões no Guia do usuário do AWS IAM Identity Center .
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) 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 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) no Guia do usuário do IAM.

nota

O FreeRTOS versão 202012.00 oferece suporte ao ESP-IDF v3.3. Se você estiver usando uma versão posterior do FreeRTOS, siga as instruções específicas IDFv4 de .2 em. Conceitos básicos do ESP-IDF v4.2

Conceitos básicos do ESP-IDF v3.3

Esta seção mostra como usar o ESP-IDF v3.3 no hardware da Espressif. Para usar o ESP-IDF v4.2, consulte Conceitos básicos do ESP-IDF v4.2.

Configuração do hardware Espressif

Para obter mais informações sobre como configurar o hardware da placa de desenvolvimento ESP32 - DevKit C, consulte o Guia de introdução ESP32 - DevKit C V4.

Para obter informações sobre como configurar o hardware da placa de ESP-WROVER-KIT desenvolvimento, consulte o Guia de introdução da ESP-WROVER-KIT V4.1.

Importante

Quando chegar à seção Get Started dos guias do Espressif, siga as etapas abaixo.

Configuração do ambiente de desenvolvimento

Para se comunicar com sua placa, você deve baixar e instalar uma cadeia de ferramentas.

Configuração da cadeia de ferramentas

nota

O ESP-IDF v3.3 não é compatível com a versão mais recente do compilador. ESP32 Se você já instalou a versão mais recente do ESP32 compilador, desinstale-a e use a versão compatível do compilador incluída na instalação do conjunto de ferramentas. Veja os links nesta seção. Para verificar a versão do compilador, execute o comando a seguir.


xtensa-esp32-elf-gcc --version

Para configurar a cadeia de ferramentas, siga estas instruções do sistema operacional de sua máquina host:

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.

Se você seguiu as instruções de “Get ESP-IDF” em Next Steps, agora ou em uma ocasião anterior, você deve limpar a variável de ambiente IDF_PATH do sistema antes de continuar. Se você seguiu as instruções de “Get ESP-IDF”, essa variável de ambiente é definida automaticamente.

Instalar CMake

O sistema de CMake compilação é necessário para criar os aplicativos de demonstração e teste do FreeRTOS para esse dispositivo. O FreeRTOS oferece suporte às versões 3.13 ou posteriores.

Você pode baixar a versão mais recente CMake do em CMake.org. As distribuições binárias e de origem estão disponíveis.

Para obter mais detalhes sobre o uso CMake com FreeRTOS, consulte. Usando CMake com FreeRTOS

Estabelecimento de uma conexão serial

Para estabelecer uma conexão serial entre sua máquina host e o ESP32 - DevKit C, você deve instalar os drivers CP21 0x USB para UART Bridge VCP. Você pode fazer download desses drivers no Silicon Labs.

Para estabelecer uma conexão serial entre sua máquina host e o ESP32 -WROVER-KIT, você deve instalar alguns drivers de porta COM virtual FTDI. Você pode fazer download desses driver no FTDI.

Para obter mais informações, consulte Estabelecer conexão serial com ESP32. Depois de estabelecer uma conexão serial, anote a porta serial da conexão de sua placa. Você precisará dela durante a compilação da demonstração.

Faça download e configure os FreeRTOS

Depois de configurar seu ambiente, você pode baixar os Freertos GitHubem .Para obter instruções, consulte o arquivo README.md no site. GitHub

Configuração das aplicações de demonstração do FreeRTOS

Se você estiver executando macOS ou Linux, abra um prompt de terminal. Se você estiver executando o Windows, abra mingw32.exe. MinGW é um ambiente de desenvolvimento minimalista para aplicativos nativos do Microsoft Windows.
Para verificar se você tem Python 2.7.10 ou posterior instalado, execute
```
python --version
```
A versão instalada é exibida. Se você não tiver o Python 2.7.10 ou posterior instalado, poderá instalá-lo no site do Python.
Você precisa do AWS Command Line Interface (AWS CLI) para executar AWS IoT comandos. Se você estiver executando o Windows, use o easy_install awscli para instalar o AWS CLI no ambiente mingw32.

Se você estiver executando o macOS ou o Linux, consulte Installing the AWS CLI.
Execute aws configure e configure o AWS CLI com seu ID de chave de AWS acesso, chave de acesso secreta e AWS região. Para obter mais informações, consulte Configurar a AWS CLI.
Use o comando a seguir para instalar o AWS SDK para Python (boto3):
- No Windows, no ambiente mingw32, 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 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)

Para executar o script de configuração

Se você estiver executando macOS ou Linux, abra um prompt de terminal. Se você estiver executando o Windows, abra mingw32.exe.
Navegue até o diretório freertos/tools/aws_config_quick_start e execute
```
python SetupAWS.py setup
```

O script faz o seguinte:

Cria uma coisa, um certificado e uma política da IoT
Anexa a política da IoT ao certificado e o certificado à coisa da AWS IoT
Preenche o aws_clientcredential.h arquivo com seu AWS IoT endpoint, SSID Wi-Fi 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. 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.

Compilar, instalar e executar o projeto de demonstração do FreeRTOS

Você pode usar CMake para gerar os arquivos de compilação, Make para criar o binário do aplicativo e o utilitário IDF do Espressif para atualizar sua placa.

Compilar o FreeRTOS no Linux e macOS (ESP-IDF v3.3)

Se você estiver usando o Windows, consulte Compilar o FreeRTOS no Windows (ESP-IDF v3.3).

Use CMake para gerar os arquivos de compilação e, em seguida, use Make para criar o aplicativo.

Para gerar os arquivos de compilação do aplicativo de demonstração com CMake

Altere os diretórios para a raiz do diretório de download do FreeRTOS.
Use o comando a seguir para gerar os arquivos de compilação.
```
cmake -DVENDOR=espressif -DBOARD=esp32_wrover_kit -DCOMPILER=xtensa-esp32 -S . -B your-build-directory 
```
nota
Se você deseja compilar o aplicativo para depuração, adicione o sinalizador -DCMAKE_BUILD_TYPE=Debug a esse comando.
Se você deseja gerar os arquivos de compilação do aplicativo de teste, adicione o sinalizador -DAFR_ENABLE_TESTS=1.
O código fornecido pelo Espressif usa a pilha de IP leve (lwIP) como a pilha de rede padrão. Para usar a pilha de rede FreeRTOS+TCP em vez disso, adicione o sinalizador ao comando. –DAFR_ESP_FREERTOS_TCP CMake
Para adicionar a dependência do LWIP para código não fornecido pelo fornecedor, adicione as linhas a seguir ao arquivo CMakeLists.txt de dependência,, para seu CMake componente Wi-Fi personalizado.
```
# Add a dependency on the bluetooth espressif component to the common component
set(COMPONENT_REQUIRES lwip)
```

Para criar o aplicativo com Make

Altere os diretórios para o diretório build.
Use o seguinte comando para criar o aplicativo com o Make.
```
make all -j4
```
nota
Você deve gerar os arquivos de compilação com o comando cmake toda vez que alternar entre o projeto aws_demos e o projeto aws_tests.

Compilar o FreeRTOS no Windows (ESP-IDF v3.3)

No Windows, você deve especificar um gerador de compilação para CMake. Caso contrário, o CMake padrão é Visual Studio. O Espressif recomenda oficialmente o sistema do build Ninja, porque ele funciona no Windows, no Linux e no MacOS. Você deve executar CMake comandos em um ambiente nativo do Windows, como cmd ou PowerShell. A execução de CMake comandos em um ambiente Linux virtual, como MSYS2 ou WSL, não é suportada.

Use CMake para gerar os arquivos de compilação e, em seguida, use Make para criar o aplicativo.

Para gerar os arquivos de compilação do aplicativo de demonstração com CMake

Altere os diretórios para a raiz do diretório de download do FreeRTOS.
Use o comando a seguir para gerar os arquivos de compilação.
```
cmake -DVENDOR=espressif -DBOARD=esp32_wrover_kit -DCOMPILER=xtensa-esp32 -GNinja -S . -B build-directory
```
nota
Se você deseja compilar o aplicativo para depuração, adicione o sinalizador -DCMAKE_BUILD_TYPE=Debug a esse comando.
Se você deseja gerar os arquivos de compilação do aplicativo de teste, adicione o sinalizador -DAFR_ENABLE_TESTS=1.
O código fornecido pelo Espressif usa a pilha de IP leve (lwIP) como a pilha de rede padrão. Para usar a pilha de rede FreeRTOS+TCP em vez disso, adicione o sinalizador ao comando. –DAFR_ESP_FREERTOS_TCP CMake
Para adicionar a dependência do LWIP para código não fornecido pelo fornecedor, adicione as linhas a seguir ao arquivo CMakeLists.txt de dependência,, para seu CMake componente Wi-Fi personalizado.
```
# Add a dependency on the bluetooth espressif component to the common component
set(COMPONENT_REQUIRES lwip)
```

Para o build do aplicativo

Altere os diretórios para o diretório build.
Invoque o Ninja para criar o aplicativo.
```
ninja
```
Ou use a CMake interface genérica para criar o aplicativo.
```
cmake --build build-directory
```
nota
Você deve gerar os arquivos de compilação com o comando cmake toda vez que alternar entre o projeto aws_demos e o projeto aws_tests.

Instalar e executar o FreeRTOS (ESP-IDF v3.3)

Esta seção mostra como usar o ESP-IDF v3.3 no hardware da Espressif. Para usar o ESP-IDF v4.2, consulte Conceitos básicos do ESP-IDF v4.2.

Use o utilitário IDF da Espressif (freertos/vendors/espressif/esp-idf/tools/idf.py) para atualizar sua placa, executar o aplicativo e visualizar os logs.

Para apagar a atualização da placa, acesse o diretório freertos e use o seguinte comando.


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

Para atualizar o binário do aplicativo para sua placa, use make


make flash

Você também pode usar o script do IDF para atualizar sua placa:


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

Para monitorar:


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

nota

Você pode combinar esses comandos. Por exemplo:


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

Conceitos básicos do ESP-IDF v4.2

Esta seção mostra como usar o ESP-IDF v4.2 no hardware da Espressif. Para usar o ESP-IDF v3.3, consulte Conceitos básicos do ESP-IDF v3.3.

nota

Os comandos do Linux neste tutorial exigem o uso do shell Bash.

Configuração do hardware Espressif

Para obter informações sobre como configurar o hardware da placa de desenvolvimento ESP32 - DevKit C, consulte o Guia de introdução ESP32 - DevKit C V4.

Para obter informações sobre como configurar o hardware da placa de ESP-WROVER-KIT desenvolvimento, consulte o Guia de introdução da ESP-WROVER-KIT V4.1.

Importante

Ao chegar na seção Começar a usar dos guias do Espressif, pare e retorne para as instruções desta página.

Configuração do ambiente de desenvolvimento

Para se comunicar com sua placa, você deve baixar e instalar uma cadeia de ferramentas.

Configuração da cadeia de ferramentas

Para configurar a cadeia de ferramentas, siga estas instruções do sistema operacional de sua máquina host:

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.

Concluir a instalação (Linux/macOS)

O instalador do ESP-IDF para Windows instala todas as ferramentas necessárias. As plataformas Linux e macOS exigem uma etapa adicional para concluir a instalação.

Abrir a janela de linha de comando
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
```
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
```

Estabelecimento de uma conexão serial

Para estabelecer uma conexão serial entre sua máquina host e o ESP32 -WROVER-KIT, você deve instalar o driver da porta COM virtual FTDI. Você pode fazer download desse driver no FTDI.

Faça download e configure os FreeRTOS

Depois de configurar seu ambiente, você pode baixar os FreeRTOS em. GitHub Para obter instruções, consulte o arquivo README.md no site. GitHub

Configuração das aplicações de demonstração do FreeRTOS

Se você estiver executando macOS ou Linux, abra um prompt de terminal. Se você estiver executando o Windows, abra mingw32.exe. ( MinGW é um ambiente de desenvolvimento minimalista para aplicativos nativos do Microsoft Windows.)
Para verificar se você tem o Python3 instalado, execute
```
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.
Você precisa do AWS Command Line Interface (AWS CLI) para executar AWS IoT comandos. Se você estiver executando o Windows, use o easy_install awscli para instalar o AWS CLI no ambiente mingw32.

Se você estiver executando o macOS ou o Linux, consulte Installing the AWS CLI.
Executar
```
aws configure
```
e configure-o AWS CLI com seu ID de chave de AWS acesso, chave de acesso secreta e AWS região padrão. Para obter mais informações, consulte Configurar a AWS CLI.
Use o comando a seguir para instalar o AWS SDK para Python (boto3):
- No Windows, no ambiente mingw32, execute
```
easy_install boto3
```
- No macOS ou Linux, execute
```
pip install tornado nose --user
```
  e depois execute
```
pip install boto3 --user
```

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)

Para executar o script de configuração

Se você estiver executando macOS ou Linux, abra um prompt de terminal. Se você estiver executando o Windows, abra o arquivo mingw32.exe.
Navegue até o diretório freertos/tools/aws_config_quick_start e execute
```
python SetupAWS.py setup
```

O script faz o seguinte:

Cria uma coisa, um certificado e uma política da IoT
Anexa a política da IoT ao certificado e o certificado à coisa da AWS IoT
Preenche o aws_clientcredential.h arquivo com seu AWS IoT endpoint, SSID Wi-Fi 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. 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.

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.

Compilar e instalar o 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" comidf.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

Navegue até a raiz do diretório de downloads do FreeRTOS.
Na janela da linha de comando, insira o comando a seguir para adicionar as ferramentas de ESP-IDF ao PATH do seu terminal.

Windows
```
vendors\espressif\esp-idf\export.bat
```
Linux / macOS
```
source vendors/espressif/esp-idf/export.sh
```

Configure o cmake no diretório build e compile a imagem do firmware com o comando a seguir.


idf.py -DVENDOR=espressif -DBOARD=esp32_wrover_kit -DCOMPILER=xtensa-esp32 build

O resultado deverá ser parecido com o que segue.


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'

Se não houver erros, a compilação gerará os arquivos .bin binários do firmware.

Apague a memória instalada da placa de desenvolvimento com o comando a seguir.
```
idf.py erase_flash 
```
Use o script idf.py para instalar o binário da aplicação na placa.
```
idf.py flash
```
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

nota

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 do 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 ou sistema de compilação Ninja.

Como compilar e instalar o projeto

Em uma janela da linha de comando, navegue até o diretório raiz de downloads do FreeRTOS.
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
```

Insira o comando a seguir para gerar os arquivos de compilação.

Com Makefiles da Unix


cmake -DVENDOR=espressif -DBOARD=esp32_wrover_kit -DCOMPILER=xtensa-esp32 -S . -B ./YOUR_BUILD_DIRECTORY -DAFR_ENABLE_ALL_MODULES=1 -DAFR_ENABLE_TESTS=0

Com 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

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

Monitoramento de mensagens MQTT na nuvem

Você pode usar o cliente MQTT no AWS IoT console para monitorar as mensagens que seu dispositivo envia para a AWS nuvem.

Para assinar o tópico MQTT com o cliente AWS IoT MQTT

Navegue até o console do AWS IoT.
No painel de navegação, escolha Test (Teste) para abrir o cliente MQTT.
Em Tópico de inscrição, insira your-thing-name/example/topic e selecione Inscreva-se no tópico.

Execução das demonstrações de Bluetooth Low-Energy

O FreeRTOS oferece suporte à conectividade Bluetooth Low Energy.

Para executar o projeto de demonstração do FreeRTOS no Bluetooth Low Energy, você precisa executar a aplicação de demonstração do SDK móvel de Bluetooth Low Energy do FreeRTOS em um dispositivo móvel Android ou iOS.

Como configurar a aplicação de demonstração do SDK móvel de Bluetooth Low Energy do FreeRTOS

Siga as instruções em Dispositivos Bluetooth Mobile SDKs for FreeRTOS para baixar e instalar o SDK para sua plataforma móvel em seu computador host.
Siga as instruções em Aplicativo de demonstração do SDK móvel de Bluetooth Low Energy do FreeRTOS para configurar o aplicativo móvel de demonstração em seu dispositivo móvel.

Para obter instruções sobre como executar a demonstração do MQTT por Bluetooth Low Energy na sua placa, consulte o Aplicativo de demonstração do MQTT por Bluetooth Low Energy.

Para obter instruções sobre como executar a demonstração do provisionamento de Wi-Fi na sua placa, consulte o aplicativo de demonstração do provisionamento de Wi-Fi.

Usando FreeRTOS em seu próprio projeto para CMake ESP32

Se quiser consumir Freertos em seu CMake próprio projeto, você pode configurá-lo como um subdiretório e construí-lo junto com seu aplicativo. Primeiro, obtenha uma cópia dos FreeRTOS em. GitHub Você também pode configurá-lo como um submódulo Git com o comando a seguir para que seja mais fácil atualizar no futuro.


git submodule add -b release https://github.com/aws/amazon-freertos.git freertos

Se uma versão mais recente for lançada, você poderá atualizar sua cópia local com esses 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"

Se o seu projeto tem a seguinte estrutura de diretórios:


- freertos (the copy that you obtained from GitHub or the AWS IoT console)
- src
  - main.c (your application code)
- CMakeLists.txt

A seguir há um exemplo do arquivo CMakeLists.txt de nível superior que pode ser usado para compilar sua aplicação junto com o FreeRTOS.

Para criar o projeto, execute os CMake comandos a seguir. Verifique se o ESP32 compilador está na variável de ambiente PATH.


cmake -S . -B build-directory -DCMAKE_TOOLCHAIN_FILE=freertos/tools/cmake/toolchains/xtensa-esp32.cmake -GNinja


cmake --build build

Para instalar a aplicação na sua placa, execute o comando a seguir.


cmake --build build-directory --target flash

Uso de componentes do FreeRTOS

Depois de executar CMake, você pode encontrar todos os componentes disponíveis na saída resumida. Isso deve ser parecido com a seguinte exemplo.


====================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:
=========================================================================

Você pode fazer referência a qualquer componente da lista Modules to build. Para vinculá-los à sua aplicação, coloque o namespace AFR:: na frente do nome, por exemplo, AFR::mqtt, AFR::ota e assim por diante.

Adicionar componentes personalizados ao ESP-IDF

Você pode adicionar mais componentes ao ambiente de compilação ESP-IDF. Por exemplo, supondo que você deseja adicionar um componente chamado example_component e seu projeto tenha a seguinte aparência


- freertos
- components
  - example_component
    - include
      - example_component.h
    - src
      - example_component.c
    - CMakeLists.txt
- src
  - main.c
- CMakeLists.txt

veja a seguir um exemplo do arquivo CMakeLists.txt do seu componente.

Você também pode especificar dependências usando a CMake função target_link_libraries padrão. Observe que o nome de destino do seu componente é armazenado na variável COMPONENT_TARGET, definida pelo ESP-IDF.

Para componentes ESP, isso é feito definindo duas variáveis, COMPONENT_REQUIRES e COMPONENT_PRIV_REQUIRES. Consulte Build System (CMake) no Guia de Programação ESP-IDF v4.2.

Em seguida, no arquivo CMakeLists.txt de nível superior, você diz ao ESP-IDF onde encontrar esses componentes. Adicione as seguintes linhas em qualquer lugar antes de add_subdirectory(freertos).

Esse componente agora é vinculado automaticamente ao código da aplicação por padrão. Você deve poder incluir seus arquivos de cabeçalho e chamar as funções que eles definem.

Substituição de configurações do FreeRTOS

Atualmente, não há uma abordagem bem definida para redefinir as configurações fora da árvore de origem do FreeRTOS. Por padrão, CMake procurará os freertos/vendors/espressif/boards/esp32/aws_demos/config_files/ freertos/demos/include/ diretórios e. No entanto, você pode usar uma solução alternativa para dizer ao compilador para procurar outros diretórios primeiro. Por exemplo, você pode adicionar outra pasta para configurações do FreeRTOS.


- freertos
- freertos-configs
  - aws_clientcredential.h
  - aws_clientcredential_keys.h
  - iot_mqtt_agent_config.h
  - iot_config.h
- components
- src
- CMakeLists.txt

Os arquivos em freertos-configs são copiados dos diretórios freertos/vendors/espressif/boards/esp32/aws_demos/config_files/ e freertos/demos/include/. No seu arquivo CMakeLists.txt de nível superior, adicione esta linha antes de add_subdirectory(freertos) para que o compilador pesquise este diretório primeiro.


include_directories(BEFORE freertos-configs)

Fornecimento de seu próprio sdkconfig para ESP-IDF

Caso queira fornecer a sua própriasdkconfig.default, você pode definir a CMake variávelIDF_SDKCONFIG_DEFAULTS, na linha de comando:


cmake -S . -B build-directory -DIDF_SDKCONFIG_DEFAULTS=path_to_your_sdkconfig_defaults -DCMAKE_TOOLCHAIN_FILE=freertos/tools/cmake/toolchains/xtensa-esp32.cmake -GNinja

Se não for especificado um local para seu próprio arquivo sdkconfig.default, o FreeRTOS usará o arquivo padrão localizado em freertos/vendors/espressif/boards/esp32/aws_demos/sdkconfig.defaults.

Resumo

Se você tem um projeto com um componente chamado example_component e desejar substituir algumas configurações, aqui está um exemplo completo do arquivo CMakeLists.txt de nível 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 obter mais informações sobre o sistema de compilação do Espressif com CMake, consulte Sistema de compilação nos guias da API do Espressif

Solução de problemas

Se você estiver executando o macOS e o sistema operacional não o reconhecer ESP-WROVER-KIT, verifique se você não tem os drivers D2XX instalados. Para desinstalá-los, siga as instruções em FTDI Drivers Installation Guide for macOS X.
O utilitário de monitor fornecido pelo ESP-IDF (e chamado usando make monitor) ajuda a decodificar endereços. Por esse motivo, ele pode ajudar você a obter alguns backtraces significativos caso a aplicação falhe. Para obter mais informações, consulte Decodificação de endereços automática no site da Espressif.
Também é possível habilitar GDBstub a comunicação com o gdb sem a necessidade de nenhum hardware JTAG especial. Para obter mais informações, consulte Lançamento do GDB com GDBStub no site do Espressif.
Para obter informações sobre a configuração de um ambiente com base em OpenOCD se a depuração com base em hardware JTAG for necessária, consulte Depuração JTAG no site da Espressif.
Se não for possível instalar pyserial usando pip no macOS, faça download no site do pyserial.
Se a placa for reiniciada continuamente, tente apagar a instalação digitando o seguinte comando no terminal.
```
make erase_flash
```
Se você vir erros ao executar idf_monitor.py, use Python 2.7.
As bibliotecas necessárias de ESP-IDF estão incluídas no FreeRTOS, portanto, não é necessário baixá-las externamente. Se a variável de ambiente IDF_PATH estiver definida, recomendamos que faça a limpeza dela antes de compilar o FreeRTOS.
No Windows, pode levar de 3 a 4 minutos para o projeto ser criado. Você pode usar o comutador -j4 no comando make para reduzir o tempo de compilação:
```
make flash monitor -j4
```
Se o dispositivo tiver problemas para se conectar AWS IoT, abra o aws_clientcredential.h arquivo e verifique se as variáveis de configuração estão definidas corretamente no arquivo. clientcredentialMQTT_BROKER_ENDPOINT[]deveria ser assim1234567890123-ats.iot.us-east-1.amazonaws.com.
Se você estiver seguindo as etapas em Usando FreeRTOS em seu próprio projeto para CMake ESP32 e vir erros de referência indefinidos no vinculador, em geral, a causa é a falta de bibliotecas dependentes ou demonstrações. Para adicioná-los, atualize o CMakeLists.txt arquivo (no diretório raiz) usando a CMake função padrãotarget_link_libraries.

O ESP-IDF v4.2 é compatível com o uso da cadeia de ferramentas xtensa-esp32-elf-gcc 8.2.0.. Se você estiver usando uma versão anterior da cadeia de ferramentas Xtensa, baixe a versão necessária.

Se você vir um log de erros como o seguinte sobre dependências de python que não estão sendo atendidas no ESP-IDF v4.2.


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 as dependências do Python na sua plataforma usando o seguinte comando do Python:


root/vendors/espressif/esp-idf/requirements.txt

Para obter mais informações sobre solução de problemas, consulte Solução de problemas de conceitos básicos.

Depuração

Código de depuração no Espressif ESP32 - DevKit C e (ESP-IDF v3.3) ESP-WROVER-KIT

Esta seção mostra como depurar o hardware da Espressif usando o ESP-IDF v3.3. Para depurar usando o ESP-IDF v4.2, consulte Código de depuração no Espressif ESP32 - DevKit C e (ESP-IDF v4.2) ESP-WROVER-KIT.

Você precisa de um cabo JTAG para USB. Usamos um cabo USB para MPSSE (por exemplo, o FTDI C232HM-DDHSL-0).

Configuração do ESP- DevKit C JTAG

Para o cabo FTDI C232HM-DDHSL-0, essas são as conexões com o DevKitC. ESP32

Cor do fio C232HM-DDHSL-0	ESP32 Pino GPIO	Nome do sinal JTAG
Marrom (pino 5)	IO14	TMS
Amarelo (pino 3)	IO12	TDI
Preto (pino 10)	GND	GND
Laranja (pino 2)	IO13	TCK
Verde (pino 4)	IO15	TDO

ESP-WROVER-KIT Configuração do JTAG

Para o cabo FTDI C232HM-DDHSL-0, essas são as conexões com o -WROVER-KIT. ESP32

Cor do fio C232HM-DDHSL-0	ESP32 Pino GPIO	Nome do sinal JTAG
Marrom (pino 5)	IO14	TMS
Amarelo (pino 3)	IO12	TDI
Laranja (pino 2)	IO13	TCK
Verde (pino 4)	IO15	TDO

Essas tabelas foram desenvolvidas na planilha FTDI C232HM-DDHSL-0. Para obter mais informações, consulte "Detalhes mecânicos e conexão de cabos C232HM MPSSE" na planilha.

Para habilitar o JTAG no ESP-WROVER-KIT, coloque os jumpers nos pinos TMS, TDO, TDI, TCK e S_TDI, conforme mostrado aqui.

Depuração no Windows (ESP-IDF v3.3)

Para configurar para depuração no Windows

Conecte o lado USB do FTDI C232HM-DDHSL-0 ao computador e o outro lado como descrito em Código de depuração no Espressif ESP32 - DevKit C e (ESP-IDF v3.3) ESP-WROVER-KIT. O dispositivo FTDI C232HM-DDHSL-0 deve aparecer no Device Manager (Gerenciador de dispositivos) em Universal Serial Bus Controllers (Controladores USB).
Na lista de dispositivos USB, clique com o botão direito do mouse no dispositivo C232HM-DDHSL-0 dispositivo e selecione Properties (Propriedades).

nota
O dispositivo pode estar listado como USB Serial Port (Porta serial USB).

Na janela de propriedades, escolha a guia Details (Detalhes) para ver as propriedades do dispositivo. Se o dispositivo não estiver listado, instale o driver do Windows para FTDI C232HM-DDHSL-0.
Na guia Detalhes, escolha Propriedade e, em seguida, escolha Hardware IDs. Você deve ver algo parecido com isto no campo Valor.
```
FTDIBUS\COMPORT&VID_0403&PID_6014
```
Neste exemplo, o ID do fornecedor é 0403 e o ID do produto é 6014.

Verifique se eles IDs correspondem à IDs entradaprojects/espressif/esp32/make/aws_demos/esp32_devkitj_v1.cfg. Eles IDs são especificados em uma linha que começa com, ftdi_vid_pid seguida por uma ID do fornecedor e uma ID do produto.
```
ftdi_vid_pid 0x0403 0x6014
```
Faça download do OpenOCD para Windows.
Descompacte o arquivo C:\ e adicione C:\openocd-esp32\bin ao caminho do sistema.
O OpenOCD requer libusb, que não é instalado por padrão no Windows.

Para instalar o libusb
1. Faça download de zadig.exe.
2. Executar zadig.exe. No menu Options (Opções), escolha List All Devices (Listar todos os dispositivos).
3. No menu suspenso, escolha C232HM-DDHSL-0.
4. No campo de driver de destino, à direita da seta verde, selecione WinUSB.
5. Na lista suspensa no campo de driver de destino, escolha a seta e selecione Instalar driver. Escolha Replace Driver (Substituir driver).
Abra um prompt de comando, navegue até projects/espressif/esp32/make/aws_demos e execute o seguinte comando.

Para ESP32 -WROOM-32 e -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
```
Deixe o prompt de comando aberto.
Abra um novo prompt de comando, navegue até o diretório msys32 e execute mingw32.exe.
No terminal mingw32, navegue até projects/espressif/esp32/make/aws_demos e execute
```
make flash monitor
```
Abra outro terminal mingw32, navegue até projects/espressif/esp32/make/aws_demos e aguarde até que a demonstração comece a ser executada na placa. Quando isso ocorrer, execute xtensa-esp32-elf-gdb -x gdbinit build/aws_demos.elf. O programa deve parar na função main.

nota

ESP32 Ele suporta no máximo dois pontos de ruptura.

Depuração no macOS (ESP-IDF v3.3)

Faça download do driver FTDI para macOS.
Faça download do OpenOCD.
Extraia o arquivo .tar baixado e defina o caminho em .bash_profile como OCD_INSTALL_DIR/openocd-esp32/bin.
Use o comando a seguir para instalar o libusb no macOS.
```
brew install libusb
```
Use o comando a seguir para fazer download do driver da porta serial.
```
sudo kextunload -b com.FTDI.driver.FTDIUSBSerialDriver
```
Se você estiver executando uma versão posterior a 10.9 do macOS, use o comando a seguir para descarregar o driver FTDI da Apple.
```
sudo kextunload -b com.apple.driver.AppleUSBFTDI
```
Use o seguinte comando para obter o ID do produto e o ID do fornecedor do cabo FTDI. Ele lista os dispositivos USB conectados.
```
system_profiler SPUSBDataType
```
A saída de system_profiler deve ser a seguinte.
```
DEVICE:
                            
Product ID: product-ID
Vendor ID: vendor-ID (Future Technology Devices International Limited)
```
Abra o arquivo projects/espressif/esp32/make/aws_demos/esp32_devkitj_v1.cfg. Os IDs do fornecedor e do produto do seu dispositivo são especificados em uma linha que começa com ftdi_vid_pid. Altere o IDs para corresponder ao IDs da system_profiler saída na etapa anterior.
Abra uma janela de terminal, navegue até projects/espressif/esp32/make/aws_demos e use o seguinte comando para executar OpenOCD:

Para ESP32 -WROOM-32 e -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 um novo terminal e use o seguinte comando para carregar o driver de porta serial FTDI.
```
sudo kextload -b com.FTDI.driver.FTDIUSBSerialDriver
```
Navegue até projects/espressif/esp32/make/aws_demos e execute o seguinte comando.
```
make flash monitor
```
Abra um novo terminal, navegue até projects/espressif/esp32/make/aws_demos e execute o seguinte comando.
```
xtensa-esp32-elf-gdb -x gdbinit build/aws_demos.elf
```
O programa deve parar em main().

Depuração no Linux (ESP-IDF v3.3)

Faça download do OpenOCD. Extraia o tarball e siga as instruções de instalação no arquivo readme.
Use o seguinte comando para instalar libusb em Linux.
```
sudo apt-get install libusb-1.0
```
Abra um terminal e digite ls -l /dev/ttyUSB* para listar todos os dispositivos USB conectados ao computador. Isso ajuda você a verificar se as portas USB da placa são reconhecidas pelo sistema operacional. O resultado deverá ser parecido com o que segue.
```
$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
```
Saia e, em seguida, faça login e desligue e ligue a alimentação da placa para que as alterações entrem em vigor. Em um prompt de terminal, liste os dispositivos USB. Certifique-se de que o proprietário do grupo tenha sido alterado de dialout para 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
```
A interface /dev/ttyUSBn com o menor número é usada para comunicação JTAG. A outra interface é roteada para a porta serial (UART) ESP32 do e é usada para carregar o código na memória flash ESP32 do.
Em uma janela de terminal, navegue até projects/espressif/esp32/make/aws_demos e use o seguinte comando para executar OpenOCD:

Para ESP32 -WROOM-32 e -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 outro terminal, navegue até projects/espressif/esp32/make/aws_demos e execute o seguinte comando.
```
make flash monitor
```
Abra outro terminal, navegue até projects/espressif/esp32/make/aws_demos e execute o seguinte comando:
```
xtensa-esp32-elf-gdb -x gdbinit build/aws_demos.elf
```
O programa deve parar em main().

Código de depuração no Espressif ESP32 - DevKit C e (ESP-IDF v4.2) ESP-WROVER-KIT

Esta seção mostra como depurar o hardware da Espressif usando o ESP-IDF v4.2. Para depurar usando o ESP-IDF v3.3, consulte Código de depuração no Espressif ESP32 - DevKit C e (ESP-IDF v3.3) ESP-WROVER-KIT.

Você precisa de um cabo JTAG para USB. Usamos um cabo USB para MPSSE (por exemplo, o FTDI C232HM-DDHSL-0).

Configuração do ESP- DevKit C JTAG

Para o cabo FTDI C232HM-DDHSL-0, essas são as conexões com o DevKitC. ESP32

Cor do fio C232HM-DDHSL-0	ESP32 Pino GPIO	Nome do sinal JTAG
Marrom (pino 5)	IO14	TMS
Amarelo (pino 3)	IO12	TDI
Preto (pino 10)	GND	GND
Laranja (pino 2)	IO13	TCK
Verde (pino 4)	IO15	TDO

ESP-WROVER-KIT Configuração do JTAG

Para o cabo FTDI C232HM-DDHSL-0, essas são as conexões com o -WROVER-KIT. ESP32

Cor do fio C232HM-DDHSL-0	ESP32 Pino GPIO	Nome do sinal JTAG
Marrom (pino 5)	IO14	TMS
Amarelo (pino 3)	IO12	TDI
Laranja (pino 2)	IO13	TCK
Verde (pino 4)	IO15	TDO

Essas tabelas foram desenvolvidas na planilha FTDI C232HM-DDHSL-0. Para obter mais informações, consulte "Detalhes mecânicos e conexão de cabos C232HM MPSSE" na planilha.

Para habilitar o JTAG no ESP-WROVER-KIT, coloque os jumpers nos pinos TMS, TDO, TDI, TCK e S_TDI, conforme mostrado aqui.

Depuração no Windows (ESP-IDF v4.2)

Para configurar para depuração no Windows

Conecte o lado USB do FTDI C232HM-DDHSL-0 ao computador e o outro lado como descrito em Código de depuração no Espressif ESP32 - DevKit C e (ESP-IDF v4.2) ESP-WROVER-KIT. O dispositivo FTDI C232HM-DDHSL-0 deve aparecer no Device Manager (Gerenciador de dispositivos) em Universal Serial Bus Controllers (Controladores USB).
Na lista de dispositivos USB, clique com o botão direito do mouse no dispositivo C232HM-DDHSL-0 dispositivo e selecione Properties (Propriedades).

nota
O dispositivo pode estar listado como USB Serial Port (Porta serial USB).

Na janela de propriedades, escolha a guia Details (Detalhes) para ver as propriedades do dispositivo. Se o dispositivo não estiver listado, instale o driver do Windows para FTDI C232HM-DDHSL-0.
Na guia Detalhes, escolha Propriedade e, em seguida, escolha Hardware IDs. Você deve ver algo parecido com isto no campo Valor.
```
FTDIBUS\COMPORT&VID_0403&PID_6014
```
Neste exemplo, o ID do fornecedor é 0403 e o ID do produto é 6014.

Verifique se eles IDs correspondem à IDs entradaprojects/espressif/esp32/make/aws_demos/esp32_devkitj_v1.cfg. Eles IDs são especificados em uma linha que começa com, ftdi_vid_pid seguida por uma ID do fornecedor e uma ID do produto.
```
ftdi_vid_pid 0x0403 0x6014
```
Faça download do OpenOCD para Windows.
Descompacte o arquivo C:\ e adicione C:\openocd-esp32\bin ao caminho do sistema.
O OpenOCD requer libusb, que não é instalado por padrão no Windows.

Para instalar o libusb
1. Faça download de zadig.exe.
2. Executar zadig.exe. No menu Options (Opções), escolha List All Devices (Listar todos os dispositivos).
3. No menu suspenso, escolha C232HM-DDHSL-0.
4. No campo de driver de destino, à direita da seta verde, selecione WinUSB.
5. Na lista suspensa no campo de driver de destino, escolha a seta e selecione Instalar driver. Escolha Replace Driver (Substituir driver).
Abra outro terminal, navegue até a raiz do diretório de download do FreeRTOS e execute o seguinte comando.
```
idf.py openocd 
```
Deixe o prompt de comando aberto.
Abra outro terminal, navegue até a raiz do diretório de download do FreeRTOS e execute
```
idf.py flash monitor
```
Abra outro prompt de comando, navegue até a raiz do diretório de download do FreeRTOS e espere até que a demonstração comece a ser executada na placa. Quando isso ocorrer, execute
```
idf.py gdb 
```
O programa deve parar na função main.

nota

ESP32 Ele suporta no máximo dois pontos de ruptura.

Depuração no macOS (ESP-IDF v4.2)

Faça download do driver FTDI para macOS.
Faça download do OpenOCD.
Extraia o arquivo .tar baixado e defina o caminho em .bash_profile como OCD_INSTALL_DIR/openocd-esp32/bin.
Use o comando a seguir para instalar o libusb no macOS.
```
brew install libusb
```
Use o comando a seguir para fazer download do driver da porta serial.
```
sudo kextunload -b com.FTDI.driver.FTDIUSBSerialDriver
```
Se você estiver executando uma versão posterior a 10.9 do macOS, use o comando a seguir para descarregar o driver FTDI da Apple.
```
sudo kextunload -b com.apple.driver.AppleUSBFTDI
```
Use o seguinte comando para obter o ID do produto e o ID do fornecedor do cabo FTDI. Ele lista os dispositivos USB conectados.
```
system_profiler SPUSBDataType
```
A saída de system_profiler deve ser a seguinte.
```
DEVICE:
                            
Product ID: product-ID
Vendor ID: vendor-ID (Future Technology Devices International Limited)
```
Abra o arquivo projects/espressif/esp32/make/aws_demos/esp32_devkitj_v1.cfg. Os IDs do fornecedor e do produto do seu dispositivo são especificados em uma linha que começa com ftdi_vid_pid. Altere o IDs para corresponder ao IDs da system_profiler saída na etapa anterior.
Abra uma janela do terminal, navegue até a raiz do diretório de download do FreeRTOS e use o seguinte comando para executar o OpenOCD.
```
idf.py openocd 
```
Deixe essa janela do terminal aberta.
Abra um novo terminal e use o seguinte comando para carregar o driver de porta serial FTDI.
```
sudo kextload -b com.FTDI.driver.FTDIUSBSerialDriver
```
Navegue até a raiz do diretório de downloads do FreeRTOS e execute
```
idf.py flash monitor
```
Abra outro terminal, navegue até a raiz do diretório de download do FreeRTOS e execute
```
idf.py gdb 
```
O programa deve parar em main.

Depuração no Linux (ESP-IDF v4.2)

Faça download do OpenOCD. Extraia o tarball e siga as instruções de instalação no arquivo readme.
Use o seguinte comando para instalar libusb em Linux.
```
sudo apt-get install libusb-1.0
```
Abra um terminal e digite ls -l /dev/ttyUSB* para listar todos os dispositivos USB conectados ao computador. Isso ajuda você a verificar se as portas USB da placa são reconhecidas pelo sistema operacional. O resultado deverá ser parecido com o que segue.
```
$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
```
Saia e, em seguida, faça login e desligue e ligue a alimentação da placa para que as alterações entrem em vigor. Em um prompt de terminal, liste os dispositivos USB. Certifique-se de que o proprietário do grupo tenha sido alterado de dialout para 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
```
A interface /dev/ttyUSBn com o menor número é usada para comunicação JTAG. A outra interface é roteada para a porta serial (UART) ESP32 do e é usada para carregar o código na memória flash ESP32 do.
Na janela do terminal, navegue até a raiz do diretório de download do FreeRTOS e use o seguinte comando para executar o OpenOCD.
```
idf.py openocd 
```
Abra outro terminal, navegue até a raiz do diretório de download do FreeRTOS e execute o seguinte comando.
```
idf.py flash monitor
```
Abra outro terminal, navegue até a raiz do diretório de download do FreeRTOS e execute o seguinte comando.
```
idf.py gdb 
```
O programa deve parar em main().

Atenção O Javascript está desativado ou não está disponível no seu navegador.

Para usar a documentação da AWS, o Javascript deve estar ativado. Consulte as páginas de Ajuda do navegador para obter instruções.

Convenções do documento

Microchip ATECC6 08A Secure Element com simulador de Windows

Expressif - ESP32 WROOM-32SE

Começando com o Espressif ESP32 - DevKit C e o ESP-WROVER-KIT

Importante

nota

Visão geral

Pré-requisitos

Inscreva-se para um Conta da AWS

Para se inscrever em um Conta da AWS

Criar um usuário com acesso administrativo

Proteja seu Usuário raiz da conta da AWS

Criar um usuário com acesso administrativo

Iniciar sessão como o usuário com acesso administrativo

Atribuir acesso a usuários adicionais

nota

Conceitos básicos do ESP-IDF v3.3

Configuração do hardware Espressif

Importante

Configuração do ambiente de desenvolvimento

Configuração da cadeia de ferramentas

nota

Importante

Instalar CMake

Estabelecimento de uma conexão serial

Faça download e configure os FreeRTOS

Configuração das aplicações de demonstração do FreeRTOS

Para executar o script de configuração

nota

Compilar, instalar e executar o projeto de demonstração do FreeRTOS

Compilar o FreeRTOS no Linux e macOS (ESP-IDF v3.3)

Para gerar os arquivos de compilação do aplicativo de demonstração com CMake

nota

Para criar o aplicativo com Make

nota

Compilar o FreeRTOS no Windows (ESP-IDF v3.3)

Para gerar os arquivos de compilação do aplicativo de demonstração com CMake

nota

Para o build do aplicativo

nota

Instalar e executar o FreeRTOS (ESP-IDF v3.3)

nota

Conceitos básicos do ESP-IDF v4.2

nota

Configuração do hardware Espressif

Importante

Configuração do ambiente de desenvolvimento

Configuração da cadeia de ferramentas

Importante

Concluir a instalação (Linux/macOS)

Estabelecimento de uma conexão serial

Faça download e configure os FreeRTOS

Configuração das aplicações de demonstração do FreeRTOS

Para executar o script de configuração

nota

Compilação, atualização e execução do projeto de demonstração do FreeRTOS usando o script idf.py

Compilar e instalar o FreeRTOS no Windows, Linux e macOS (ESP-IDF v4.2)

nota

Como compilar e instalar o projeto

nota

nota

Crie e atualize Freertos com CMake

Como compilar e instalar o projeto

Monitoramento de mensagens MQTT na nuvem

Para assinar o tópico MQTT com o cliente AWS IoT MQTT

Execução das demonstrações de Bluetooth Low-Energy

Como configurar a aplicação de demonstração do SDK móvel de Bluetooth Low Energy do FreeRTOS

Usando FreeRTOS em seu próprio projeto para CMake ESP32

Uso de componentes do FreeRTOS

Adicionar componentes personalizados ao ESP-IDF

Substituição de configurações do FreeRTOS

Fornecimento de seu próprio sdkconfig para ESP-IDF

Resumo

Solução de problemas

Depuração

Código de depuração no Espressif ESP32 - DevKit C e (ESP-IDF v3.3) ESP-WROVER-KIT

Configuração do ESP- DevKit C JTAG

ESP-WROVER-KIT Configuração do JTAG

Depuração no Windows (ESP-IDF v3.3)

Para configurar para depuração no Windows

nota

nota

Depuração no macOS (ESP-IDF v3.3)