BluePill com STM32CubeIDE

Introdução

No post Placa De Desenvolvimento Stm32f103c8t6 Arm Stm32, aprendemos a programar a BluePill pelo Arduino IDE. Neste, usaremos o STM32CubeIDE, ambiente de desenvolvimento oficial da STMicroelectronics.

Baixar e Instalar

Para baixar o software, acesse a página de downloads do site oficial. Nesta, selecione, na lista “Get Software”, o instalador para o sistema operacional de seu PC.

Lista com os instaladores

Leia e aceite os termos de compromisso, faça o login, cadastro ou verificação e baixe o arquivo .zip com o instalador.

Arquivo baixado

Descompacte-o na pasta de sua preferência e, como administrador, execute-o. Proceda com a instalação normalmente, selecionando para que ambos os pacotes de drivers sejam, também, instalados.

Tela de seleção de componentes adicionais

Ao fim, todo o ambiente estará instalado.

Materiais Necessários para o Projeto BluePill com STM32CubeIDE

• Placa de Desenvolvimento STM32F103C6T6 Arm Stm32
• Programador ST-LINK V2

Pisca LED

Ao abrir, pela primeira vez, o IDE, é possível definir a pasta utilizada como diretório dos projetos neste desenvolvidos.

Janela de seleção do diretório de projetos

Após definir o diretório, será possível iniciar o projeto. Para isso, na tela inicial, clique em “Start new STM32 project”, na região superior-esquerda.

Tela inicial do IDE

Isso abre o seletor de alvo, em que devemos buscar, no campo “Commercial Part Number”, por STM32F103C6T6A e selecionar a primeira opção da lista, como mostra a imagem a seguir.

Tela de seleção de alvo do projeto

Após clicar em “Next”, deve-se escolher o nome do projeto, a linguagem utilizada e clicar em “Finish”.

Tela final da configuração do projeto

Feito isso, deve ser carregada a interface gráfica de configuração do chip.

Interface gráfica de configuração do chip

Nesta, abra o menu “SYS”, na categoria “System Core”, selecione, no campo “Debug”, “Serial Wire” e, no “Timebase Source”, “SysTick”.

Configuração do sistema do chip

Na mesma categoria, no menu “RCC”, em “High Speed Clock (HSE)”, selecione “Crystal/Ceramic Resonator”.

Controlador de clock

No campo “Pinout View”, clique, com o botão esquerdo do mouse, sobre o pino PC-13. Então, clique em “GPIO_Output”, para configurá-lo como saída digital.

Definição de função do pino PC-13

Em seguida, clique, sobre o mesmo pino, com o botão direito do mouse, fazendo com que seja exibido o respectivo menu. Neste, clique em “Enter User Label”.

Menu de preferências do pino

No campo agora aberto, digite “pinoLED”.

Campo de nomeação do pino

Na próxima tela, “Clock Configuration”, selecione, em “PLL Source Mux”, a opção inferior, “HSE”, e, em “System Clock Mux”, “PLCCCLK”.

Configuração de clock

Então, tecle “Ctrl+S”, para salvar as configurações. Isso fará surgir uma janela questionando se o código correspondente a estas configurações deve ser criado. Clique em “Yes”.

Janela de geração de código

Caso seja questionado quanto à mudança de perspectiva, clique em “Yes”. O código gerado já realiza toda a configuração necessária para a inicialização dos periféricos utilizados. Assim, resta, na estrutura while (1), da main, inserir o código responsável pelo piscar do LED. Para isso, digite, entre o “abre chaves” da estrutura e o comentário /* USER CODE END WHILE */, HAL_GPIO_TogglePin(pinoLED_GPIO_Port, pinoLED_Pin); e, entre este comando e o comentário, HAL_GPIO_TogglePin(pinoLED_GPIO_Port, pinoLED_Pin);, como mostrado a seguir.

Código com as adições do projeto

O arquivo main.c deve estar, ao fim, como visto abaixo.

/* USER CODE BEGIN Header */
/**
  ******************************************************************************
  * @file           : main.c
  * @brief          : Main program body
  ******************************************************************************
  * @attention
  *
  * Copyright (c) 2023 STMicroelectronics.
  * All rights reserved.
  *
  * This software is licensed under terms that can be found in the LICENSE file
  * in the root directory of this software component.
  * If no LICENSE file comes with this software, it is provided AS-IS.
  *
  ******************************************************************************
  */
/* USER CODE END Header */
/* Includes ------------------------------------------------------------------*/
#include "main.h"

/* Private includes ----------------------------------------------------------*/
/* USER CODE BEGIN Includes */

/* USER CODE END Includes */

/* Private typedef -----------------------------------------------------------*/
/* USER CODE BEGIN PTD */

/* USER CODE END PTD */

/* Private define ------------------------------------------------------------*/
/* USER CODE BEGIN PD */
/* USER CODE END PD */

/* Private macro -------------------------------------------------------------*/
/* USER CODE BEGIN PM */

/* USER CODE END PM */

/* Private variables ---------------------------------------------------------*/

/* USER CODE BEGIN PV */

/* USER CODE END PV */

/* Private function prototypes -----------------------------------------------*/
void SystemClock_Config(void);
static void MX_GPIO_Init(void);
/* USER CODE BEGIN PFP */

