Atualmente, podemos dizer que quase todos os especialistas e entusiastas em sistema embarcados certamente já tiveram algum contato com plataformas Arduino, e quem se familiarizou com as diversas bibliotecas e ferramentas gratuitas, provavelmente teve algum apego a simplicidade oferecida pelos parâmetros de programação do mesmo. O objetivo dessa postagem será a apresentação introdutória da placa STM32, que será uma excelente alternativa para aqueles que desejam trabalhar com microcontroladores mais ágeis e precisos sem sair do conforto oferecido pela IDE do Arduino.

          Para concluir as atividades desse post, tenha em mãos os seguintes componentes:

          Você pode compra-los clicando nos links acima ou visitando nosso site: www.curtocircuito.com.br.

    

Características e Funções

          Apelidado como Blue Pill em fóruns de programação como o STM32duino, este sistema baseia-se em microcontroladores STM32F103, desenvolvidos pela empresa STMicroeletrics. A placa de prototipagem STM32 apresenta-se como uma ferramenta inovadora para aqueles que desejam obter um melhor desempenho em seus projetos, afinal, tal dispositivo dispõe de um processador de 32 bits com arquitetura Cortex-M3 ARM, uma das melhores ferramentas de execução em Real-Time, além de operar a 72Mhz, com duas configurações de núcleo, sendo como padrão comum 64 Kb de memória Flash, e 128 Kb testados virtualmente em versões C8.           

          Esse componente passou a ganhar fama, principalmente, pela possibilidade de atuar como um Arduino, sendo em muitos artigos comparado a modelos como Nano, além de apresente vantagens como processamento, maior quantidade de portas analógicas, e possuir um valor de mercado relativamente mais baixo. Para expressar melhor tais diferenças, observe a tabela apresentada abaixo, onde realizaremos uma breve comparação entre os sistemas operacionais de um STM32 e alguns dos modelos mais comuns de placas Arduino.

A tabela a seguir fará um breve comparativo entre modelos populares de placas Arduino, e o STM32.


         Embora não seja tão popular quanto as placas da família Arduino, o Blue Pill oferece uma maior vantagem, tanto no quesito de potência quanto no aprendizado. Além dos parâmetros apresentados acima, podemos citar também alguns pontos interessantes, como os dois cristais osciladores presente no STM32, um com 8MHz e outro de 32MHz, que poderão ser utilizados para acionar o RTC (Real Time Clock) interno, possibilitando a aplicação de modos de operação econômicos, permitindo que a placa entre em sono profundo (Deep Sleep).

Pinagem

          O microcontrolador em si atua com apenas 3,3V, porém, a placa possui um regulador de tensão IC para permitir que alguns dos pinos GPIO comporte valores de até 5V. Analisando a pinagem de um STM32, podemos encontrar 33 portas GPIO, que variam sua tolerância entre 3,3V e 5V, além 3 canais SPI e I2S, 10 leitores ADC de 12 bits, 3 USART e 15 pinos PWM.  No diagrama abaixo, será apresentado um breve resumo das funções presentes na pinagem de um Blue Pill.

Conheça os pinos GPIO, PWM,Analógico, Digital e USART presentes em um STM32.


          Os valores destacados em amarelo, denominados na legenda como "Pin Name", serão utilizados para declarar os pinos em programações via Arduino IDE. Por exemplo, para declarar um LED conectado ao pino 2 (PC13) , o programador deverá escrever : pinMode(PC13, OUTPUT);


Como configurar a pinagem de um STM32 por meio do Arduino IDE.

          Procure analisar bem a legenda antes de conectar qualquer componente, afinal, alguns pinos como o próprio PC13, não toleram valores acima de 3,3V, além de apresentar outras características exclusivas. 


STM32 na IDE do Arduino
 

          O Blue Pill poderá ser programado em outras opções de plataformas como PlatformIO, Eclipce, porém, o software de programação oferecido pela empresa Arduino possui uma comunidade forte, que dissemina múltiplos materiais de auxilio e bibliotecas que facilitam o desenvolvimento com STM32. A ide de programação estará disponível gratuitamente no site oficial Arduino.cc.

          Para compilar quaisquer programações em um microcontrolador via Arduino IDE, será necessário selecionar um dos modelos de placas compatíveis com software, no caso de placas STM32 e similares, será preciso adicionar um novo conjunto nas opções de gerenciamento de placas, portanto, acesse o menu Arquivo >> Preferências>> URLs Adicionais para Gerenciamento de Placas, adicione o seguinte endereço: 

