Introdução ao Espressif ESP32 - DevKit C e ao ESP-WROVER-KIT - Gratuito RTOS

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 a plataforma -C3.

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 no site da Espressif.

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:

  1. Conectar sua placa a uma máquina host.

  2. Instalar software na máquina host para desenvolver e depurar aplicativos incorporados para seu microcontrolador.

  3. Compilação cruzada de um aplicativo de RTOS demonstração gratuito em uma imagem binária.

  4. Carregar a imagem binária do aplicativo em sua placa e executar o aplicativo.

  5. 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
  1. Abra a https://portal.aws.amazon.com/billing/inscrição.

  2. 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 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
  1. 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 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 .

  2. 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
  1. 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 .

  2. 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
  1. 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 .

  2. 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:

Conceitos básicos

nota

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

  1. Configuração de hardware da Espressif.

    Importante

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

  2. Baixe Amazon gratuitamente RTOS em GitHub. (Para obter instruções, consulte o READMEarquivo.md.)

  3. 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

    1. Baixe ESP - IDF é o Universal Online Installer para Windows.

    2. Execute o Instalador online universal.

    3. Ao chegar à etapa Baixar ou usar ESP - IDF, selecione Usar um IDF diretório existente ESP - e defina Escolher IDF diretório existente ESP - comofreertos/vendors/espressif/esp-idf.

    4. Concluir a instalação.

    macOS

    1. 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.

    2. Abra a janela de linha de comando.

    3. 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
    4. Adicione as IDF ferramentas ESP - toolchain ao caminho do seu terminal com o comando a seguir.

      source vendors/espressif/esp-idf/export.sh

    Linux

    1. Siga as instruções na Configuração padrão dos pré-requisitos do Toolchain (ESP- IDF v4.2) para Linux.

      Importante

      Ao acessar as instruções “Obter ESP -IDF” em Próximas etapas, pare e retorne às instruções nesta página.

    2. Abra a janela de linha de comando.

    3. 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
    4. Adicione as IDF ferramentas ESP - toolchain ao caminho do seu terminal com o comando a seguir.

      source vendors/espressif/esp-idf/export.sh
  4. Estabelecimento de uma conexão serial.

    1. 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.

    2. Siga as etapas para estabelecer uma conexão serial com ESP32.

    3. 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 emfreertos/vendors/espressif/boards/board-name/aws_demos/config_files/FreeRTOSConfig.h. (Por exemplo, se AFR_BOARD espressif.esp32_devkitc for escolhido, o arquivo de configuração estará localizado em freertos/vendors/espressif/boards/esp32/aws_demos/config_files/FreeRTOSConfig.h.)

  1. Se você estiver executando macOS ou Linux, abra um prompt de terminal. Se você estiver executando o Windows, abra o aplicativo "ESP- IDF 4.xCMD" (se você incluiu essa opção ao instalar o conjunto de IDF ferramentas ESP -) ou o aplicativo “Prompt de comando”, caso contrário.

  2. 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.

  3. 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

  4. 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

  5. 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 freertos/tools/aws_config_quick_start/configure.json e defina os seguintes atributos:

    afr_source_dir

    O caminho completo para o diretório freertos no computador. Certifique-se de usar barras para especificar esse caminho.

    thing_name

    O nome que você deseja atribuir à AWS IoT coisa que representa seu quadro.

    wifi_ssid

    O SSID da sua 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)

  6. Executar o script de configuração.

    1. Se você estiver executando macOS ou Linux, abra um prompt de terminal. Se você estiver executando o Windows, abra o aplicativo "ESP- IDF 4.xCMD" ou “Command”.

    2. 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 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, consulte README.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
  1. Navegue até o console do AWS IoT.

  2. No painel de navegação, escolha Teste e, em seguida, escolha Cliente MQTT de teste.

  3. Em Tópico de inscrição, insira your-thing-name/example/topic e selecione Inscreva-se no tópico.

Quando o projeto de demonstração for executado com êxito em seu dispositivo, você verá "Olá, mundo!". enviado várias vezes para o tópico em que você assinou.

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)
  1. Navegue até a raiz do seu diretório de RTOS download gratuito.

  2. 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
  3. 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.

  4. Apague a memória instalada da placa de desenvolvimento com o comando a seguir.

    idf.py erase_flash
  5. Use o script idf.py para instalar o binário da aplicação na placa.

    idf.py flash
  6. 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
  1. Em uma janela de linha de comando, navegue até a raiz do seu diretório de RTOS download gratuito.

  2. 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
  3. 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
  4. Crie o projeto.

    Com Makefiles da Unix
    make -C ./YOUR_BUILD_DIRECTORY -j8
    Com Ninja
    ninja -C ./YOUR_BUILD_DIRECTORY -j8
  5. 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
  1. 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.

  2. 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. 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

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/ 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 RTOS configurações gratuitas.

- 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)

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 emfreertos/vendors/espressif/boards/esp32/aws_demos/sdkconfig.defaults.

Para obter mais informações, consulte Configuração do projeto na APIReferência do Espressif e, se você encontrar problemas após a compilação bem-sucedida, consulte a seção sobre Opções obsoletas e suas substituições nessa página.

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 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 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.

Posicionamento do jumper
Depuração no Windows (- v4.2) ESP IDF
Para configurar para depuração no Windows
  1. 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.

  2. 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

  3. 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
  4. Baixe Open OCD para Windows.

  5. Descompacte o arquivo C:\ e adicione C:\openocd-esp32\bin ao caminho do sistema.

  6. O Open OCD requer o 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 - -0. DDHSL

    4. No campo do condutor-alvo, à direita da seta verde, escolha Vencer USB.

    5. Na caixa vertical no campo de driver de destino, escolha a seta e selecione Instalar driver. Escolha Replace Driver (Substituir driver).

  7. 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.

  8. Abra um novo prompt de comando, navegue até a raiz do seu diretório de RTOS download gratuito e execute

    idf.py flash monitor
  9. 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
  1. Baixe o FTDIdriver para macOS.

  2. Baixe Open OCD.

  3. Extraia o arquivo .tar baixado e defina o caminho em .bash_profile como OCD_INSTALL_DIR/openocd-esp32/bin.

  4. Use o comando a seguir para instalar o libusb no macOS.

    brew install libusb
  5. Use o comando a seguir para fazer download do driver da porta serial.

    sudo kextunload -b com.FTDI.driver.FTDIUSBSerialDriver
  6. Use o comando a seguir para fazer download do driver da porta serial.

    sudo kextunload -b com.FTDI.driver.FTDIUSBSerialDriver
  7. 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
  8. 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)
  9. 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.

  10. 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.

  11. 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
  12. Navegue até a raiz do seu diretório de RTOS download gratuito e execute

    idf.py flash monitor
  13. 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
  1. Baixe Open OCD. Extraia o tarball e siga as instruções de instalação no arquivo readme.

  2. Use o seguinte comando para instalar libusb em Linux.

    sudo apt-get install libusb-1.0
  3. 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
  4. 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 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 /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.

  5. 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
  6. 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
  7. 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().