Mais que uma placa com um microcontrolador, o Arduino é uma plataforma aberta, fácil de usar do ponto de vista do hardware e do software. Existem diferentes tipos e versões de placas do Arduino e na figura 1 estão apresentadas, como exemplo, três desses tipos.

Figura 1: Arduino Uno, Arduino Mega2560 e Arduino Pro Mini.

O Uno é uma placa de propósito geral e certamente a mais encontrada nos livros, artigos e videos disponibilizados na Internet. O Mega2560 é o Arduino utlizado em projetos que necessitam de maior capacidade. Por sua vez, o Pro Mini é um microcontrolador típico para projetos que necessitam miniaturização. Em complemento, a tabela 1 compara as quantidades de pinos digitais e analógicos dessas três de placas de Arduino.

Tabela 1: Quantidade de pinos digitais e analógicos para as placas de Arduino Uno, Mega2560 e Pro Mini.

Uma rápida pesquisa na Internet mostrará detalhes sobre cada tipo de placa, sendo essa variedade de opções uma consequencia da enorme popularidade do Arduino, alcançando milhões de usuários, e a facilidade de copiar e modificar a placa original uma vez que a tecnologia é aberta em hardware e software. Só não é permitido copiar e não informar para quem compra que se trata de uma cópia. Esse tipo de expediente contraría os termos que regulam os direitos autorais. Mas, nesse momento, vamos deixar esse aspecto para outra ocasião e destacar que será possível encontrar um modelo com dimensões e capacidade adequados ao projeto que se deseja desenvolver.

Existem também os módulos e shields (módulos construídos para montagem sobre o Arduino) usados nos projetos e que podem ser facilmente encontrados no mercado, como os ilustrados na figura 2.

Figura 2: Exemplos de módulos, shields e componentes usados em projetos com o Arduino.

E não menos importantes são os protoboards, que simplificam a montagem de protótipos, os cabos jumpers, as baterias, os displays, os motores DC, os servomotores, os motores de passo e vários componentes eletrônicos que iremos utilizar nos projetos de nossos artigos.

Há muito material disponível na Internet sobre projetos com o Arduino e isso tem aspectos positivos e, também, negativos.  Tenho notado que muitos daqueles que usam o Arduino parecem que se dão por satisfeitos em descobrir apenas como foi feita a montagem física dos circuitos eletrônicos, focalizando na informação sobre que pinos do Arduino foram ligados a que componentes externos (Leds, chaves, resistores, sensores, pinos de módulos, pinos de shields, etc), e copiam o sketch que faz o projeto funcionar, sem realmente buscar compreendê-lo. Alguns fazem isso por dificuldade em entender o código e sua lógica e outros, infelizmente, agem dessa forma por preguiça.

Me lembro de uma dúvida básica de alguns de meus alunos iniciantes sobre a “inteligência” do Arduino.  A pergunta a mim apresentada costumava ser a seguinte: “– Porque, se eu ligar num pino errado, não funciona? Mas o sketch já não está dizendo para o Arduino onde tudo está ligado? Bem, meus caros, vocês têm que ligar os pinos e programar para que o código represente o que está montado. Ou, por outro caminho, vocês têm que montar o que está descrito no código. Se o sketch diz, por exemplo, que o pino digital 2 é o do Led, isso tem que estar feito na montagem. Em outras palavras, como numa via de mão dupla, a montagem dos componentes eletrônicos com o Arduino precisa ser compatível com o sketch.

Isso nos leva a concluir que para trabalhar bem com o Arduino é importante, além de fazer a montagem correta dos componentes, aprender a programá-lo. Você deve compreender, pelo menos, um pouco da lógica de programação que permite ao usuário desfrutar do vasto grupo de funções e das famosas bibliotecas.  E, evidentemente, você deve saber como explorar as facilidades do IDE (Integrated Development Environment).

Por exemplo, no menu do IDE o símbolo    é usado para compilar um skecth e verificar erros de sintaxe.

Por sua vez, o símbolo     é usado para carregar no Arduino um sketch criado no IDE. Há muito mais sobre o IDE que veremos no decorrer de nossos artigos.

