Os microcontroladores fazem parte de qualquer equipamento eletrônico moderno, de rádios, telefones celulares, brinquedos, equipamentos industriais, médicos, de navegação, controle, etc. Conhecer e praticar com eles é muito útil para o desenvolvimento de sistemas eletrônicos. A plataforma Arduino nos permite de forma fácil, nos apresentarmos no mundo dos microcontroladores e suas aplicações. Neste artigo, veremos os códigos mais comuns no mundo dos microcontroladores e Arduino. Os botões e os LEDs são os componentes eletrônicos mais comuns em qualquer circuito e é importante saber como programá-los.

MIC026E

 

   Arduino é uma plataforma de desenvolvimento que usa pequenos computadores (microcontroladores) para a criação de equipamentos eletrônicos. Sendo uma plataforma aberta (aberta), está se tornando popular e cresceu nos últimos anos. A Figura 1 mostra o quadro ou placa de desenvolvimento do Arduino Uno.

   Neste artigo, vamos começar no mundo dos microcontroladores de forma fácil. Para escrever o código, é necessário ter instalado o IDE de desenvolvimento Arduino (veja a Figura 2), que pode ser baixado da página da web Arduino. Para começar, usaremos os programas de exemplo que o próprio IDE de desenvolvimento da Arduino tem nos arquivos de menu-> Exemplos. Veja a Figura 3.

 

Figura 1. Placa de desenvolvimento Arduino Uno
Figura 1. Placa de desenvolvimento Arduino Uno

 

 

Figura 2. Ambiente de desenvolvimento Arduino Uno
Figura 2. Ambiente de desenvolvimento Arduino Uno

 

 

Figura 3. Menu de exemplos do Arduino Uno
Figura 3. Menu de exemplos do Arduino Uno

 

   Nas práticas a seguir, usaremos componentes eletrônicos, como LEDs e botões de pressão (veja a Figura 4). Esses componentes serão conectados aos pinos de entrada e saída do cartão de desenvolvimento. Na Figura 5, podemos ver a localização dos pinos de entrada e saída do cartão de desenvolvimento. No total, existem 14 pinos que estão numerados de '0' a '13'. Todos operam a 5 Volts. Cada pino pode fornecer ou receber um máximo de 40 miliampères e ter um resistor de pull-up interno (desconectado por padrão) de 20-50 kohms.

 

Figura 4. Componentes eletrônicos
Figura 4. Componentes eletrônicos

 

 

Figura 5. Entradas e saídas digitais Arduino Uno
Figura 5. Entradas e saídas digitais Arduino Uno

 

   

Para configurar se um pino é de saída ou entrada, usaremos a função pinMode, que recebe 2 parâmetros. O primeiro é o número do pino (de 0 a 13) eo segundo parâmetro se ele deve ser saída ou entrada. Se ele for lançado, no segundo parâmetro, escreveremos OUTPUT e se ele for inserido no segundo parâmetro, escreveremos INPUT. Para escrever um nível alto ou baixo em um pino configurado como saída, usaremos a função digitalWrite e leremos o valor de um pino, configurado como uma entrada, usaremos a função digitalRead.

 

LIGAR E DESLIGAR (ON / OFF) UM LED.

Vá para o Menu Arquivo-> Exemplos-> 01.Basics-> Blink. O código a seguir aparecerá no IDE:

// a função de configuração é executada uma vez que você pressiona a tecla de reinicialização ou liga a placa
void setup() {
  // inicializa o pino digital LED_BUILTIN como saída.
  pinMode(LED_BUILTIN, OUTPUT);
}
// a função de loop funciona uma e outra vez para sempre
void loop() {
  digitalWrite(LED_BUILTIN, HIGH); // liga o LED (ALTO é o nível de tensão)
  delay(1000); // aguarde um segundo
  digitalWrite(LED_BUILTIN, LOW); // desligue o LED fazendo a tensão BAIXO
  delay(1000); // aguarde um segundo
}

 

