O desenvolvimento para microcontroladores da Texas Instruments (TI), como a série MSPM0G3507, é tradicionalmente realizado no Code Composer Studio (CCS). Embora o CCS seja uma ferramenta robusta, seu sistema de compilação baseado em gmake pode ser lento em projetos complexos, especialmente ao lidar com mudanças no syscfg ou inclusão de bibliotecas pesadas como a LVGL. A utilização do CLion, em conjunto com o gerador Ninja, oferece uma experiência superior de codificação e uma aceleração significativa no tempo de build.

Configuração do Toolchain ti-clang no CLion

Para manter a compatibilidade total com o ecossistema da TI, é fundamental utliizar o compilador ti-clang original dentro do CLion. Isso garante que as otimizações e especificidades da arquitetura ARM Cortex-M0+ sejam respeitadas.

1. No CLion, acesse Settings > Build, Execution, Deployment > Toolchains.
2. Adicione um novo item do tipo MinGW (ou utilize o padrão do sistema).
3. No campo C Compiler e C++ Compiler, aponte para o executável tiarmclang.exe localizado no diretório de instalação do CCS. Geralmente, o caminho segue o padrão: CCS_INSTALL_DIR/ccs/tools/compiler/ti-cgt-armllvm_x.x.x/bin/tiarmclang.exe.

Estruturação do CMakeLists.txt

O CMakeLists.txt é o coração da configuração. Abaixo, apresento uma estrutura otimizada que resolve problemas comuns, como a limitação de caracteres em arquivos de resposta (.rsp) do ti-clang e a integração dinâmica com o SDK da TI.

cmake_minimum_required(VERSION 3.24)
project(MSPM0_Project LANGUAGES C CXX ASM)

set(CMAKE_C_STANDARD 17)
set(CMAKE_CXX_STANDARD 17)

# Definição de sufixos para o compilador TI
set(CMAKE_EXECUTABLE_SUFFIX_C ".out")
set(CMAKE_EXECUTABLE_SUFFIX_CXX ".out")

# Correção para o formato de arquivos de resposta do ti-clang
set(CMAKE_C_RESPONSE_FILE_LINK_FLAG "@")
set(CMAKE_C_RESPONSE_FILE_FORMAT "LINES")
set(CMAKE_NINJA_FORCE_RESPONSE_FILE 1)

# Configuração do Caminho do SDK
set(TI_SDK_ROOT "D:/TI/mspm0_sdk_2_xx_xx_xx" CACHE PATH "Raiz do SDK MSPM0")

# Flags de Compilação para Cortex-M0+
add_compile_options(
    -march=thumbv6m 
    -mcpu=cortex-m0plus 
    -mfloat-abi=soft 
    -mlittle-endian 
    -mthumb 
    -O2
)

# Definições Globais
add_compile_definitions(__MSPM0G3507__)

# Gerenciamento de Arquivos de Origem
file(GLOB_RECURSE SRC_FILES
    "src/*.cpp"
    "src/*.c"
    "Debug/ti_msp_dl_config.c"
    "${TI_SDK_ROOT}/source/ti/devices/msp/m0p/startup_system_files/ticlang/startup_mspm0g350x_ticlang.c"
)

add_executable(${PROJECT_NAME} ${SRC_FILES})

# Diretórios de Include
target_include_directories(${PROJECT_NAME} PUBLIC
    "src"
    "Debug"
    "${TI_SDK_ROOT}/source"
    "${TI_SDK_ROOT}/source/third_party/CMSIS/Core/Include"
)

# Configuração do Linker
target_link_options(${PROJECT_NAME} PRIVATE
    "-Wl,-m${PROJECT_NAME}.map"
    "-Wl,-l${CMAKE_SOURCE_DIR}/Debug/device_linker.cmd"
    "-Wl,--rom_model"
)

Integração entre CLion e CCS

Embora a compilação ocorra no CLion, o CCS continua sendo necessário para a depuração de hardware e configuração via syscfg. Para garantir que ambos funcionem em harmonia, siga estas diretrizes:

• Exclusão de Diretórios: No CCS, clique com o botão direito na pasta cmake-build-debug (ou similar criada pelo CLion) e selecione Exclude from Build. Isso evita conflitos de objetos duplicados durante a depuração.
• Sincronização de Includes: Sempre que adicionar um novo diretório de cabeçalhos no CMake, certifique-se de adicioná-lo também nas propriedades do projeto CCS (Include Options) para manter o indexador do CCS funcional.
• Workflow de SysConfig: Altere os pinos e periféricos no arquivo .syscfg dentro do CCS, salve e compile uma vez no CCS para gerar os arquivos atualizados em Debug/syscfg. O CLion detectará as mudanças automaticamente e recompilará apenas o necessário.

Aceleração com Bibliotecas Estáticas

Em projetos com LVGL ou outras middlewares, o tempo de linkagem e compilação inicial pode ser alto. Uma técnica eficaz é isolar essas bibliotecas em alvos estáticos no CMake. Isso permite que a biblioteca seja compilada apenas uma vez.

# Alvo separado para LVGL
add_library(lvgl_lib STATIC)
file(GLOB_RECURSE LVGL_SOURCES "lib/lvgl/src/*.c")
target_sources(lvgl_lib PRIVATE ${LVGL_SOURCES})
target_include_directories(lvgl_lib PUBLIC "lib/lvgl")

# Vinculando ao projeto principal
target_link_libraries(${PROJECT_NAME} PRIVATE lvgl_lib)

Ao adotar essa estrutura, o CCS tratará a LVGL como um arquivo .a pré-compilado, reduzindo o tempo de build total de minutos para poucos segundos durante o ciclo de desenvolvimento iterativo.