Apesar do projeto que vamos apresentar ter um grau baixo de complexidade, carrega a vantagem de ser um bom ponto de partida para os iniciantes e todos aqueles que desejam aprender a programar o Arduino. Utiliza componentes facilmente encontrados e de baixíssimo custo, além de ser útil para testar praticamente todas as placas de Arduino.

A lista de componentes do projeto inclui: 1 Arduino Uno, 1 Led verde, 1 módulo buzzer (modelo GBK Robotics P15), 1 tact switch, 1 resistor de 330 ohms (5%, 1/4W), 1 resistor de 1K ohm (5%, 1/4W), 1 protoboard com 830 furos e alguns cabos jumpers macho-macho. Note que o modulo GBK Robotics P15 contém 1 buzzer piezoelétrico, 1 Led verde e 1 resistor de 100 Ohms.

Figura 3: Projeto Push Button–Led–Buzzer com Arduino Uno

No desenho de montagem do projeto no protoboard, o módulo buzzer é apresentado com seus componentes separados e está ilustrada na figura 4.

Figura 4: Montagem do Projeto Push Button-Led-Buzzer no Protoboard

Isso significa que todas as ligações devem ser completadas seguindo as indicações dessa figura. Note que o pino digital 13 do Arduino está ligado ao anodo do Led. O catodo do Led é conectado a um dos terminais do resistor de 330 ohms, sendo que o outro terminal desse resistor é ligado à terra (GND do Arduino). Por sua vez, o pino digital 2 do Arduino está ligado a um dos terminais do botão push button e também a um dos terminais do resistor de 1K ohm. O outro terminal do botão push button é conectado ao GND do Arduino, assim como o outro terminal do resistor de 1K ohm é ligado ao Vcc do Arduino (+5 Volts). Ainda temos o pino digital 9 do Arduino ligado a entrada de sinal do módulo buzzer e, completando a montagem, o terminal GND do módulo buzzer é ligado ao GND do Arduino. Vale notar que o projeto usa a fonte de +5 Volts da placa do Arduino Uno.

Essa montagem simula situações presentes em vários projetos de automação e robótica como, por exemplo, quando é necessário executar uma ação de controle de ligar ou desligar um dispositivo ao se pressionar um botão. Ainda dentro dessa ideia, e para tornar esse projeto mais interessante, foram elaborados dois sketches que farão o hardware trabalhar de duas formas diferentes. Isso nos auxiliará a apresentar alguns elementos de lógica de programação e funções básicas.

Cenário A – Enquanto o push button estiver pressionado o Arduino acende o Led e faz o buzzer tocar por 3 vezes.  Quando se solta o push button o Led é apagado e o buzzer permanece em silêncio. O sketch que faz isso é disponibilizado abaixo.

***************************************

// Aperta push button para ligar e tocar buzzer 
// Solta push button para desligar
// Push button aciona Led e buzzer
const int LED = 13; // LED é o pino 13
const int PB = 2; // PB é o pino 2
const int Buzzer = 9; // Buzzer é o pino 9
void setup() {
  // Definir modo dos pinos
  pinMode (Buzzer, OUTPUT); // Buzzer é saída
  pinMode (LED, OUTPUT); // LED é saída
  pinMode (PB, INPUT); // PB é entrada
}
void loop() {
  // Aperta o push button liga o Led e toca o buzzer
  int valor = digitalRead (PB); // Le valor em PB
  if (valor == LOW) { 
    digitalWrite (LED, HIGH); // Liga Led
    TocaBuzzer();
 }
    else  {
    digitalWrite (LED, LOW); // Desliga Led
  }
}
void TocaBuzzer() {
for (int i = 0; i<3; i++) {
  int freq = 349; // frequencia é a nota FA
  tone (Buzzer, freq); 
  delay (200);
  noTone (Buzzer);
  }
}

***************************************

O sketch do cenário A tem como núcleo de sua rotina, na parte do loop(), a leitura da pino digital 2 (PB ou push button), através da instrução int valor = digitalRead (PB) e, em seguida, perguntando se o valor lido (armazenado na variável inteira valor) é igual ao nível lógico zero, através de if (valor == LOW) . Se essa condição é verdadeira, significa que o push button foi acionado, levando o valor para zero volt, e as instruções digitalWrite (LED, HIGH), que acende o Led, e TocaBuzzer(), que faz o buzzer tocar, são executadas.