http://dan.drown.org/stm32duino/package_STM32duino_index.json

         

Configure as Preferências do Arduino IDE, para que a placa seja reconhecida pelo software.


         
Em seguida abra o menu Ferramentas >> Placa >> Gerenciador de Placas. Na barra de pesquisa, escreva STM32F1xx e instale a versão mais recente do conjunto.
 

No gerenciador de placas será possível adicionar um conjunto de Placas compatíveis com a IDE.
         
          Infelizmente, não será possível transferir nenhuma programação diretamente pelo conector USB, ao menos não inicialmente, afinal, um pequeno problema encontrado nesse tipo de placa será a ausência do Gerenciador de Inicialização (Bootloader), utilizado na comunicação entre o computador e o microcontrolador. Diversos desenvolvedores dos fóruns STM32duino e derivados publicaram soluções variadas a esta questão, portanto, nos tópicos a seguir iremos apresentar os métodos mais plausíveis, explorando algumas as formas mais simples de se gravar um Blue Pill através do Arduino IDE.


Compilando Programações sem Bootloader no ST-Link

          O ST-Link irá fornecer o método menos complexo e mais direto de se transferir programações ao Blue Pill, servindo tanto na gravação de firmware quanto para debugar códigos. A conexão entre o gravador ST e o STM32 será bem simples, basta conectar os pinos SWCLK, SWDIO, GND e 3.3V de ambos os componentes, utilizando jumpers Fêmea-Fêmea como mostra o exemplo a seguir.

A programação poderá ser transferida diretamente pelo ST-Link, sem haver a necessidade de adicionar o Bootloader a placa.


          Conecte o ST-Link ao computador, vá ao software de programação e clique em Arquivos >> Exemplos >> Básicos >> Blynk. Substitua as variáveis "LED_BUILTIN" pelo valor escrito ao lado do LED verde (ou azul), que na maioria dos casos será "PC13", como algumas placas STM32 costumam vir com este mesmo programa instalado, troque os valores de delay por algo como 1000 e 100, ou 1000 e 500, apenas para que o piscar do LED siga um ritmo diferente do padrão.

// Projeto Curto Circuito – Blynk Blue Pill (STM32)

void setup() 
{
  // PC13, LED embutido na própria placa 
  pinMode(PC13, OUTPUT);
}

void loop() 
{
  digitalWrite(PC13, HIGH);   // LED conectado ao PC13 Liga
  delay(1000);                // Aguarda 1 segundo
  digitalWrite(PC13, LOW);    // LED conectado ao PC13 Desliga
  delay(500);                 // Aguarda meio segundo
}

          Ajuste as configurações da placa no menu Ferramentas, como mostra a imagem abaixo. Normalmente, selecionamos uma COM correspondente ao componente na opção Porta, no entanto, o ST-Link não será reconhecido pela IDE do Arduino, mas isso não será um problema, a programação poderá ser transferida normalmente desde que a opção Upload method esteja ajustada como "STLink".    


Selecione o modelo Generic STM32F103C, e o Método como "STLink" para que a programação seja transferida a placa.

          Após compilar o código, observe que o LED PC13, embutido na própria placa, deverá piscar de acordo com os valores especificados na programação. Qualquer programação poderá ser compilada dessa forma, porém, vale destacar que com esse método não será possível utilizar ferramentas como o Plotter/Monitor Serial da IDE do Arduino.


Para que a programação Blink funcione, substitua os termos LED_BUILD pelo valor PC13.

          Para auxiliar no desenvolvimento de futuros projetos, clique em Sketch >> Incluir Biblioteca >> Gerenciar Bibliotecas. Escreva “STM32” na barra de pesquisa do gerenciador, e procure adicionar ao menos um conjunto de exemplos, que poderão simplificar a construção de funções e lógicas voltadas ao STM32.


Adicione ao menos um conjunto com funções básicas e exemplos voltados ao STM32.