/* USER CODE END PFP */

/* Private user code ---------------------------------------------------------*/
/* USER CODE BEGIN 0 */

/* USER CODE END 0 */

/**
  * @brief  The application entry point.
  * @retval int
  */
int main(void)
{
  /* USER CODE BEGIN 1 */

  /* USER CODE END 1 */

  /* MCU Configuration--------------------------------------------------------*/

  /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
  HAL_Init();

  /* USER CODE BEGIN Init */

  /* USER CODE END Init */

  /* Configure the system clock */
  SystemClock_Config();

  /* USER CODE BEGIN SysInit */

  /* USER CODE END SysInit */

  /* Initialize all configured peripherals */
  MX_GPIO_Init();
  /* USER CODE BEGIN 2 */

  /* USER CODE END 2 */

  /* Infinite loop */
  /* USER CODE BEGIN WHILE */
  while (1)
  {
    HAL_GPIO_TogglePin(pinoLED_GPIO_Port, pinoLED_Pin);
    HAL_Delay(500);
    /* USER CODE END WHILE */

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

/**
  * @brief System Clock Configuration
  * @retval None
  */
void SystemClock_Config(void)
{
  RCC_OscInitTypeDef RCC_OscInitStruct = {0};
  RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};

  /** Initializes the RCC Oscillators according to the specified parameters
  * in the RCC_OscInitTypeDef structure.
  */
  RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;
  RCC_OscInitStruct.HSEState = RCC_HSE_ON;
  RCC_OscInitStruct.HSEPredivValue = RCC_HSE_PREDIV_DIV1;
  RCC_OscInitStruct.HSIState = RCC_HSI_ON;
  RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
  RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
  RCC_OscInitStruct.PLL.PLLMUL = RCC_PLL_MUL2;
  if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
  {
    Error_Handler();
  }

  /** Initializes the CPU, AHB and APB buses clocks
  */
  RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK
                              |RCC_CLOCKTYPE_PCLK1|RCC_CLOCKTYPE_PCLK2;
  RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
  RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
  RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV1;
  RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;

  if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_0) != HAL_OK)
  {
    Error_Handler();
  }
}

/**
  * @brief GPIO Initialization Function
  * @param None
  * @retval None
  */
static void MX_GPIO_Init(void)
{
  GPIO_InitTypeDef GPIO_InitStruct = {0};

  /* GPIO Ports Clock Enable */
  __HAL_RCC_GPIOC_CLK_ENABLE();
  __HAL_RCC_GPIOD_CLK_ENABLE();
  __HAL_RCC_GPIOA_CLK_ENABLE();

  /*Configure GPIO pin Output Level */
  HAL_GPIO_WritePin(pinoLED_GPIO_Port, pinoLED_Pin, GPIO_PIN_RESET);

  /*Configure GPIO pin : pinoLED_Pin */
  GPIO_InitStruct.Pin = pinoLED_Pin;
  GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
  HAL_GPIO_Init(pinoLED_GPIO_Port, &GPIO_InitStruct);

}

/* USER CODE BEGIN 4 */

/* USER CODE END 4 */

/**
  * @brief  This function is executed in case of error occurrence.
  * @retval None
  */
void Error_Handler(void)
{
  /* USER CODE BEGIN Error_Handler_Debug */
  /* User can add his own implementation to report the HAL error return state */
  __disable_irq();
  while (1)
  {
  }
  /* USER CODE END Error_Handler_Debug */
}

#ifdef  USE_FULL_ASSERT
/**
  * @brief  Reports the name of the source file and the source line number
  *         where the assert_param error has occurred.
  * @param  file: pointer to the source file name
  * @param  line: assert_param error line source number
  * @retval None
  */
void assert_failed(uint8_t *file, uint32_t line)
{
  /* USER CODE BEGIN 6 */
  /* User can add his own implementation to report the file name and line number,
     ex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */
  /* USER CODE END 6 */
}
#endif /* USE_FULL_ASSERT */

Para compilar o código, clique, na barra de ferramentas, em “build”, representado por um martelo. Os detalhes da compilação serão exibidos no console, na região central-inferior da tela.

Processo de compilação do programa

O carregamento do programa deve ser feito por meio do ST-LINK V2. Este deve ser conectado à placa conforme o diagrama abaixo.

Conexão entre BluePill e ST-LINK V2

Com a placa ligada ao gravador, conecte-o ao computador. Daí em diante, caso seja solicitada a instalação de algum driver, no PC, ou firmware, no gravador, opte, em ambos os casos, pelo mais recente. Feitas as instalações necessárias, clique, na barra de ferramentas, em “Run”, “Run as” e, por fim, em “STM32 C/C++ Application”.

Caminho de ferramentas para a gravação do código

Será exibida uma janela com as configurações de execução, em que nenhuma alteração deve ser feita.

Configurações de execução do programa

Após clicar em “OK”, o programa será executado pela placa:

Referências

• https://www.youtube.com/watch?v=Azr5vjbgACM;

Sobre o Autor

Eduardo Henrique Formado técnico em mecatrônica no CEFET-MG, atualmente estuda Engenharia de Controle e Automação na UFMG.