Neste exemplo, ligamos e desligamos um LED. A placa Arduino Uno possui um LED (incorporado) conectado ao pino digital 13 que, por padrão, é chamado de LED_BUILTIN. Se você quiser conectar LEDs a outros pinos, você pode seguir o diagrama elétrico da Figura 6. Você deve declarar uma constante como:

conts int LED_APP 12

para o caso de o LED estar conectado ao pino 12. Eu mudei este número de acordo com o pino onde o LED na placa Arduino Uno está conectado.

 

Figura 6. Ligar LED à placa Arduino Uno
Figura 6. Ligar LED à placa Arduino Uno

 

   

Todos os caracteres encontrados após '//' são comentários e servem para indicar e lembrar-nos que eles fazem certas seções ou partes de código. No código anterior, existem duas funções:

setup ()

loop ()

A função setup() é onde o microcontrolador está configurado e só é executado uma vez, quando a placa é alimentada por uma fonte de tensão ou quando executamos uma reinicialização. Esta função é muito semelhante ao BIOS (Basic Input Output Setup) de computadores pessoais. Nesta função, nós programamos as entradas e saídas do microcontrolador.

 

Figura 7. Fluxograma para programas Arduino
Figura 7. Fluxograma para programas Arduino

 

   A função loop(), como o nome indica, é um loop que se repete indefinidamente e é onde o programa principal está escrito. A Figura 7 mostra o diagrama de fluxo para as funções de setup() e loop(). Podemos ver que a função setup() é executada no início e a função de loop se repete indefinidamente.

   A função de configuração é:

void setup () {

  pinMode (LED_BUILTIN, OUTPUT);

}

   Dentro da função setup (), a função pinMode é chamada (LED_BUILTIN, OUTPUT); Esta função informa o microcontrolador de que o LED será configurado como saída.

Void loop () {

  digitalWrite (LED_BUILTIN, HIGH);

  delay (1000);

  digitalWrite (LED_BUILTIN, LOW);

  delay (1000);

}

   Dentro da função loop(), é chamada de função digitalWrite(LED_BUILTIN, HIGH); Esta função escreve um "1" lógico ou um nível alto no pino LED. Na eletrônica digital, os níveis elevados são representados por uma tensão de 5V. A função loop() também chama a função de delay(1000); que atrasa a operação do microcontrolador pela quantidade de milissegundos especificada nos parênteses da função.

Para o caso do exemplo anterior, estamos atrasando o microcontrolador em 1000 milissegundos ou 1 segundo. Em seguida, usamos a função digitalWrite(LED_BUILTIN, LOW); que coloca um "0" lógico ou nível sob o pino LED. Na eletrônica digital, um nível baixo é representado por 0 volts ou terra (GROUND). Então, temos um atraso de 1 segundo.

   Assim, o programa se repete continuamente e podemos observar como o LED liga e desliga continuamente. Se os valores dos parâmetros da função delay() forem alterados; Você pode ver a mudança de cintilação no LED. Este programa, embora básico, é importante compreendê-lo bem, porque todos os programas seguem a mesma regra, por mais complexos que sejam. A Figura 8 mostra o fluxograma do exemplo anterior.

 

Figura 8. Diagrama de fluxo para ligar e desligar o LED
Figura 8. Diagrama de fluxo para ligar e desligar o LED

 

CONECTANDO UM BOTÃO PUSH (PUSHBUTTON) PARA O MICROCONTROLADOR.

   Nesta prática, conectaremos um botão a um pino do microcontrolador configurado como uma entrada digital. O código de exemplo pode ser encontrado no IDE, no Menu: Arquivo-> Exemplo-> 02.Digital-> Botão.

// constants won't change. They're used here to set pin numbers:
const int buttonPin = 2; // the number of the pushbutton pin
const int ledPin = 13; // the number of the LED pin
 
// variables will change:
int buttonState = 0; // variable for reading the pushbutton status
 