Mapple Mini: Bootloader e Comunicação USB

          Como foi dito anteriormente, para habilitar a comunicação USB será necessário instalar um bootloader compatível no STM32, que poderá ser facilmente encontrado no Github STM32duino, criado por Roger Clark. Se o LED embutido na placa estiver conectado no pino PC13, baixe apenas o arquivo "generic_boot20_pc13.bin". O bootloader será instalado através de duas ferramentas, o STSW-LINK009, disponível gratuitamente, com os drives para placas STM32 e derivações ST-LINK / V2 e ST-LINK / V2-1, e o utilitário STSW-LINK004, aplicado a leitura, verificação e gravação do dispositivo. O download encontra-se disponível gratuitamente, exigindo apenas um pequeno cadastro com o nome e e-mail dos usuários. Nos arquivos STSW-LINK009, instale o aplicativo x86 ou amd64, obtendo um resultado similar ao apresentado a seguir.


Para utilizar o micro USB do STM32, será necessário adicionar alguns drives específicos, disponíveis gratuitamente pela STMicro.

          Após intalar os drivers, conecte a placa STM32 ao computador através do gravador ST-Link, abra STSW-LINK004, instale e execute a ferramenta STM32 ST-LINK Utility. Clique no menu File >> Open Files, e procure pelo bootloader que deseja instalar, que no caso, será documento ".bin" baixado anteriormente. Para que o STM possa se conectar ao software, coloque o plug BOOT 0 na posição 1 como mostra o exemplo abaixo.


Para gravar o bootloader no STM32, será necessário mudar a posição do plug BOOT0 para 1.


          C
lique em Target >> Connect, para conectar-se, em seguida retorne em Target >> Program, e inicie a gravação do bootloader na memória flash do STM32.


O bootloader será gravado na memória flash do microcontrolador.


          Com o termino do procedimento, desconecte a placa e retorne o plug BOOT 0 a posição 0. Acesse o GitHub e baixe os arquivos Arduino_STM32, cuja função será instalar o restante dos drivers necessários, fornecendo uma COM ao conectar-se diretamente via USB. Após extrair o conteúdo, acesse a pasta drivers e procure pelos aplicativos install_drivers e install_STM_COM_drivers, execute ambos e reinicie a IDE do Arduino. Agora, sempre que conectar o STM32 pelo USB, será apresentado um endereço para a comunicação serial.


Após instalar o bootloader e os drives necessários, o STM32 passará a ser reconhecido pela IDE.


          Para testar o funcionamento da transmissão de informações pela porta USB, iremos propor uma programação simples, acionando componentes através de comandos enviados pela ferramenta monitor serial da IDE do Arduino. Na construção do circuito elétrico, conecte LEDs aos terminais PC15, PC14 e PC13.

Adicione três LEDs ao circuito, para testar a comunicação entre a placa o computador.

          Transfira a programação a seguir:
// Projeto Curto Circuito – ETM32: Monitor Serial 

// Variáveis para o controle dos LEDs
int LED = PC13;
int LED2 = PC14;
int LED3 = PC15;

// Variáveis Lógicas
int st1 = 0;
int st2 = 0;
int st3 = 0;

void setup() 
{
  // Declara a pinagem dos LEDs como OUTPUT.
  pinMode(LED, OUTPUT);
  pinMode(LED2, OUTPUT);
  pinMode(LED3, OUTPUT);
  // Ajusta a comunicação em 9600 dbs
  Serial.begin(9600);


}


void loop() 
{
  char choice = Serial.read(); // Lê os caracteres escritos no monitor serial

  if (choice == '1')
  { // Se receber 1
    st1 = !st1; // Troca o valor atual de st1(variando entre 0 e 1)
    if (st1 == 1)
    {// Se o valor de st1 for 1 
      digitalWrite(LED, HIGH);   // Liga o LED
      Serial.println("LED ON");  
    }
    else
    {// Se o valor de st1 for 0 
      digitalWrite(LED, LOW);   // Desliga o LED 
      Serial.println("LED OFF");
    }
  }
  if (choice == '2')
  { // Se receber 2
       st2 = !st2;// Troca o valor atual de st2(variando entre 0 e 1)
    if (st2 == 1)
    {// Se o valor de st2 for 1 
      digitalWrite(LED2, HIGH);  // Liga o LED
      Serial.println("LED2 ON");
    }
    else
    {// Se o valor de st2 for 0 
      digitalWrite(LED2, LOW);   // Desliga o LED 
      Serial.println("LED2 OFF");
    }
  }
  if (choice == '3')
  { // Se receber 3
      st3 = !st3;// Troca o valor atual de st3(variando entre 0 e 1)
    if (st3 == 1)
    {// Se o valor de st3 for 1 
      digitalWrite(LED3, HIGH);  // Liga o LED 
      Serial.println("LED3 ON");
    }
    else
    {// Se o valor de st3 for 0
      digitalWrite(LED3, LOW);   // Desliga o LED 
      Serial.println("LED3 OFF");
    }
  }
}
          O funcionamento da programação será baseado na leitura dos caracteres enviados através dos monitos serial, os valores coletados serão armazenadas em char choise e interpretados pela função Serial.read()As variáveis "st1 st2 e st3 " serão responsáveis pelo acionamento dos LEDs, alternando o valor atual de cada um ao receber um determinado caractere, que, no caso, será 1 para o controle do pino PC13, 2 para o pino PC14, e 3 para o pino PC15, avisando sobre o status de cada um diretamente pelo monitor serial.


