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á.
Introdução ao Espressif ESP32 - DevKit C e ao ESP-WROVER-KIT
Importante
Essa integração de referência está hospedada no RTOS repositório Amazon-Free, que está obsoleto. Recomendamos começar aqui ao criar um novo projeto. Se você já tem um RTOS projeto gratuito existente com base no repositório Amazon-FreeRTOS, agora obsoleto, consulte o. Guia de migração do RTOS repositório Github gratuito da Amazon
nota
Para explorar como integrar bibliotecas e demonstrações RTOS modulares gratuitas em seu próprio IDF projeto Espressif, consulte nossa integração de referência em destaque para ESP32
Siga este tutorial para começar a usar o Espressif ESP32 - DevKit C equipado com os módulos ESP32 - WROOM -32, ESP32 - SOLO -1 ou ESP - WROVER e 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 suportadas no FreeRTOS.
Para obter mais informações sobre as versões mais recentes dessas placas, consulte ESP32- DevKit C V4 ou ESP-WROVER-KITv4.1
nota
Atualmente, a RTOS porta livre para ESP32 - WROVER - KIT e ESP DevKit 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 seu microcontrolador.
-
Compilação cruzada de um aplicativo de RTOS demonstração gratuito em 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 o Free RTOS em seu quadro Espressif, você deve configurar sua AWS conta e permissões.
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
Abra a https://portal.aws.amazon.com/billing/inscrição.
Siga as instruções online.
Parte do procedimento de inscrição envolve receber uma chamada telefônica 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 atributos 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
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 Console
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 sua 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 .
-
Ative a autenticação multifator (MFA) para seu usuário root.
Para obter instruções, consulte Habilitar um MFA dispositivo virtual para seu usuário Conta da AWS root (console) no Guia IAM do usuário.
Criar um usuário com acesso administrativo
-
Ative o IAM Identity Center.
Para obter instruções, consulte Habilitar AWS IAM Identity Center no Guia do usuário do AWS IAM Identity Center .
-
No IAM Identity Center, conceda 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 entrar com seu usuário do IAM Identity Center, use o login URL que foi enviado ao seu endereço de e-mail quando você criou o usuário do IAM Identity Center.
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 IAM Identity Center, crie um conjunto de permissões que siga as melhores práticas de aplicação de permissões com privilégios mínimos.
Para obter instruções, consulte Create a permission set 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 Add groups 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 IAM por meio de um provedor de identidade:
Crie um perfil para a federação de identidades. Siga as instruções em Criar uma função para um provedor de identidade terceirizado (federação) no Guia IAM do usuário.
-
IAMusuários:
-
Crie um perfil que seu usuário possa assumir. Siga as instruções em Criar uma função para um IAM usuário no Guia do IAM usuário.
-
(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 Adicionar permissões a um usuário (console) no Guia do IAM usuário.
-
Conceitos básicos
nota
Os comandos do Linux neste tutorial exigem o uso do shell Bash.
-
Configuração de hardware da 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.
-
-
Baixe Amazon gratuitamente RTOS em GitHub
. (Para obter instruções, consulte o READMEarquivo.md .) -
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 sua própria versão do Free RTOS Kernel integrada como um componente, o Amazon Free RTOS inclui uma versão personalizada do ESP - IDF v4.2 que tem o Free RTOS Kernel 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
-
Baixe ESP - IDF é o Universal Online Installer
para Windows. -
Execute o Instalador online universal.
-
Ao chegar à etapa Baixar ou usar ESP - IDF, selecione Usar um IDF diretório existente ESP - e defina Escolher IDF diretório existente ESP - como
.freertos
/vendors/espressif/esp-idf -
Concluir a instalação.
macOS
-
Siga as instruções na Configuração padrão dos pré-requisitos do Toolchain (ESP- IDF v4.2
) para macOS. Importante
Ao acessar as instruções “Obter ESP -IDF” em Próximas etapas, pare e retorne às instruções nesta página.
-
Abra a janela de linha de comando.
-
Navegue até o diretório de RTOS download gratuito e, em seguida, execute o script a seguir para baixar e instalar o conjunto de ferramentas espressif em sua plataforma.
vendors/espressif/esp-idf/install.sh
-
Adicione as IDF ferramentas ESP - toolchain ao caminho do seu terminal com o comando a seguir.
source vendors/espressif/esp-idf/export.sh
Linux
-
Siga as instruções na Configuração padrão dos pré-requisitos do Toolchain (ESP- IDF v4.2
) para Linux. Importante
Ao acessar as instruções “Obter ESP -IDF” em Próximas etapas, pare e retorne às instruções nesta página.
-
Abra a janela de linha de comando.
-
Navegue até o diretório de RTOS download gratuito e, em seguida, execute o script a seguir para baixar e instalar o conjunto de ferramentas Espressif em sua plataforma.
vendors/espressif/esp-idf/install.sh
-
Adicione as IDF ferramentas ESP - toolchain 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 - DevKit C, você deve instalar os VCP drivers CP21 0x USB no UART Bridge. 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 o driver da COM porta FTDI virtual. Você pode baixar esse driver em FTDI
. -
Siga as etapas para estabelecer uma conexão serial com ESP32
. -
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.
-
Configure os aplicativos de RTOS demonstração gratuitos
Para este tutorial, o arquivo RTOS de configuração gratuito está localizado em
. (Por exemplo, se freertos
/vendors/espressif/boards/board-name
/aws_demos/config_files/FreeRTOSConfig.hAFR_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
-
Se você estiver executando macOS ou Linux, abra um prompt de terminal. Se você estiver executando o Windows, abra o aplicativo "ESP- IDF 4.xCMD" (se você incluiu essa opção ao instalar o conjunto de IDF ferramentas ESP -) ou o aplicativo “Prompt de comando”, caso contrário.
-
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 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 o AWS CLI no aplicativo “Command” ou "ESP- IDF 4.xCMD”.Se você estiver executando o macOS ou o Linux, consulte Instalando o. 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 Configurando o. AWS CLI
-
Use o comando a seguir para instalar o AWS SDK for Python (boto3):
-
No Windows, no aplicativo “Command” ou "ESP- IDF 4.xCMD", execute
pip install boto3 --user
nota
Consulte os detalhes na documentação do boto3
. -
No macOS ou Linux, execute
pip install tornado nose --user
e depois execute
pip install boto3 --user
Gratuito RTOS inclui o
SetupAWS.py
script para facilitar a configuração da sua placa Espressif à qual se conectar. AWS IoT Para configurar o script, abra
e defina os seguintes atributos:freertos
/tools/aws_config_quick_start/configure.jsonafr_source_dir
-
O caminho completo para o diretório
no computador. Certifique-se de usar barras para especificar esse caminho.freertos
thing_name
-
O nome que você deseja atribuir à AWS IoT coisa que representa seu quadro.
wifi_ssid
-
O SSID da sua 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
(WEPsegurança) -
eWiFiSecurityWPA
(WPAsegurança) -
eWiFiSecurityWPA2
(WPA2segurança)
-
-
-
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 aplicativo "ESP- IDF 4.xCMD" ou “Command”.
-
Navegue até o diretório
e executefreertos
/tools/aws_config_quick_startpython SetupAWS.py setup
O script faz o seguinte:
-
Cria uma coisa, um certificado e uma política de IoT.
-
Anexa a política de IoT ao certificado e o certificado à coisa do AWS IoT .
-
Preenche o
aws_clientcredential.h
arquivo com seu AWS IoT endpointSSID, 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
, consulteREADME.md
no diretório
.freertos
/tools/aws_config_quick_start -
-
Monitorando MQTT mensagens na nuvem
Antes de executar o projeto de RTOS demonstração gratuito, você pode configurar o MQTT cliente no AWS IoT console para monitorar as mensagens que seu dispositivo envia para a AWS nuvem.
Para assinar o MQTT tópico com o AWS IoT MQTT cliente
-
Navegue até o console do AWS IoT
. -
No painel de navegação, escolha Teste e, em seguida, escolha Cliente MQTT de teste.
-
Em Tópico de inscrição, insira
e selecione Inscreva-se no tópico.your-thing-name
/example/topic
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.
Crie, atualize e execute o projeto de RTOS demonstração gratuito usando o script idf.py
Você pode usar o IDF utilitário Espressif (idf.py
) para criar o projeto e atualizar 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
Crie e atualize gratuitamente RTOS no Windows, Linux e macOS (ESP- IDF v4.2)
-
Navegue até a raiz do seu diretório de RTOS download gratuito.
-
Em uma janela de linha de comando, digite o seguinte comando para adicionar as IDF ferramentas ESP - às do seu terminalPATH.
- Windows (aplicação "Comando")
-
vendors\espressif\esp-idf\export.bat
- Windows (aplicativo” ESP - IDF 4.xCMD”)
-
(Isso já foi feito quando você abriu a aplicação.)
- 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
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 use o Flash Free RTOS com CMake
Além do idf.py
script fornecido pelo IDF SDK para criar e executar seu código, você também pode criar o projeto comCMake. Atualmente, ele é compatível com o Makefile da Unix ou sistema de compilação Ninja.
Como compilar e instalar o projeto
-
Em uma janela de linha de comando, navegue até a raiz do seu diretório de RTOS download gratuito.
-
Execute o script a seguir para adicionar as IDF ferramentas ESP - ao seu shellPATH.
- 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
-
Crie o projeto.
- Com Makefiles da Unix
-
make -C ./YOUR_BUILD_DIRECTORY -j8
- Com Ninja
-
ninja -C ./YOUR_BUILD_DIRECTORY -j8
-
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
Execução das demonstrações de Bluetooth Low-Energy
O RTOS suporte gratuito Biblioteca de Bluetooth Low Energy à conectividade.
Para executar o projeto de RTOS demonstração gratuito em Bluetooth Low Energy, você deve executar o aplicativo gratuito de SDK demonstração móvel RTOS Bluetooth Low Energy em um dispositivo móvel iOS ou Android.
Para configurar o aplicativo de SDK demonstração móvel gratuito RTOS Bluetooth Low Energy
-
Siga as instruções SDKs móveis para dispositivos Bluetooth do FreeRTOS para baixar e instalar o SDK para sua plataforma móvel em seu computador host.
-
Siga as instruções em aplicação de demonstração do SDK móvel de Bluetooth Low Energy do FreeRTOS para configurar a aplicação móvel de demonstração no dispositivo móvel.
Para obter instruções sobre como executar a MQTT demonstração via Bluetooth Low Energy em sua placa, consulteMQTT por Bluetooth Low Energy.
Para obter instruções sobre como executar a demonstração do provisionamento de Wi-Fi na sua placa, consulte Provisionamento de Wi-Fi.
Usando o Free RTOS em seu próprio CMake projeto para ESP32
Se quiser consumir o Free RTOS em seu próprio CMake projeto, você pode configurá-lo como um subdiretório e construí-lo junto com seu aplicativo. Primeiro, obtenha uma cópia do Free RTOS from GitHub
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
Em seguida, veja a seguir um exemplo do CMakeLists.txt
arquivo de nível superior que pode ser usado para criar seu aplicativo junto com o FreeRTOS.
cmake_minimum_required(VERSION 3.13) project(freertos_examples) # Tell IDF build to link against this target. set(IDF_EXECUTABLE_SRCS "<complete_path>/src/main.c") set(IDF_PROJECT_EXECUTABLE my_app) # 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::core_mqtt)
Para criar o projeto, execute os CMake comandos a seguir. Verifique se o ESP32 compilador está na variável de PATH ambiente.
cmake -S . -B build-directory -DCMAKE_TOOLCHAIN_FILE=freertos/tools/cmake/toolchains/xtensa-esp32.cmake -GNinja
cmake --build build-directory
Para instalar a aplicação na sua placa, execute o comando a seguir.
cmake --build build-directory --target flash
Usando componentes do Free RTOS
Depois de executarCMake, você pode encontrar todos os componentes disponíveis na saída resumida. Isso deve ser parecido com a seguinte exemplo.
====================Configuration for FreeRTOS==================== Version: 202107.00 Git version: 202107.00-g79ad6defb 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: backoff_algorithm, common, common_io, core_http, core_http_demo_dependencies, core_json, core_mqtt, core_mqtt_agent, core_mqtt_agent_demo_dependencies, core_mqtt_demo_dependencies, crypto, defender, dev_mode_key_ provisioning, device_defender, device_defender_demo_ dependencies, device_shadow, device_shadow_demo_dependencies, freertos_cli_plus_uart, freertos_plus_cli, greengrass, http_demo_helpers, https, jobs, jobs_demo_dependencies, kernel, logging, mqtt, mqtt_agent_interface, mqtt_demo_ helpers, mqtt_subscription_manager, ota, ota_demo_ dependencies, ota_demo_version, pkcs11, pkcs11_helpers, pkcs11_implementation, pkcs11_utils, platform, secure_sockets, serializer, shadow, tls, transport_interface_secure_sockets, wifi Enabled by user: common_io, core_http_demo_dependencies, core_json, core_mqtt_agent_demo_dependencies, core_mqtt_demo_ dependencies, defender, device_defender, device_defender_demo_ dependencies, device_shadow, device_shadow_demo_dependencies, freertos_cli_plus_uart, freertos_plus_cli, greengrass, https, jobs, jobs_demo_dependencies, logging, ota_demo_dependencies, pkcs11, pkcs11_helpers, pkcs11_implementation, pkcs11_utils, platform, secure_sockets, shadow, wifi Enabled by dependency: backoff_algorithm, common, core_http, core_mqtt, core_mqtt_agent, crypto, demo_base, dev_mode_key_provisioning, freertos, http_demo_helpers, kernel, mqtt, mqtt_agent_ interface, mqtt_demo_helpers, mqtt_subscription_manager, ota, ota_demo_version, pkcs11_mbedtls, serializer, tls, transport_interface_secure_sockets, utils 3rdparty dependencies: jsmn, mbedtls, pkcs11, tinycbor Available demos: demo_cli_uart, demo_core_http, demo_core_mqtt, demo_core_mqtt_ agent, demo_device_defender, demo_device_shadow, demo_greengrass_connectivity, demo_jobs, demo_ota_core_http, demo_ota_core_mqtt, demo_tcp 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::core_mqtt
, AFR::ota
e assim por diante.
Adicione componentes personalizados usando ESP - IDF
Você pode adicionar mais componentes ao usar 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.
add_library(
example_component
src/example_component.c
) target_include_directories(example_component
PUBLIC include)
Em seguida, no arquivo CMakeLists.txt
de nível superior, adicione o componente inserindo a linha a seguir logo depois de add_subdirectory(freertos)
.
add_subdirectory(
component/example_component
)
Em seguida, modifique target_link_libraries
para incluir seu componente.
target_link_libraries(my_app PRIVATE AFR::core_mqtt PRIVATE
example_component
)
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.
Substitua as configurações gratuitamente RTOS
Atualmente, não há uma abordagem bem definida para redefinir as configurações fora da árvore de código livreRTOS. Por padrão, CMake procurará os freertos
/vendors/espressif/boards/esp32/aws_demos/config_files/
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 RTOS configurações gratuitas.freertos
/demos/include/
- 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
e freertos
/vendors/espressif/boards/esp32/aws_demos/config_files/
. No seu arquivo freertos
/demos/include/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)
Fornecendo 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 você não especificar um local para seu próprio sdkconfig.default
arquivo, o Free RTOS usará o arquivo padrão localizado em
.freertos
/vendors/espressif/boards/esp32/aws_demos/sdkconfig.defaults
Para obter mais informações, consulte Configuração do projeto
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.
cmake_minimum_required(VERSION 3.13) project(freertos_examples) set(IDF_PROJECT_EXECUTABLE my_app) set(IDF_EXECUTABLE_SRCS "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::core_mqtt)
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 no Guia de instalação de FTDI drivers para macOS X.
-
O utilitário monitor fornecido por ESP - IDF (e invocado usando make monitor) ajuda você 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 JTAG hardware especial. Para obter mais informações, consulte Launching GDB with GDBStub
no site do Espressif. -
Para obter informações sobre como configurar um ambiente aberto se a depuração OCD baseada JTAG em hardware for necessária, consulte JTAGDepuração
no site do Espressif. -
Se não for possível instalar
pyserial
usandopip
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 há necessidade de baixá-las externamente. Se a variável de
IDF_PATH
ambiente estiver definida, recomendamos que você a limpe antes de criar o FreeRTOS. -
No Windows, pode levar de 3 a 4 minutos para o projeto ser criado. Para reduzir o tempo de compilação, você pode usar o comutador
-j4
no comando make.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 o Free RTOS em seu próprio CMake projeto para 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
. -
ESP- IDF v4.2 suporta o uso do xtensa\ -esp32\ -elf\ -gcc 8\ .2\ .0\. conjunto de ferramentas. Se você estiver usando uma versão anterior da cadeia de ferramentas Xtensa, baixe a versão necessária.
-
Se você ver um registro de erros como o seguinte sobre dependências de python que não estão sendo atendidas para 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 - C e (- DevKit v4.2) ESP-WROVER-KIT ESP IDF
Esta seção mostra como depurar o hardware do Espressif usando - v4.2. ESP IDF Você precisa de um USB cabo JTAG para. Usamos um MPSSE cabo USB para (por exemplo, o FTDIC232HM- DDHSL -0
- ESP- JTAG Configuração DevKit C
-
Para o cabo FTDI DDHSL C232HM-0, essas são as conexões com o DevKitC. ESP32
| C232HM-DDHSL-0 Wire Color | ESP32 GPIO Pin | JTAG Signal Name | | ------------------------- | -------------- | ---------------- | | Brown (pin 5) | IO14 | TMS | | Yellow (pin 3) | IO12 | TDI | | Black (pin 10) | GND | GND | | Orange (pin 2) | IO13 | TCK | | Green (pin 4) | IO15 | TDO |
- ESP-WROVER-KIT JTAGconfiguração
-
Para o cabo FTDI C232HM- DDHSL -0, essas são as conexões com o - -. ESP32 WROVER KIT
| C232HM-DDHSL-0 Wire Color | ESP32 GPIO Pin | JTAG Signal Name | | ------------------------- | -------------- | ---------------- | | Brown (pin 5) | IO14 | TMS | | Yellow (pin 3) | IO12 | TDI | | Orange (pin 2) | IO13 | TCK | | Green (pin 4) | IO15 | TDO |
Essas tabelas foram desenvolvidas a partir da folha de dados FTDIC232HM- -0. DDHSL
Para obter mais informações, consulte a seção “Conexão do MPSSE cabo C232HM e detalhes mecânicos” na folha de dados. Para ativar JTAG o ESP-WROVER-KIT, coloque os jumpers nos TDI pinosTMS,TDO, TDITCK, e S_, conforme mostrado aqui.
- Depuração no Windows (- v4.2) ESP IDF
-
Para configurar para depuração no Windows
-
Conecte o USB lado do FTDI C232HM- DDHSL -0 ao seu computador e o outro lado conforme descrito em. Código de depuração no Espressif ESP32 - C e (- DevKit v4.2) ESP-WROVER-KIT ESP IDF O dispositivo FTDI C232HM- DDHSL -0 deve aparecer no Gerenciador de dispositivos em Controladores de barramento serial universal.
-
Na lista de dispositivos de barramento serial universal, clique com o botão direito do mouse no dispositivo C232HM- DDHSL -0 e escolha Propriedades.
nota
O dispositivo pode estar listado como porta USB serial.
Para ver as propriedades do dispositivo, na janela de propriedades, escolha a guia Detalhes. Se o dispositivo não estiver listado, instale o driver do Windows para FTDI C232HM
- -0. DDHSL -
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 entrada
projects/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
-
Baixe Open OCD para Windows
. -
Descompacte o arquivo
C:\
e adicioneC:\openocd-esp32\bin
ao caminho do sistema. -
O Open OCD requer o libusb, que não é instalado por padrão no Windows. Para instalar o libusb:
-
Faça download de zadig.exe
. -
Executar
zadig.exe
. No menu Options (Opções), escolha List All Devices (Listar todos os dispositivos). -
No menu suspenso, escolha C232HM - -0. DDHSL
-
No campo do condutor-alvo, à direita da seta verde, escolha Vencer USB.
-
Na caixa vertical 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é a raiz do seu diretório de RTOS download gratuito e execute o comando a seguir.
idf.py openocd
Deixe o prompt de comando aberto.
-
Abra um novo prompt de comando, navegue até a raiz do seu diretório de RTOS download gratuito e execute
idf.py flash monitor
-
Abra outro prompt de comando, navegue até a raiz do seu diretório de RTOS download gratuito e espere até que a demonstração comece a ser executada em sua placa. Quando isso ocorrer, execute
idf.py gdb
O programa deve parar na função
main
.nota
ESP32Ele suporta no máximo dois pontos de ruptura.
-
- Depuração no macOS (- v4.2) ESP IDF
-
-
Baixe o FTDIdriver para macOS
. -
Baixe Open OCD
. -
Extraia o arquivo .tar baixado e defina o caminho em
.bash_profile
comoOCD_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
-
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 do macOS posterior à 10.9, use o comando a seguir para descarregar o driver da Apple. FTDI
sudo kextunload -b com.apple.driver.AppleUSBFTDI
-
Use o comando a seguir para obter o ID do produto e o ID do fornecedor do FTDI cabo. Ele lista os USB dispositivos 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 comftdi_vid_pid
. Altere o IDs para corresponder ao IDs dasystem_profiler
saída na etapa anterior. -
Abra uma janela de terminal, navegue até a raiz do seu diretório de RTOS download gratuito e use o comando a seguir para executar o OpenOCD.
idf.py openocd
Deixe essa janela do terminal aberta.
-
Abra um novo terminal e use o comando a seguir para carregar o driver da porta FTDI serial.
sudo kextload -b com.FTDI.driver.FTDIUSBSerialDriver
-
Navegue até a raiz do seu diretório de RTOS download gratuito e execute
idf.py flash monitor
-
Abra outro novo terminal, navegue até a raiz do seu diretório de RTOS download gratuito e execute
idf.py gdb
O programa deve parar em
main
.
-
- Depuração no Linux (- v4.2) ESP IDF
-
-
Baixe Open OCD
. 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 USB dispositivos conectados ao seu computador. Isso ajuda a verificar se as USB portas 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 do terminal, liste os USB dispositivos. Certifique-se de que o proprietário do grupo tenha sido alterado de
dialout
paraplugdev
.$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
/dev/ttyUSBn
interface com o número mais baixo é usada para JTAG comunicação. A outra interface é roteada para a porta serial ESP32 do (UART) e é usada para carregar o código na memória flash ESP32 do. -
Em uma janela de terminal, navegue até a raiz do seu diretório de RTOS download gratuito e use o comando a seguir para executar o OpenOCD.
idf.py openocd
-
Abra outro terminal, navegue até a raiz do seu diretório de RTOS download gratuito e execute o comando a seguir.
idf.py flash monitor
-
Abra outro terminal, navegue pela raiz do seu diretório de RTOS download gratuito e execute o seguinte comando:
idf.py gdb
O programa deve parar em
main()
.
-