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á. # Uso da CMake com o FreeRTOS **Importante** Esta página se refere ao Amazon-FreeRTOS repositório que está obsoleto. Recomendamos [começar aqui](freertos-getting-started-modular.md) ao criar um novo projeto. Se você já tem um projeto FreeRTOS existente com base no repositório agora Amazon-FreeRTOS obsoleto, consulte o. [Amazon-FreeRTOS Guia de migração do repositório Github](github-repo-migration.md) Você pode usar CMake para gerar arquivos de compilação do projeto a partir de código-fonte da aplicação FreeRTOS e compilar e executar o código-fonte. Você também pode usar um IDE para editar, depurar, compilar, atualizar e executar código em FreeRTOS-qualified dispositivos. Cada guia de conceitos básicos específico para a placa inclui instruções para configurar o IDE para uma plataforma específica. Se você preferir trabalhar sem um IDE, você pode usar outras ferramentas de terceiros de edição de código e depuração para desenvolver e depurar seu código e, então, usar CMake para compilar e executar os aplicativos. As seguintes placas são compatíveis com CMake: + Expressivo ESP32-DevKitC + Expressivo ESP-WROVER-KIT + Infineon XMC4800 IoT Connectivity Kit + Kit inicial Marvell MW320 AWS IoT + Kit inicial Marvell MW322 AWS IoT + Pacote Microchip Curiosity PIC32MZEF + Kit de desenvolvimento Nordic nRF52840 DK + Nó de IoT do kit STMicroelectronicsSTM32L4 Discovery + Texas Instruments CC3220SF-LAUNCHXL + Simulador do Microsoft Windows Consulte os tópicos a seguir para obter mais informações sobre como usar CMake com FreeRTOS. **Topics** + [Pré-requisitos](#building-cmake-prereqs) + [Desenvolvimento de aplicações do FreeRTOS com ferramentas de terceiros para edição e depuração de código](#developing-third-party) + [Compilação do FreeRTOS com o CMake](#building-cmake) ## Pré-requisitos Certifique-se de que sua máquina host atenda aos seguintes pré-requisitos antes de continuar: + O conjunto de ferramentas de compilação do seu dispositivo deve ser compatível com o sistema operacional da máquina. O CMake é compatível com todas as versões do Windows, macOS e Linux O subsistema do Windows para Linux (WSL) não é compatível. Use o CMake nativo em máquinas Windows. + É necessário ter o CMake versão 3.13 ou posterior instalado. Você pode baixar a distribuição binária do CMake em. [CMake.org](https://cmake.org/download/) **nota** Se você fizer download da distribuição binária do CMake, certifique-se de adicionar o executável CMake à variável de ambiente PATH antes de usar o CMake na linha de comando. Você também pode fazer download e instalar o CMake usando um gerenciador de pacotes, como [homebrew](https://brew.sh/) no macOS e [scoop](https://scoop.sh/) ou [chocolatey](https://chocolatey.org/) no Windows. **nota** As versões do pacote CMake fornecidas nos gerenciadores de pacotes estão desatualizadas para muitas distribuições do Linux. Se o gerenciador de pacote de distribuição não fornecer a versão mais recente do CMake, experimente gerenciadores de pacote alternativos, como `linuxbrew` ou `nix`. + Você deve ter um sistema de compilação nativo compatível. O CMake pode direcionar muitos sistemas de compilação nativos, inclusive o [GNU Make](https://www.gnu.org/software/make/) ou o [Ninja](https://github.com/ninja-build/ninja/releases). Tanto o Make quanto o Ninja podem ser instalados com gerenciadores de pacotes no Linux, no macOS e no Windows. Se você estiver usando o Make no Windows, poderá instalar uma versão independente do [Equation](http://www.equation.com/servlet/equation.cmd?fa=make) ou instalar o [MinGW](https://sourceforge.net/projects/mingw-w64/files/), que inclui o Make no pacote. **nota** O executável Make no MinGW é chamado `mingw32-make.exe`, em vez de `make.exe`. Recomendamos que você use o Ninja, porque ele é mais rápido do que o Make e também fornece suporte nativo a todos os sistemas operacionais de desktop. ## Desenvolvimento de aplicações do FreeRTOS com ferramentas de terceiros para edição e depuração de código Você pode usar um editor de código e uma extensão de depuração ou uma ferramenta de terceiros de depuração para desenvolver aplicações para o FreeRTOS. Se, por exemplo, você usa o [Visual Studio Code](https://code.visualstudio.com/) como editor de código, você pode instalar a extensão [Cortex-Debug](https://marketplace.visualstudio.com/items?itemName=marus25.cortex-debug)VS Code como um depurador. Ao concluir o desenvolvimento de seu aplicativo, você pode invocar a ferramenta de linha de comando CMake para criar seu projeto no VS Code. Para obter mais informações sobre como usar CMake para compilar aplicações do FreeRTOS, consulte [Compilação do FreeRTOS com o CMake](#building-cmake). Para a depuração, você pode fornecer um VS Code com configuração de depuração semelhante ao seguinte: ``` "configurations": [ { "name": "Cortex Debug", "cwd": "${workspaceRoot}", "executable": "./build/st/stm32l475_discovery/aws_demos.elf", "request": "launch", "type": "cortex-debug", "servertype": "stutil" } ] ``` ## Compilação do FreeRTOS com o CMake O CMake seleciona seu sistema operacional host como o sistema de destino por padrão. Para usá-lo em compilação cruzada, o CMake exige um arquivo de conjunto de ferramentas, que especifica o compilador que você deseja usar. No FreeRTOS, fornecemos arquivos de cadeia de ferramentas padrão no `{{freertos}}/tools/cmake/toolchains`. A maneira de fornecer esse arquivo para o CMake depende de você estar usando a interface de linha de comando ou a GUI do CMake. Para obter mais detalhes, siga as instruções de [Geração de arquivos de compilação (ferramenta de linha de comando do CMake)](#cmake-gen-cli) abaixo. Para obter mais informações sobre compilação cruzada no CMake, consulte [CrossCompiling](https://gitlab.kitware.com/cmake/community/wikis/doc/cmake/CrossCompiling)o wiki oficial do CMake. **Para criar um CMake-based projeto** 1. Execute o CMake para gerar os arquivos de compilação para um sistema de compilação nativo, como o Make ou o Ninja. É possível usar a [ferramenta de linha de comando do CMake](https://cmake.org/cmake/help/latest/manual/cmake.1.html) ou a [GUI do CMake](https://cmake.org/cmake/help/latest/manual/cmake-gui.1.html) para gerar os arquivos de compilação para seu sistema de compilação nativo. Para obter informações sobre como gerar arquivos de compilação do FreeRTOS, consulte [Geração de arquivos de compilação (ferramenta de linha de comando do CMake)](#cmake-gen-cli) e [Geração de arquivos de compilação (GUI do CMake)](#cmake-gen-gui). 1. Invoque o sistema de compilação nativo para transformar o projeto em um executável. Para obter informações sobre como criar arquivos de compilação do FreeRTOS, consulte [Compilação do FreeRTOS a partir de arquivos de compilação gerados](#cmake-build). ### Geração de arquivos de compilação (ferramenta de linha de comando do CMake) Você pode usar a ferramenta de linha de comando CMake para gerar arquivos de compilação do FreeRTOS. Para gerar os arquivos de compilação, especifique uma placa de destino, um compilador e o local do código-fonte e o diretório de compilação. É possível usar as seguintes opções para o cmake: + `-DVENDOR`: especifica a placa de destino. + `-DCOMPILER`: especifica o compilador. + `-S`: especifica a localização do código-fonte. + `-B`: especifica a localização dos arquivos de compilação gerados. **nota** O compilador deve estar na variável `PATH` do sistema ou você deve especificar o local do compilador. Por exemplo, se o fornecedor for a Texas Instruments, a placa for Launchpad CC3220 e o compilador for GCC para ARM, você poderá emitir o seguinte comando para compilar os arquivos de origem do diretório atual em um diretório denominado `{{build-directory}}`: ``` cmake -DVENDOR=ti -DBOARD=cc3220_launchpad -DCOMPILER=arm-ti -S . -B {{build-directory}} ``` **nota** Se você estiver usando o Windows, deverá especificar o sistema de compilação nativo, pois, o CMake usa o Visual Studio por padrão. Por exemplo: ``` cmake -DVENDOR=ti -DBOARD=cc3220_launchpad -DCOMPILER=arm-ti -S . -B {{build-directory}} -G Ninja ``` Ou: ``` cmake -DVENDOR=ti -DBOARD=cc3220_launchpad -DCOMPILER=arm-ti -S . -B {{build-directory}} -G "MinGW Makefiles" ``` As expressões regulares `${VENDOR}.*` e `${BOARD}.*` são usadas para pesquisar uma placa correspondente, portanto, você não precisa usar os nomes completos do fornecedor e da placa para as opções `BOARD` e `VENDOR`. Nomes parciais funcionam, desde que haja uma única correspondência. Por exemplo, os seguintes comandos geram os mesmos arquivos de compilação da mesma origem: ``` cmake -DVENDOR=ti -DCOMPILER=arm-ti -S . -B {{build-directory}} ``` ``` cmake -DBOARD=cc3220 -DCOMPILER=arm-ti -S . -B {{build-directory}} ``` ``` cmake -DVENDOR=t -DBOARD=cc -DCOMPILER=arm-ti -S . -B {{build-directory}} ``` Você pode usar a opção `CMAKE_TOOLCHAIN_FILE` se quiser usar um arquivo de conjunto de ferramentas que não esteja localizado no diretório padrão `cmake/toolchains`. Por exemplo: ``` cmake -DBOARD=cc3220 -DCMAKE_TOOLCHAIN_FILE='/path/to/toolchain_file.cmake' -S . -B {{build-directory}} ``` Se o arquivo de conjunto de ferramentas não usar caminhos absolutos para o compilador e você não tiver adicionado o compilador à variável de ambiente de `PATH`, talvez o CMake não conseguirá encontrá-lo. Para certificar-se de que o CMake encontre seu arquivo de conjunto de ferramentas, você pode usar a opção `AFR_TOOLCHAIN_PATH`. Essa opção pesquisa o caminho do diretório do conjunto de ferramentas especificado e a subpasta do conjunto de ferramentas em `bin`. Por exemplo: ``` cmake -DBOARD=cc3220 -DCMAKE_TOOLCHAIN_FILE='/path/to/toolchain_file.cmake' -DAFR_TOOLCHAIN_PATH='/path/to/toolchain/' -S . -B {{build-directory}} ``` Para habilitar a depuração, defina `CMAKE_BUILD_TYPE` como `debug`. Com essa opção ativada, o CMake adiciona sinalizadores de depuração às opções de compilação e cria o FreeRTOS com símbolos de depuração. ``` # Build with debug symbols cmake -DBOARD=cc3220 -DCOMPILER=arm-ti -DCMAKE_BUILD_TYPE=debug -S . -B {{build-directory}} ``` Você também pode definir o `CMAKE_BUILD_TYPE` como `release` para adicionar sinalizadores de otimização às opções de compilação. ### Geração de arquivos de compilação (GUI do CMake) Você pode usar a GUI do CMake para gerar arquivos de compilação do FreeRTOS. **Para gerar arquivos de compilação com a GUI do CMake** 1. Na linha de comando, emita `cmake-gui` para iniciar a GUI. 1. Escolha **Browse Source (Procurar origem)** e especifique a entrada de origem e escolha **Browse Build (Procurar compilação)** e especifique a saída da compilação. ![Janela do CMake com campos de entrada para o local do código-fonte e o local dos binários de compilação, juntamente com opções para navegar pelas fontes, navegar pelo diretório de compilação, pesquisar, adicionar ou remover entradas e visualizar opções agrupadas ou avançadas.](http://docs.aws.amazon.com/pt_br/freertos/latest/userguide/images/cmake-gui1.png) 1. Escolha **Configure (Configurar)** e, em **Specify the build generator for this project (Especificar o gerador de compilação para esse projeto)**, localize e escolha o sistema de compilação que deseja usar para compilar os arquivos de compilação gerados. Se você não vir a janela pop-up, pode reutilizar um diretório de compilação existente. Neste caso, exclua o cache do CMake escolhendo **Delete Cache (Excluir cache)** no menu **File (Arquivo)**. ![CMakeSetup caixa de diálogo com opções para especificar o gerador para o projeto como Unix Makefiles e especificar o arquivo da cadeia de ferramentas para compilação cruzada.](http://docs.aws.amazon.com/pt_br/freertos/latest/userguide/images/cmake-gui2.png) 1. Escolha **Specify toolchain file for cross-compiling (Especificar arquivo de conjunto de ferramentas para compilação cruzada)** e escolha **Next (Próximo)**. 1. Escolha o arquivo de cadeia de ferramentas (por exemplo, `{{freertos}}/tools/cmake/toolchains/arm-ti.cmake`) e escolha **Concluir**. A configuração padrão do FreeRTOS é a placa de modelo, que não fornece nenhum destino de camada portátil. Como resultado, uma janela será exibida com a mensagem Error in configuration process. **nota** Se você estiver vendo o seguinte erro: ``` CMake Error at tools/cmake/toolchains/find_compiler.cmake:23 (message): Compiler not found, you can specify search path with AFR_TOOLCHAIN_PATH. ``` Isso significa que o compilador não está na sua variável de ambiente `PATH`. Você pode definir a variável `AFR_TOOLCHAIN_PATH` na GUI para informar o CMake onde você instalou o compilador. Se você não vir a variável `AFR_TOOLCHAIN_PATH`, escolha **Add Entry (Adicionar entrada)**. Na janela pop-up, em **Name (Nome)**, digite **AFR\_TOOLCHAIN\_PATH**. Em **Compiler Path (Caminho do compilador)**, digite o caminho para o compilador. Por exemplo, `C:/toolchains/arm-none-eabi-gcc`. 1. Agora, a GUI deve ter a seguinte aparência: ![Janela de configuração do CMake para compilar o FreeRTOS com a placa do fornecedor selecionada, os módulos habilitados e os caminhos de compilação especificados.](http://docs.aws.amazon.com/pt_br/freertos/latest/userguide/images/cmake-gui3.png) Escolha **AFR\_BOARD**, escolha a placa e**Configure (Configurar)** novamente. 1. Escolha **Gerar**. O CMake gera os arquivos do sistema de compilação (por exemplo, makefiles ou arquivos ninja), e esses arquivos aparecem no diretório de compilação que você especificou na primeira etapa. Siga as instruções na próxima seção para gerar a imagem binária. ### Compilação do FreeRTOS a partir de arquivos de compilação gerados #### Criação com sistema de compilação nativo Você pode compilar o FreeRTOS com um sistema de compilação nativo chamando o comando de sistema de compilação a partir do diretório de binários de saída. Por exemplo, se o diretório de saída do arquivo de compilação for `` e você estiver usando o Make como seu sistema de compilação nativo, execute os seguintes comandos: ``` cd make -j4 ``` #### Criar o com o CMake Você também pode usar a ferramenta de linha de comando do CMake para criar o FreeRTOS. O CMake fornece uma camada de abstração para chamar os sistemas de compilação nativos. Por exemplo: ``` cmake --build {{build_dir}} ``` Estes são alguns outros usos comuns do modo de compilação da ferramenta de linha de comando do CMake: ``` # Take advantage of CPU cores. cmake --build {{build_dir}} --parallel 8 ``` ``` # Build specific targets. cmake --build {{build_dir}} --target afr_kernel ``` ``` # Clean first, then build. cmake --build {{build_dir}} --clean-first ``` Para obter mais informações sobre o modo de compilação do CMake, consulte [Documentação do CMake](https://cmake.org/cmake/help/latest/manual/cmake.1.html#build-tool-mode).