Ao enviar os comandos 1, 2 ou 3, através do monitor serial, os LEDs deverão alterar seus níveis lógicos.

         

ADC – Leitura Analógica

          Conhecidos como Conversores Analógicos para Digitais, este tipo de recurso possibilita a leitura de valores analógicos presente em diversos tipos de sensores e componentes. Diferente do padrão encontrado nos modelos populares de Arduino, com terminais ADC de 10 bits e um intevalo entre 0 e 5V, os canais analógicos disponíveis no STM32 operam com 12 bits e tensão de entrada de 0 á 3,3V. A taxa de bits aplicada a cada terminal implica diretamente na resolução da leitura, que poderá ser calculado de forma simples, por exemplo, temos 12 bits, em outras palavras dois elevado a doze (2¹²) , que resulta em 4096, ou seja, a faixa de leitura dos terminais analógicas será de 0 á 4095.

          Trabalhar com qualquer um dos 10 pinos ADC será exatamente igual ao procedimento utilizado em placas Arduino, realizando leituras e controle por meio de funções como analogRead e analogWrite. o único diferencial será observado ao declarar a pinagem, que ao invés de utilizar termos como A0 ou B0, será declarado como PA0 ou PB0.


A pinagem analógica de placas STM32 operam a uma resolução de 12 bits, com faixa de leitura de 0 á 4095.


          Para testar o funcionamento dos conversores ADC, transfira a programação a seguir, onde iremos aplicar os valores de leitura de um potenciômetro ao controle do delay de um LED, imprimindo os valores obtidos no monitor serial.  

// Projeto Curto Circuito – ETM32: Leitura Analógica

int analogPin = PA0;   // Declara PA0 para a leitura analógica
int sensor = 0;        // Variavel para armazenar a leitura do sensor
int LED = PC13;        // LED conectado ao pino PC13


void setup()
{

  pinMode(sensor, INPUT);
  pinMode(LED, OUTPUT);

  Serial.begin(9600);
}

void loop()
{
  sensor = analogRead(analogPin); //Armazena os valores de leiuta de analogPin
 
  Serial.println(sensor);
  
  digitalWrite(LED, HIGH); // LED Liga
  delay(sensor);           // O delay será igual ao valor de sensor
  digitalWrite(LED, LOW);  // LED Desliga
  delay(sensor);

}

          Na  construção do circuito referente a atividade proposta, adicione um potenciômetro linear de 1K, conectando o terminal no meio do componente ao pino PA0, os demais terminais nos pinos GND e 3,3 V do Protoboard, e um LED ao pino PC13.


O STM32 fará uma leitura dos valores presente no potenciômetro, controlando o delay do LED.


          O potenciômetro será utilizado para ajustar a faixa de leitura do pino PA0 entre 0 á 4095. O comando analogRead terá a função de obter os valores do terminal analógico, armazenando-os na variável "sensor", que será aplicado ao delay, resultando em períodos de tempo distintos entre o piscar do LED.


Controle PWM

          Sinais analógicos variam continuamente, sendo por muitas vezes difícil definir seu valor real, enquanto os sinais digitais possuem uma variação mais previsível, alternando entre dois níveis lógicos, ligado (0) e desligado (1). O controle PWM (Modulação de Largura de Pulso) é uma técnica adotada por muitos Microcontroladores, por ser uma forma eficiente de controlar sinais analógicos digitalmente. Este tipo de controle encontra-se em 1terminais, operando com resolução de 16 bits (0 á 65535), e a tensão de entrada máxima variando entre 3,3 V e 5 V de acordo com o terminal.



           O PWM será responsável por codificar sinais, onde uma onda quadrada será modulada para receber a leitura analógica tornando-a digital, e por fim ajustando-a de acordo com a amplitude desejada. Na figura abaixo, serão apresentados 3 sinais analógicos codificados a 10%, 50% e 90%, ajustando a intensidade de um LED de acordo com o pulso gerado.


