Como Usar o STM32 Blue Pill com STM32CubeIDE: Manual Técnico Completo

Introdução

Neste manual, será apresentado como instalar, configurar e utilizar a placa de desenvolvimento STM32 Blue Pill (STM32F103C8T6) com o ambiente oficial STM32CubeIDE. Se desejar adquirir este produto em nossa loja, clique aqui.

Descrição geral do produto

O que é o STM32 Blue Pill?

O STM32 Blue Pill é uma placa de prototipagem e desenvolvimento eletrônico compacta baseada no microcontrolador STM32F103C8T6, desenvolvido pela STMicroelectronics. Com arquitetura ARM Cortex-M3 de 32 bits e frequência de clock de até 72 MHz, ele oferece um salto expressivo de desempenho de processamento, memória e periféricos em relação a placas de 8 bits convencionais.

Projetada com formato compacto de barramento duplo de pinos de passo padrão (2,54 mm), a placa integra cristais osciladores de alta precisão (8 MHz para clock principal e 32,768 kHz para o relógio de tempo real / RTC), regulador de tensão interno de 3,3 V, circuito de reset, LEDs de sinalização e conectividade direta com depuradores SWD ou conversores seriais.

Para que serve?

A placa STM32 Blue Pill serve como unidade central de processamento para sistemas embarcados e projetos que exigem maior poder computacional, tais como:

• Controle e acionamento de máquinas CNC, gravadoras a laser e impressoras 3D (firmwares Marlin e GRBL);
• Dispositivos de automação industrial, aquisição rápida de sinais e instrumentação eletrônica;
• Algoritmos de controle digital, processamento digital de sinais (DSP leve) e aplicações com comunicação serial multiplexada.

Por que devo usar?

• Alto desempenho com baixo custo: processador ARM Cortex-M3 de 32 bits a 72 MHz com até 1,25 DMIPS/MHz por uma fração do custo de placas tradicionais;
• Ampla variedade de periféricos integrados: canais de ADC rápidos de 12 bits, interfaces USART, SPI, I2C, CAN e porta USB nativa;
• Ecossistema profissional ST: suporte completo ao ambiente oficial STM32CubeIDE, ferramentas gráficas de configuração de hardware (CubeMX) e bibliotecas HAL e LL otimizadas.

Quando devo usar?

A placa STM32 Blue Pill é indicada quando:

• O projeto exige maior velocidade de processamento e operações matemáticas de 32 bits que sobrecarregam processadores de 8 bits;
• São necessários múltiplos canais analógicos com resolução de 12 bits ou múltiplos barramentos seriais de alta velocidade no mesmo circuito;
• O desenvolvedor deseja aprender a trabalhar com ferramentas e bibliotecas padrão da indústria de sistemas embarcados (ARM / ST HAL).

Não é a melhor escolha quando:

• O projeto exige suporte nativo sem fio como Wi-Fi e Bluetooth integrado (neste caso, prefira o ESP32 ou ESP8266);
• O circuito requer alimentação direta exclusiva em 5 V sem conversão de níveis lógicos;
• Uma placa simples de entrada como Arduino Uno ou Nano atende perfeitamente sem necessidade de depuração avançada.

Como funciona a arquitetura ARM Cortex-M3 e o ecossistema STM32

O microcontrolador STM32F103 opera sob a arquitetura Harvard com barramentos separados de instruções e dados de 32 bits, pipeline de 3 estágios e controlador de interrupções vetoriais aninhadas (NVIC - Nested Vectored Interrupt Controller), permitindo atendimento ultrarrápido a eventos de hardware com latência previsível.

O ecossistema de software fornecido pela STMicroelectronics organiza o desenvolvimento em camadas:

• Device Configuration Tool (CubeMX integrado): interface gráfica para alocação de pinos (pinout), árvore de clock e inicialização de periféricos;
• Camada HAL (Hardware Abstraction Layer): conjunto de drivers em linguagem C que padronizam o acesso aos registradores de hardware sem necessidade de manipular bits de baixo nível diretamente;
• Compilador e Depurador GNU GCC / GDB: ferramentas de código aberto integradas no Eclipse (STM32CubeIDE) para compilação estática e depuração em tempo real via porta SWD.

Detalhes do produto na loja

Modelo	Código SKU	Microcontrolador	Arquitetura	Tensão de Operação	Dimensões
Placa ARM STM32 Blue Pill	RB0335	STM32F103C8T6	ARM 32 Cortex-M3	2,0 a 3,6 VDC (LDO 5V embutido)	53 × 22 mm

Especificações técnicas