void setup() {
// initialize the LED pin as an output:
pinMode(ledPin, OUTPUT);
// initialize the pushbutton pin as an input:
   pinMode(buttonPin, INPUT);
}
 
void loop() {
// read the state of the pushbutton value:
   buttonState = digitalRead(buttonPin);
 
// check if the pushbutton is pressed. If it is, the buttonState is HIGH:
if (buttonState == HIGH) {
// turn LED on:
   digitalWrite(ledPin, HIGH);
} else {
// turn LED off:
   digitalWrite(ledPin, LOW);
}
}

 

   No início do programa, definimos 2 constantes inteiras, isto é, dizer que esses valores não serão alterados durante a execução do programa. Para isso, a palavra const é usada, conforme mostrado nas seguintes linhas de código:

const int buttonPin = 2;

const int ledPin = 13;

   Na função setup(), configuramos o pino 13 como saída digital e pino 2 como entrada digital, conforme visto no código:

void setup() {

  pinMode(ledPin, OUTPUT);

  pinMode(buttonPin, INPUT);

}

A função pinMode(ledPin, OUTPUT); informa ao microcontrolador que o pino ledPin (13) será configurado como uma saída (OUTPUT) e a função pinMode (buttonPin, INPUT); diz ao microcontrolador que o pino buttonPin(pino 2) será configurado como uma entrada digital (INPUT). O hardware para este exemplo é mostrado na Figura 9, onde podemos ver que o botão passa no pino 2. É necessário conectar um resistor de 10 kOhms a 5 volts (pull-up), para polarizar a entrada para positivo, quando o O botão não está pressionado.

 

Figura 9. Conectando um botão para a placa Arduino Uno
Figura 9. Conectando um botão para a placa Arduino Uno

 

   Também declaramos um botão de valor variável, o que significa que seu valor ou conteúdo será modificado pelo programa. A seguinte linha de código mostra e declara a variável para o compilador:

int buttonState = 0;

   O código para a função loop() neste exemplo é:

void loop() {

  buttonState = digitalRead (buttonPin);

  se (buttonState == HIGH) {

        digitalWrite (ledPin, HIGH);

  } else {

         digitalWrite (ledPin, LOW);

  }

}

   Na função loop(), usamos a função digitalRead(buttonPin); para ler o botão do botão de entrada digitalPin e armazenar esse valor na variável buttonState. Então, o código verifica se esse valor é alto (ALTO) para o qual usamos a instrução if (buttonState == HIGH). Se o valor for alto, executaremos a função digitalWrite(ledPin, HIGH); ou o botão buttonState é baixo, a função digitalWrite será executada (ledPin, LOW); Assim, ao ler uma entrada digital, podemos controlar as saídas (atuadores) ou executar algum outro código. A Figura 10 mostra o fluxograma para ler o botão.

 

Figura 10. Diagrama de fluxo para ler um botão (mantido em espanhol conforme original do autor)
Figura 10. Diagrama de fluxo para ler um botão (mantido em espanhol conforme original do autor)

 

 

 ** PWM PARA AUMENTAR E BAIXAR A INTENSIDADE LUMINOSA DE UM LED.

   Os pinos 3, 5, 6, 9, 10 e 11 da placa Arduino Uno podem ser usados como saídas analógicas PWM. No total, existem 6 pinos com PWM na placa Arduino Uno. A Figura 11 mostra esses pinos. Observe que, no painel, essas saídas são marcadas com o símbolo ~ antes do número, indicando as saídas PWM. O microcontrolador ATmega328P utilizado na placa Arduino possui 3 temporizadores. Cada temporizador possui 2 módulos de comparação de saída que normalmente são usados para gerar sinais PWM. Na Figura 12 podemos ver o Temporizador 0 do microcontrolador.

 

Figura 11. Saídas PWM na placa Arduino Uno
Figura 11. Saídas PWM na placa Arduino Uno

 

 

