Transformando o example-application no “seu projeto” (renomear, versionar, adicionar módulo próprio e validar no build)
Aqui eu vou te passar um fluxo bem operacional (comandos + o que editar) que preserva o que o template tem de melhor: workspace reproducível + capacidade de ter componentes out-of-tree (drivers/libs/bindings).
Renomeando o projeto sem quebrar o workspace
Depois que você já conseguiu rodar ao menos uma vez:
cd my-workspace/example-application
west build -b <SUA_BOARD> app
…a adaptação mais segura é:
- Renomear a pasta do repositório (localmente) para o nome do seu produto.
- Manter o
west.ymlno mesmo repositório, porque ele é o manifesto do workspace app (T2). - Ajustar o
self: path:(se existir) para refletir o novo caminho (isso depende do conteúdo exato dowest.yml, mas o conceito é esse: oselfdescreve o repositório manifesto).
Exemplo:
cd my-workspace
mv example-application meu-produto-fw
Depois, você sempre builda apontando para a pasta da aplicação (que segue sendo app/):
cd meu-produto-fw
west build -b <SUA_BOARD> app
O motivo de isso funcionar é que o build do Zephyr é “application-centric”: você está compilando a aplicação e, junto, o kernel e subsistemas necessários, produzindo um binário final.
“Pinando” versões (reprodutibilidade real) no west.yml
No west.yml, a seção projects define repositórios e revisões. A documentação do manifest explica esses campos e o papel de projects/remotes/defaults/self.
Regra prática que funciona bem em produto:
- Em desenvolvimento:
revision: main(ourevision: vX.Y-branch) - Em release:
revision: <tag>ourevision: <SHA>
O próprio template comenta que há alinhamento de tags com a versão do Zephyr para manter compatibilidade.
Adicionando “um módulo seu” (repo externo) e fazendo o Zephyr enxergar
Aqui entram as duas peças:
west.yml→ baixa o repositório do módulo (west project)zephyr/module.ymlno repo do módulo → registra o módulo para o build/Kconfig do Zephyr
Criando um módulo local (exemplo didático)
Vamos criar um módulo mínimo dentro do workspace (simulando um repo que depois você colocaria no Git):
cd my-workspace/meu-produto-fw
mkdir -p modules/meu_modulo_minimo/zephyr
mkdir -p modules/meu_modulo_minimo/include
mkdir -p modules/meu_modulo_minimo/src
Agora crie estes arquivos:
modules/meu_modulo_minimo/zephyr/module.yml
(este arquivo é o “sinalizador” de que o repo é um módulo Zephyr)
name: meu_modulo_minimo
build:
cmake: .
kconfig: Kconfig
modules/meu_modulo_minimo/CMakeLists.txt
(usando a convenção de módulo: cria uma zephyr_library e adiciona fontes/headers)
zephyr_library()
zephyr_library_sources(src/meu_modulo_minimo.c)
zephyr_include_directories(include)
modules/meu_modulo_minimo/Kconfig
(expondo uma opção para habilitar o módulo)
menu "Meu modulo minimo"
config MEU_MODULO_MINIMO
bool "Habilitar meu_modulo_minimo"
default y
endmenu
modules/meu_modulo_minimo/include/meu_modulo_minimo.h
#pragma once
void meu_modulo_minimo_hello(void);
modules/meu_modulo_minimo/src/meu_modulo_minimo.c
#include <zephyr/sys/printk.h>
#include "meu_modulo_minimo.h"
void meu_modulo_minimo_hello(void)
{
printk("Ola do meu_modulo_minimo!\n");
}
Esse “pacote” já está aderente ao conceito de módulos: o build system descobre e integra repositórios que possuem zephyr/module.yml.
Registrando o módulo no west.yml
Agora você precisa “baixar” esse módulo via manifest. Se ele fosse um repo Git remoto, você colocaria em projects: com URL e revision. Se for local para estudo, o jeito mais honesto é transformar modules/meu_modulo_minimo num repo Git e adicionar como project apontando para um remote seu (GitHub/Gitea etc.). O ponto central: o west.yml é quem garante que o módulo existe no workspace.
Observação prática: no mundo real, esse módulo seria seu repositório
meu_modulo_minimo.git, e owest updateclonaria emmodules/meu_modulo_minimo.
Consumindo o módulo na aplicação (app/)
No app/prj.conf, habilite:
CONFIG_MEU_MODULO_MINIMO=y
CONFIG_PRINTK=y
CONFIG_CONSOLE=y
CONFIG_UART_CONSOLE=y
No app/src/main.c, chame a função:
#include <zephyr/kernel.h>
#include <zephyr/sys/printk.h>
#include "meu_modulo_minimo.h"
int main(void)
{
printk("App iniciou.\n");
meu_modulo_minimo_hello();
while (1) {
k_sleep(K_SECONDS(1));
}
}
E build:
cd my-workspace/meu-produto-fw
west build -b <SUA_BOARD> app
O motivo de isso funcionar é o pipeline do build: o CMake do Zephyr executa a configuração e constrói app + kernel + libs necessárias.
Check rápido: o módulo apareceu no “menuconfig”?
Se sua toolchain estiver OK, rode:
west build -t menuconfig
Você deve ver o menu “Meu modulo minimo” e a opção CONFIG_MEU_MODULO_MINIMO. Isso fecha o ciclo: Kconfig do módulo está integrado (via module.yml + Kconfig).