Parâmetro	Valor
Circuito Integrado (CI)	STM32F103C8T6
Núcleo de Processamento	ARM 32-bit Cortex-M3
Frequência Máxima de Clock	72 MHz
Modo de Depuração / Gravação	SWD (Serial Wire Debug) / UART Bootloader / DFU
Memória Flash de Programa	64 kB
Memória SRAM de Dados	20 kB
Resolução do Conversor ADC	12 bits (taxa de conversão de 1 µs)
Número de Canais ADC	10 canais disponíveis nos pinos externos
Tensão de Alimentação nos pinos VCC / Vin	5,0 VDC (passa pelo regulador LDO interno de 3,3 V)
Tensão de Operação do Núcleo (VDD)	2,0 VDC a 3,6 VDC (típico: 3,3 VDC)
Corrente Máxima por Pino GPIO	25 mA (recomendado: até 8 mA por pino)
Interfaces de Comunicação	2× I2C, 2× SPI, 3× USART, 1× CAN 2.0B, 1× USB 2.0 Full Speed
Temporizadores (Timers)	3 timers de uso geral (16 bits) + 1 timer avançado para controle motor/PWM
Temperatura de Operação	−40 ºC a +85 ºC
Dimensões da Placa	53 × 22 mm

⚠️ Atenção: embora a placa possua um regulador onboard que aceita 5 V no pino correspondente, o microcontrolador opera internamente a 3,3 V. A maioria dos pinos GPIO suporta nível de 5 V (marcados como FT - Five-Volt Tolerant no datasheet), mas os pinos analógicos (ADC) suportam apenas no máximo 3,3 V. Ultrapassar 3,3 V nos pinos analógicos pode queimar o canal de conversão.

Diagrama de pinagem e descrição dos terminais

O STM32F103C8T6 conta com pinos multiplexados agrupados nas portas GPIOA, GPIOB e GPIOC. Na placa Blue Pill, os pinos estão dispostos em duas fileiras paralelas facilitando a conexão em protoboards.

Principais grupos de pinos

Pino	Funções Nativas	Observações Técnicas
PC13	GPIO / LED Onboard	Conectado ao LED integrado da placa (ativo em nível lógico LOW)
PA9 / PA10	USART1_TX / USART1_RX	Porta serial principal utilizada para gravação via conversor FTDI
PA2 / PA3	USART2_TX / USART2_RX	Segunda interface serial UART assíncrona
PB6 / PB7	I2C1_SCL / I2C1_SDA	Barramento I2C para conexão com sensores e displays
PA4 / PA5 / PA6 / PA7	SPI1 (NSS, SCK, MISO, MOSI)	Barramento SPI primário de alta velocidade
PA0 a PA7, PB0, PB1	ADC1 / ADC2 (Canais 0 a 9)	Entradas analógicas de 12 bits (tensão máxima de 3,3 V)
PA11 / PA12	USB D− / USB D+	Conectados internamente ao conector micro-USB
SWDIO / SWCLK	Header SWD de 4 pinos	Interface de depuração em tempo real e gravação via ST-Link V2
3.3V / GND / 5V	Pinos de alimentação	Linhas de terra e barramentos de alimentação positivo

💡 Dica: o LED integrado na placa Blue Pill está eletricamente conectado entre o pino PC13 e a linha de 3,3 V. Isso significa que a lógica de acionamento é invertida: ao colocar o pino PC13 em nível baixo (GPIO_PIN_RESET ou 0 V), o LED acende; ao colocar em nível alto (GPIO_PIN_SET ou 3,3 V), o LED apaga.

Como conectar o projeto (Hardware e ligação FTDI)

Para realizar a programação desta placa sem o uso de um gravador ST-Link, utiliza-se o bootloader serial integrado de fábrica gravado em ROM pela STMicroelectronics. Para isso, conectamos um módulo FTDI conversor USB para UART na porta USART1 do STM32 e o ligamos à porta USB do computador.

Conexão dos pinos (STM32 ➔ FTDI)

Pino do STM32 Blue Pill	Pino do Conversor FTDI	Função
GND	GND	Referência comum de terra
5V	5V (ou VCC)	Linha de alimentação da placa
PA10 (USART1_RX)	TXO (Transmissão FTDI)	O STM32 recebe os dados transmitidos pelo computador
PA9 (USART1_TX)	RXI (Recepção FTDI)	O STM32 envia dados de retorno para o computador

Conexão e configuração dos jumpers de Boot

A placa possui dois jumpers amarelos identificados como BOOT0 e BOOT1. A posição desses jumpers define qual memória o microcontrolador executa logo após o reset:

• Modo DFU / Bootloader Serial (Gravação de Firmware): coloque o jumper BOOT0 em 1 (deslocado para a direita) e o jumper BOOT1 em 0 (mantido na posição normal). Nessa posição, o chip inicia a partir da ROM de sistema da ST, pronta para receber o novo programa pela serial. Após mudar os jumpers, aperte o botão Reset ao lado.
• Modo Normal de Execução (Operação Padrão): coloque o jumper BOOT0 em 0 e o jumper BOOT1 em 0. Nessa posição, o chip executa o programa gravado na memória Flash interna.

