Uso da CMake com o FreeRTOS

Importante

Essa página se refere ao repositório do Amazon-FreeRTOS, que está preterido. Recomendamos começar aqui 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.

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

• Espressif ESP32- C DevKit

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

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 fazer download da distribuição binária do CMake em CMake.org.

  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 no macOS e scoop ou chocolatey no Windows.

  nota

  As versões do pacote CMake fornecidas nos gerenciadores de pacotes para muitas distribuições Linux são. out-of-date 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 ou o Ninja. 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 ou instalar o MinGW, 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 como editor de código, poderá instalar a extensão Cortex-Debug VS Code como 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.

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) abaixo. Para obter mais informações sobre compilação cruzada no CMake, consulte CrossCompilingo wiki oficial do CMake.

Para criar um projeto com base no CMake

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 ou a GUI do CMake 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) e Geração de arquivos de compilação (GUI do CMake).

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

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.

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

   

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

   

4. Escolha Specify toolchain file for cross-compiling (Especificar arquivo de conjunto de ferramentas para compilação cruzada) e escolha Next (Próximo).

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

   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.

6. Agora, a GUI deve ter a seguinte aparência:

   

   Escolha AFR_BOARD, escolha a placa eConfigure (Configurar) novamente.

7. 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 <build_dir> e você estiver usando o Make como seu sistema de compilação nativo, execute os seguintes comandos:

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