Franzininho C0 Sem o STM32Cube: Programando STM32 com GNU ARM, Make e OpenOCD

20/01/2025

ÍNDICE DE CONTEÚDO

Este post faz parte da série Franzininho C0 Sem o STM32Cube

Este é o primeiro artigo da série onde aprenderemos como desenvolver projetos com STM32 sem depender de IDEs gráficas ou ecossistemas como o STM32Cube. Vamos utilizar ferramentas como GNU ARM, OpenOCD e Make e programar diretamente por registradores.

Conhecendo as Ferramentas

GNU ARM Embedded Toolchain

O GNU ARM Embedded Toolchain é um conjunto de ferramentas de desenvolvimento (toolchain) projetado para criar programas para microcontroladores baseados em arquitetura ARM Cortex-M. Ele inclui ferramentas essenciais para o desenvolvimento de software em sistemas embarcados, permitindo compilar, depurar e gerar código binário executável para esses dispositivos. O compilador é o gcc-arm, uma versão do GCC (GNU Compiler Collection) ajustada para gerar código otimizado para arquitetura ARM.

Mais detalhes acesse: https://developer.arm.com/Tools%20and%20Software/GNU%20Toolchain

OpenOCD

OpenOCD, que significa Open On-Chip Debugger, é uma ferramenta aberta para depuração, programação in-system e testes de boundary-scan em dispositivos embarcados. Ele permite a comunicação entre o host de depuração, o adaptador de depuração e o alvo, aceitando os seguintes protocolos de transporte: JTAG (IEEE 1149.1), SWD (Serial Wire Debug), DAP (Debug Access Port), Protocolos Proprietários (SPI, UART, etc.) e ST-Link.

Mais informações em: https://openocd.org/

Os Melhores Treinamentos sobre Sistemas embarcados e IoT

Cursos com professores qualificados para acelerar sua carreira e projetos

MATRÍCULE-SE AGORA

Make

É uma ferramenta que controla a geração de executáveis e outros arquivos não-fonte de um programa a partir dos arquivos-fonte do programa. É utilizado na automatização de tarefas repetitivas.

Mais detalhes em: https://www.gnu.org/software/make/

CMSIS

CMSIS é uma sigla para Cortex Microcontroller Software Interface Standard, um padrão criado pela própria ARM que define uma camada de abstração (API) de acesso ao hardware para processadores da linha Cortex-M e Cortex-A de nível básico.

Saiba mais em: https://www.arm.com/technologies/cmsis

Preparando ambiente

Para configurar o ambiente de desenvolvimento, utilizaremos o Ubuntu em um sistema Windows por meio do WSL (Windows Subsystem for Linux). Se você já possui um sistema Linux nativo instalado, pode pular a etapa de instalação do WSL.

Em um terminal digite os seguintes comandos caso esteja utilizando sistema windows.

wsl.exe –install Ubuntusudo apt updatesudo apt upgrade -y

Após a execução desses comandos, o Ubuntu será instalado e você verá um terminal do Ubuntu disponível, além de uma pasta correspondente no seu sistema.

Após a instalação, abra o terminal Ubuntu.

Instale o GNU ARM com o seguinte comando:

sudo apt install gcc-arm-none-eabi binutils-arm-none-eabi

Para verificar se a instalação foi bem sucedida use

arm-none-eabi-gcc --version

Instale o OpenCD usando os comandos abaixo:

git clone https://github.com/openocd-org/openocd.git cd openocd./bootstrap./configuremake -j$(nproc)sudo make install

Verifique se a instalação foi bem sucedida verificando a versão instalada.

openocd --version

Configurando o Acesso ao Hardware no WSL

O Windows Subsystem for Linux (WSL) permite que você execute uma distribuição Linux diretamente no Windows, no entanto, para trabalhar com sistemas embarcados e realizar depuração, programação e testes de hardware, é preciso que o WSL tenha acesso ao hardware do sistema, como portas USB e interfaces JTAG/SWD. Para isso siga os seguintes passos:

Conecte um ST-Link na sua placa Franzininho C0 seguindo o esquema.

Instale o driver USB/IP no Windows: https://learn.microsoft.com/en-us/windows/wsl/connect-usb

Após instalar, entre no no powershell do windows como administrador e use o comando:

usbipd list

Este comando lista os dispositivos disponíveis.

Anote o busid do dispositivo que deseja anexar ao WSL. Ainda no powershell do Windows use os comandos:

usbipd bind --busid <busid>usbipd attach --wsl --busid <busid>

O comando usbipd bind e atacha serão utilizados para vincular dispositivos USB ao WSL. O parâmetro <busid> deve ser substituído pelo número do BUSID do dispositivo. Por exemplo, no meu sistema, o ST-Link é identificado como 1-2, então o comando para vincular o dispositivo seria: usbipd bind –busid 1-2.

Dica: Para simplificar esse processo, você pode utilizar uma extensão no VSCode que permite realizar a etapa de attach. Caso deseje instalá-la, siga os passos abaixo:

Instale a extensão WSL no VSCode

Clique sobre o ícone da extensão e conecte o VSCode ao WSL.

Agora, busque pela extensão USBIP Connect e instale

Para verificar se a vinculação ocorreu, no terminal Ubuntu digite:

lsusb

Lembrando que essa seção pode ser ignorada se você estiver utilizando sistema linux nativo.

Conclusão

Nesta primeira parte da série Programando Franzininho C0 na Unha Sem o Ecossistema STM32Cube, conhecemos e instalamos as ferramentas essenciais para o desenvolvimento. Fique atento, pois na segunda parte, vamos configurar a estrutura de diretórios necessária e dar início ao processo de programação.