⚠️ Atenção: sempre que alterar a posição dos jumpers para gravar um novo código ou colocá-lo para rodar em modo normal, pressione o botão físico de Reset na placa para que o microcontrolador reinicie e leia o novo estado das chaves de boot.

Configurando o STM32 no STM32CubeIDE (Software)

Passo 1: Instalação do STM32CubeIDE

Caso ainda não possua o ambiente oficial de desenvolvimento da STMicroelectronics instalado no seu computador, siga os passos abaixo:

1. Acesse a página oficial de download do STM32CubeIDE clicando aqui;
2. Selecione o instalador correspondente ao seu sistema operacional (Windows, Linux ou macOS):

3. Localize a versão mais recente e clique em “Get latest”:

4. Faça o cadastro gratuito informando seu Nome e E-mail para que a STMicroelectronics envie o link de autorização de download;
5. Verifique sua caixa de entrada de e-mail e abra a mensagem de confirmação:

6. Clique no botão “Download now” para iniciar a transferência do instalador:

⚠️ Atenção: após concluir o download, extraia o instalador executável e mova-o para a pasta “Documentos” do seu computador antes de executá-lo com privilégios de administrador. Caminhos com caracteres especiais, acentos ou pastas temporárias podem causar o erro de instalação “error launching installer”.

---

Passo 2: Configurando o STM32 na IDE STM32Cube

Com o STM32CubeIDE instalado, vamos criar um projeto do zero para acionar o LED integrado na placa (conectado ao pino PC13), demonstrando o fluxo equivalente ao exemplo Blink:

1. Abra o STM32CubeIDE e selecione a pasta do seu Workspace (local onde seus projetos serão salvos). Clique em Launch:

2. Na barra de menus superior, acesse File ➔ New ➔ STM32 Project:

3. No campo Commercial Part Number, digite STM32F103C8T6. Na lista de resultados na parte inferior, selecione o chip e clique em Next:

4. Digite o nome do projeto (por exemplo, Robobuilder_teste), mantenha as opções padrão e clique em Finish:

5. Quando a janela pop-up surgir perguntando se deseja abrir a perspectiva associada, clique em Yes:

6. Você verá a interface visual da Ferramenta de Configuração do Dispositivo (Device Configuration Tool / CubeMX), exibindo o encapsulamento físico do CI e seus pinos:

7. No diagrama gráfico do chip, localize o pino PC13 no canto superior esquerdo:
   • Clique com o botão esquerdo sobre o pino PC13;
   • No menu suspenso que aparecer, selecione a opção GPIO_Output:

8. No painel de categorias à esquerda da tela, clique na aba System Core:

9. Dentro de System Core, selecione GPIO. Uma tabela com os pinos configurados surgirá à direita:

10. Clique sobre a linha de configuração do pino PC13 e, no painel inferior de propriedades, altere o campo User Label para Led_integrado:

11. Para salvar as configurações e gerar o código-fonte C estruturado automaticamente, vá no menu File ➔ Save (ou pressione Ctrl+S). Na janela de diálogo que pergunta se você deseja gerar o código (“Do you want to generate Code?”), clique em Yes:

12. Uma nova mensagem solicitará autorização para abrir a perspectiva de desenvolvimento C/C++. Responda Yes:

13. A IDE organizará as janelas exibindo a árvore de arquivos à esquerda, o painel de contorno à direita e o arquivo principal main.c aberto na área central:

Construindo o código Blink (HAL)

Com o arquivo Core/Src/main.c gerado pela ferramenta, implementamos as rotinas de acionamento de saída e temporização.

Estrutura da função de temporização (delay)

Para criar um atraso de tempo simples sem timers adicionais, implementamos uma função auxiliar com contagem em loop volátil.

No topo do arquivo main.c, na seção de protótipos de funções de usuário (/* USER CODE BEGIN PFP */), adicione a declaração da função:

/* USER CODE BEGIN PFP */
void delay(int a);                     // protótipo da função auxiliar de atraso
/* USER CODE END PFP */

Ao final do arquivo main.c, na seção dedicada para funções de usuário (/* USER CODE BEGIN 4 */), implemente a função delay():

/* USER CODE BEGIN 4 */
void delay(int a)                      // função auxiliar de atraso por software
{                                      // início do bloco da função
  volatile int i, j;                   // declara variáveis voláteis para impedir otimização do compilador
  for (i = 0; i < a; i++)              // loop de repetição até atingir a contagem requisitada
  {                                    // início do bloco for
    j++;                               // incrementa variável de passo
  }                                    // fim do bloco for
  return;                              // retorna para a função chamadora
}                                      // fim da função delay
/* USER CODE END 4 */