Os valores analógicos serão codificados pelo PWM, ajustando a luminosidade do LED de acordo com o Pulso gerado.


            Para testar o funcionamento de um terminal PWM, transfira 
a programação a seguir, onde a leitura analógica de um potenciômetro será aplicada ao controle da luminosidade de um LED. 

// Projeto Curto Circuito – ETM32: Controle PWM

const int analog = PA0;  // Terminal Analógico para o Potenciômetro
const int pwm = PB9;     // PWM para controlar a luminosidade do LED

// Variáveis lógicas
int sensorValue = 0;        // Armazena os valores de leitura do Potenciômetro
int outputValue = 0;        // Valor de saída para o PWM

void setup() 
{
    // Configura o pino ADC como INPUT
    pinMode(analog, INPUT);
    // Configura o pino do LED como PWM
    pinMode(pwm, PWM);
}

void loop()
{
    // Lê o potênciometro e armazena na variável
    sensorValue = analogRead(analog);
    //Mapeia o valor de leitura
    outputValue = map(sensorValue, 0, 4095, 0, 65535);
    // Adiciona o valor analógico ao PWM
    pwmWrite(pwm, outputValue);
 }

          O circuito será similar ao utilizado anteriormente, trocando apenas o terminal de comunicação do LED para o PB9, que será um terminal PWM capaz de codificar os valores enviados pelo potenciômetro PA0, ajustando a luminosidade de acordo com o sinal recebido.


O potenciômetro será utilizado para gerar leituras analógicas, que serão convertidas para o ajuste da intensidade do LED.       

          O comando pwmWirte será responsável por aplicar uma onda quadrada constante ao LED, com um ciclo de operação específico, que no caso, será atribuído a variável outputValue.  O valor de tal variável será obtido de acordo com o mapeamento dos valores de leitura obtidos pelo potenciômetro em "sensorValue". 

 outputValue = map(sensorValue, 0, 4095, 0, 65535);

          A função map irá avaliar os valores armazenados na variável "sensorValue", mapeando a leitura de acordo com os intervalos determinados, que foram divididos em quatro valores, 0(mínimo_in), 4095 (máximo_in), 0 (mínimo_out), 65535 (máximo_out), sendo eles separados entre valores de entrada (in), correspondendo a resolução de leitura dos pinos ADC ( 0 á 4095), e valores de saída (out), com a amostragem dos pinos PWM (0 á 65535).

          A lógica matemática por trás da função map será apresentada na imagem a seguir, onde "x" será um valor de referência a ser mapeado, e os demais valores serão os limites.


A função MAP fará um Re-mapeamento dos valores gerados pelo potenciômetro.


          Suponha que a leitura em sensorValue seja igual a 200, se aplicarmos a fórmula apresentada acima teremos: return( 200 - 0) * (65535 - 0) / (4095 - 0) + 0 =  3200, esse valor aplicado a uma simples regra de três representaria a porcentagem do sinal de acordo com o valor máximo da lógica (65535), que resultaria em aproximadamente 4%. 


A leitura analógica varia entre 0 e 4095, enquanto o PWM transforma essa amostragem em uma onda quadrada.


Considerações Finais

          O STM32 apresenta-se como uma opção completa para aqueles que desejam obter um melhor desempenho, sem abandonar as inúmeras vantagens oferecidas pela plataforma de desenvolvimento da empresa Arduino. Este pequeno componente, comparado em muitos fóruns com os modelos Nano e UNO, apresenta inúmeros atrativos como o núcleo de processamento ARM Cortex-M3 com taxa de Clock de 24 á 72 MHz, fornecendo um grande aumento na velocidade da CPU, além de memórias Flash e RAM com o dobro da capacidade fornecida pelos seus concorrentes, por um preço consideravelmente menor. Quem simpatiza com a família Arduino, certamente irá se apaixonar pelo desempenho eficiente fornecido pela Blue Pill. 

          Gostou do tutorial? Curta nossa página e compartilhe! Conhecimento bom é conhecimento compartilhado!