Conhecendo o STM32 ou Bluepill

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.

          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 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 15 terminais, 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.

            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 comando pwmWriteserá 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 a 4095), e valores de saída (out), com a amostragem dos pinos PWM (0 a 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.

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!