Loop principal de controle do LED

Dentro da função main(), localize o loop infinito while (1) na seção /* USER CODE BEGIN WHILE */ e insira o código que alterna os estados lógicos do pino:

  /* Infinite loop */
  /* USER CODE BEGIN WHILE */
  while (1)
  {
    HAL_GPIO_WritePin(Led_integrado_GPIO_Port, Led_integrado_Pin, GPIO_PIN_RESET); // acende o LED (pino em nível lógico baixo 0V)
    delay(500000);                                                                 // aguarda meio segundo em contagem de software
    HAL_GPIO_WritePin(Led_integrado_GPIO_Port, Led_integrado_Pin, GPIO_PIN_SET);   // apaga o LED (pino em nível lógico alto 3.3V)
    delay(500000);                                                                 // aguarda meio segundo em contagem de software
    /* USER CODE END WHILE */

    /* USER CODE BEGIN 3 */
  }
  /* USER CODE END 3 */

💡 Dica: a função nativa da biblioteca HAL HAL_GPIO_WritePin() recebe três parâmetros: a porta física (GPIOx), o número do pino (GPIO_PIN_x) e o estado desejado (GPIO_PIN_SET para nível alto ou GPIO_PIN_RESET para nível baixo). Você também pode utilizar a função oficial HAL_Delay(500) baseada no SysTick timer interno do microcontrolador para temporizações precisas em milissegundos.

Compilação do projeto

Com as alterações salvas no arquivo main.c:

1. No menu superior da IDE, clique em Project ➔ Build All (ou pressione o atalho de teclado Ctrl+B):

2. O compilador GNU ARM iniciará a compilação de todas as bibliotecas da HAL e do código da aplicação. Verifique na aba inferior Console se o processo encerrou com 0 errors, 0 warnings:

Gravação no microcontrolador via FTDI

Para descarregar o binário compilado no STM32 Blue Pill através do conversor serial:

1. Certifique-se de que os jumpers estão configurados no Modo DFU (BOOT0 em 1 e BOOT1 em 0);
2. Pressione o botão físico Reset na placa;
3. Utilize o software STM32CubeProgrammer (ou utilitário STM32 Flash Loader Demonstrator), selecione a porta COM correspondente ao FTDI, conecte e faça o upload do arquivo binário (.bin ou .hex) gerado na pasta Debug do projeto;
4. Após o término da gravação com sucesso, retorne o jumper BOOT0 para a posição 0 (Modo Normal de Execução) e pressione Reset novamente. O LED verde conectado ao pino PC13 começará a piscar continuamente no intervalo definido.

Conclusão

Este manual abordou de forma completa o processo de utilização e programação da placa de desenvolvimento STM32 Blue Pill (STM32F103C8T6), desde os fundamentos de arquitetura até o desenvolvimento e gravação de firmware no STM32CubeIDE:

• O que é e arquitetura: placa de alto desempenho baseada no microcontrolador ARM Cortex-M3 de 32 bits a 72 MHz com 64 kB de Flash e 20 kB de SRAM.
• Especificações técnicas: faixa de operação de 2,0 a 3,6 VDC, regulador de 3,3 V integrado, 10 canais analógicos de 12 bits e suporte a interfaces USART, SPI, I2C, CAN e USB.
• Pinagem e diagrama: mapeamento dos pinos das portas GPIOA, GPIOB e GPIOC, com ênfase no pino PC13 conectado ao LED integrado em lógica invertida.
• Conexão de hardware: esquema de ligação completo entre a placa e o conversor serial USB-UART FTDI, detalhando as linhas TX/RX e alimentação.
• Configuração dos jumpers de boot: distinção prática entre o modo de programação DFU (BOOT0=1) e o modo normal de execução em Flash (BOOT0=0).
• Configuração de software: instalação passo a passo do STM32CubeIDE, criação de projeto no assistente gráfico Device Configuration Tool, rotulação do pino PC13 e geração automática de código HAL.
• Construção do código e compilação: implementação do controle de GPIO com HAL_GPIO_WritePin, rotina de atraso de temporização e compilação com zero erros no toolchain GCC.

A placa STM32 Blue Pill é uma solução extremamente potente e acessível para quem precisa de robustez computacional, múltiplos periféricos velozes e compatibilidade profissional com o ecossistema STM32.

Solução de problemas

Olá! Sou o assistente técnico da RoboBuilders. Descreva seu problema com o Como Usar o STM32 Blue Pill com STM32CubeIDE: Manual Técnico Completo e eu ajudarei a encontrar a solução.

Enviar

O assistente usa IA e pode errar. Confirme informações críticas no datasheet oficial do fabricante.