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á.
# Usando CMake com FreeRTOS
**Importante**
Essa página se refere ao repositório do Amazon-FreeRTOS, que está preterido. Recomendamos [começar aqui](freertos-getting-started-modular.md) ao criar um novo projeto. Se você já tem um projeto FreeRTOS existente baseado no repositório Amazon-FreeRTOS que está preterido, consulte o [Guia de migração do repositório Github do Amazon FreeRTOS](github-repo-migration.md).
Você pode usar CMake para gerar arquivos de construção do projeto a partir do código-fonte do aplicativo FreeRTOS e para criar e executar o código-fonte.
Você também pode usar um IDE para editar, depurar, compilar, atualizar e executar código em dispositivos qualificados para o FreeRTOS. Cada guia de conceitos básicos específico para a placa inclui instruções para configurar o IDE para uma plataforma específica. Se preferir trabalhar sem um IDE, você pode usar outras ferramentas de edição e depuração de código de terceiros para desenvolver e depurar seu código e, em seguida, usá-las CMake para criar e executar os aplicativos.
As seguintes placas suportam CMake:
+ Expressivo - C ESP32 DevKit
+ Expressivo ESP-WROVER-KIT
+ Kit de conectividade XMC4800 IoT Infineon
+ Kit inicial da Marvell MW320 AWS IoT
+ Kit inicial da Marvell MW322 AWS IoT
+ Pacote Microchip Curiosity PIC32 MZEF
+ Kit de desenvolvimento Nordic n RF52840 DK
+ STMicroelectronicsSTM32Node IoT do Kit L4 Discovery
+ Texas Instruments CC3220 SF-LAUNCHXL
+ Simulador do Microsoft Windows
Consulte os tópicos abaixo 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)
+ [Criando FreeRTOS com 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. CMake suporta todas as versões do Windows, macOS e Linux
O subsistema do Windows para Linux (WSL) não é compatível. Use nativo CMake em máquinas Windows.
+ Você deve ter a CMake versão 3.13 ou superior instalada.
Você pode baixar a distribuição binária CMake de em [CMake.org](https://cmake.org/download/).
**nota**
Se você baixar a distribuição binária de CMake, certifique-se de adicionar o CMake executável à variável de ambiente PATH antes de usar a CMake partir da linha de comando.
Você também pode baixar e instalar CMake usando um gerenciador de pacotes, como [homebrew](https://brew.sh/) no macOS [e](https://scoop.sh/) scoop [ou](https://chocolatey.org/) chocolatey no Windows.
**nota**
As versões de CMake pacotes fornecidas nos gerenciadores de pacotes para muitas distribuições Linux são out-of-date. Se o gerenciador de pacotes da sua distribuição não fornecer a versão mais recente do CMake, você pode tentar gerenciadores de pacotes alternativos, como `linuxbrew` ou`nix`.
+ Você deve ter um sistema de compilação nativo compatível.
CMake pode ter como alvo muitos sistemas de compilação nativos, incluindo [GNU Make](https://www.gnu.org/software/make/) ou [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ê usar o [Visual Studio Code](https://code.visualstudio.com/) como editor de código, poderá instalar a extensão [Cortex-Debug](https://marketplace.visualstudio.com/items?itemName=marus25.cortex-debug) VS Code como depurador. Ao terminar de desenvolver seu aplicativo, você pode invocar a ferramenta de CMake linha de comando para criar seu projeto a partir do VS Code. Para obter mais informações sobre como usar CMake para criar aplicativos FreeRTOS, consulte. [Criando FreeRTOS com 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"
}
]
```
## Criando FreeRTOS com CMake
CMake por padrão, o sistema operacional host é o sistema de destino. Para usá-lo para compilação cruzada, é CMake necessário 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 forma de fornecer esse arquivo CMake depende se você está usando a interface de linha de CMake comando ou a GUI. Para obter mais detalhes, siga as instruções de [Geração de arquivos de compilação (CMake ferramenta de linha de comando)](#cmake-gen-cli) abaixo. Para obter mais informações sobre compilação cruzada CMake, consulte [CrossCompiling](https://gitlab.kitware.com/cmake/community/wikis/doc/cmake/CrossCompiling)no wiki oficial CMake .
**Para criar um projeto CMake baseado**
1. Execute CMake para gerar os arquivos de compilação para um sistema de compilação nativo, como Make ou Ninja.
Você pode usar a [ferramenta de CMake linha de comando](https://cmake.org/cmake/help/latest/manual/cmake.1.html) ou a [CMake GUI](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 (CMake ferramenta de linha de comando)](#cmake-gen-cli) e [Gerando arquivos de construção (CMake GUI)](#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 (CMake ferramenta de linha de comando)
Você pode usar a ferramenta de CMake linha de comando (cmake) para gerar arquivos de compilação para 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 o CC3220 Launchpad e o compilador for o GCC for ARM, você poderá emitir o seguinte comando para criar os arquivos de origem do diretório atual em um diretório chamado: `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 porque 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 do conjunto de ferramentas não usar caminhos absolutos para o compilador e você não tiver adicionado o compilador à variável de `PATH` ambiente, CMake talvez não consiga encontrá-lo. Para garantir que CMake encontre seu arquivo do conjunto de ferramentas, você pode usar a `AFR_TOOLCHAIN_PATH` opção. 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, CMake adiciona sinalizadores de depuração às opções de compilação e cria 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.
### Gerando arquivos de construção (CMake GUI)
Você pode usar a CMake GUI para gerar arquivos de compilação do FreeRTOS.
**Para gerar arquivos de compilação com a CMake GUI**
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.
![\[CMake janela com campos de entrada para localização do código-fonte e localização dos binários de compilação, junto com opções para procurar 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. Nesse caso, exclua o CMake cache escolhendo **Excluir cache** no menu **Arquivo**.
![\[CMakeCaixa de diálogo de configuração com opções para especificar o gerador para o projeto como Unix Makefiles e especificar o arquivo do conjunto 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 `AFR_TOOLCHAIN_PATH` variável na GUI para saber 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\$1TOOLCHAIN\$1PATH**. 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:
![\[CMake janela de configuração para criar FreerTOS com a placa do fornecedor selecionada, os módulos habilitados e os caminhos de construção especificados.\]](http://docs.aws.amazon.com/pt_br/freertos/latest/userguide/images/cmake-gui3.png)
Escolha **AFR\$1BOARD**, escolha a placa e**Configure (Configurar)** novamente.
1. Escolha **Gerar**. 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
```
#### Edifício com CMake
Você também pode usar a ferramenta de CMake linha de comando para criar Freertos. CMake fornece uma camada de abstração para chamar sistemas de compilação nativos. Por exemplo:
```
cmake --build build_dir
```
Aqui estão alguns outros usos comuns do modo de construção da ferramenta CMake de linha de comando:
```
# 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 CMake compilação, consulte a [CMake documentação](https://cmake.org/cmake/help/latest/manual/cmake.1.html#build-tool-mode).