A propósito, TocaBuzzer() é uma função que faz o buzzer tocar por 3 vezes, criada especificamente para esse sketch, sendo chamada dentro do loop() e descrita após o loop(), na parte final do sketch.

Cenário B – O sketch do cenário B traz uma pequena melhoria e funciona como uma chave “toggle”. Quando se pressiona e solta o push button, o sketch faz o Led acender e o buzzer tocar por 3 vezes e, então, o buzzer para de tocar, mantendo, entretanto, o Led aceso.  Quando se pressiona o push button novamente e se solta, o Led é apagado e o buzzer permanece em silêncio. Se o push button é novamente pressionado e solto, o Led acende e o buzzer toca por 3 vezes e, então, fica em silêncio, mantendo o Led aceso. E então, quando se pressiona o push button novamente e se solta, o Led é apagado e o buzzer permanece em silêncio. O sketch que faz isso é disponibilizado abaixo.

***************************************

// Push button como chave Toggle
const int PB = 2;// Push button PB no pino digital 2
const int LED = 13; // LED no pino digital 13
const int Buzzer = 9; // Buzzer é o pino 9

int AGORA; // AGORA variavel do estado do push button agora
int ANTES; // ANTES variavel do estado do push button antes
int XLED; // XLED variavel que acende e apaga o LED

void setup() {
  // LED => saida e PB => entrada
  pinMode (Buzzer, OUTPUT); // Buzzer é saída
  pinMode (LED, OUTPUT); // Led é saida
  pinMode (PB, INPUT); // Push Button é entrada
}
void loop() {

  AGORA = digitalRead (PB); // le PB e coloca em AGORA
  if (AGORA != ANTES) { // se AGORA eh diferente do ANTES executa proxima
    if (AGORA == HIGH){ // se o AGORA eh 1 executa proxima
      if (XLED == HIGH) XLED = LOW; // se XLED eh 1, muda para zero
      else XLED = HIGH; // se XLED eh 0, muda para 1
        if (XLED == HIGH){
        TocaBuzzer(); 
      }
    }
    ANTES = AGORA; // faz o ANTES igual ao AGORA
   }
  digitalWrite (LED, XLED); // escreve o estado de XLED no LED
  delay (200);
 }
    
 void TocaBuzzer() {
  for (int i = 0; i<3; i++) {
  int freq = 349; // frequencia é a nota FA
  tone (Buzzer, freq); 
  delay (300);
  noTone (Buzzer);
  }
}  

***************************************

O sketch do cenário B trabalha com duas variáveis inteiras para decidir se o Led deve ser aceso ou não, que são as seguintes:

int AGORA; // AGORA variavel do estado do push button agora
int ANTES; // ANTES variavel do estado do push button antes

Além disso é usada a variável inteira XLED, para acender e apagar o Led. Na parte do loop(), é feita a leitura da pino digital 2 (PB ou push button), através da instrução AGORA = digitalRead (PB). Em seguida, é executada um grupo de funções if().

Figura 5: Sequência de funções if() do sketch para chave “Toggle”.

Note que a condição das variáveis AGORA e ANTES serem diferentes dispara a tomada de decisão. Sempre que o push botton não estiver sendo pressionado essas duas variáveis são iguais. Da mesma forma, durante o tempo que o push button está sendo pressionado essas duas variáveis também são iguais. Somente quando existir uma transição como mostrado na figura 5, haverá uma ação definida na função if().

if (XLED == HIGH) XLED = LOW; // se XLED eh 1, muda para zero
else XLED = HIGH; // se XLED eh 0, muda para 1
if (XLED == HIGH){

Se XLED está em nível lógico alto (HIGH), o comando faz XLED igual a zero (LOW). No caso contrário, com XLED igual a LOW, o comando faz XLED igual a HIGH. Isso cria o efeito de chave “toggle”. Note que somente quando XLED é HIGH o buzzer é acionado para tocar. A variável XLED é usada para acender e apagar o Led através de digitalWrite (LED, XLED), que se encontra nas linhas seguintes do sketch. Como no sketch anterior, também no cenário B o acionamento do buzzer é feito através da função TocaBuzzer() criada especificamente para esse projeto.

Recomendo a leitura atenta dos sketchs (instruções e respectivos comentários) e, em caso de dúvida, nos enviem suas perguntas!

É isso aí, até a próxima.