Figura 12. Ciclo ativo (ciclo de trabalho) para saídas PWM
Figura 12. Ciclo ativo (ciclo de trabalho) para saídas PWM

 

   O código de exemplo para esta prática pode ser encontrado em Arquivo-> Exemplos-> 01.Basics-> Fade. A principal idéia é aumentar e diminuir a intensidade luminosa do LED usando o PWM (Modulador de largura de pulso). O código neste exemplo é:

int led = 9; // the PWM pin the LED is attached to
int brightness = 0; // how bright the LED is
int fadeAmount = 5; // how many points to fade the LED by
 
// the setup routine runs once when you press reset:
void setup() {
// declare pin 9 to be an output:
   pinMode(led, OUTPUT);
}
 
// the loop routine runs over and over again forever:
void loop() {
// set the brightness of pin 9:
   analogWrite(led, brightness);
 
// change the brightness for next time through the loop:
   brightness = brightness + fadeAmount;
 
// reverse the direction of the fading at the ends of the fade:
   if(brightness <= 0 || brightness >= 255) {
   fadeAmount = -fadeAmount;
}
// wait for 30 milliseconds to see the dimming effect
   delay(30);
}

   

PWM é uma técnica de modulação de largura de pulso que pode ser usada para controlar a corrente que flui através de um circuito muito similar aos potenciômetros em um dimmer. Para fazer isso, podemos usar a função analogWrite que recebe 2 parâmetros. O primeiro parâmetro é o pino a ser controlado eo segundo parâmetro é a quantidade de tempo que o pino permanecerá no nível alto (ON). A Figura 13 mostra como o segundo parâmetro atua no pino que está controlando. À medida que os pulsos são repetidos rapidamente (aproximadamente 500 Hz), o olho humano não percebe sua mudança, mas à medida que a largura do pulso varia, dá a sensação óptica de aumentar e diminuir a intensidade do LED. O hardware necessário para esta prática pode ser visto na Figura 14. Observe que o LED está conectado ao pino 9.

 

Figura 13. Diagrama de bloco do contador de temporizador 0
Figura 13. Diagrama de bloco do contador de temporizador 0

 

 

Figura 14. Ligar o LED à saída PWM da placa Arduino Uno
Figura 14. Ligar o LED à saída PWM da placa Arduino Uno

 

   

No início do programa, declaramos 3 variáveis da seguinte forma:

int led = 9;

int brightness = 0;

int fadeAmount = 5;

   A variável led é o pino em que vamos conectar o LED. A variável de brilho armazena o valor do brilho do LED e a variável fadeAmount é usada para alterar o brilho.

   Na função setup(), configuramos o pino LED como uma saída para a qual temos o seguinte código:

void setup() {

  pinMode(led, OUTPUT);

}

 

 Figura 15. Diagrama de fluxo para saída PWM (em espanhol como no original do autor)
 Figura 15. Diagrama de fluxo para saída PWM (em espanhol como no original do autor)

 

   No loop de função () usamos a função analogWrite(led, brilho); para colocar um valor de largura de pulso na saída PWM. Em seguida, adicionamos um fadeAmount ao brilho variável para aumentar seu valor em forma escalar. Então, detectamos se o brilho variável é maior ou igual a 255 e inverte a variável fadeAmount para reverter o efeito do brilho. Finalmente, damos um desafio de 30 milissegundos. Na Figura 15, podemos ver o fluxograma dessa prática. O código para a função loop () é o seguinte:

void loop() {
   analogWrite(led, brightness);
   brightness = brightness + fadeAmount;
   if (brightness <= 0 || brightness >= 255) {
    fadeAmount = -fadeAmount;
   }
   delay(30);
}

 

   Assim, por meio de linhas de código, podemos interagir com o mundo exterior, ou seja, podemos ler sinais (entradas, sensores) e podemos avaliar esses valores para tomar decisões sobre saídas, normalmente chamadas de atuadores. A imaginação é o indicador de que você pode usar esses recursos para criar projetos e equipamentos eletrônicos.