Tá na hora de piscar LEDs de maneira melhorada

Ficar piscando LEDs não é a coisa mais maneira que dá pra fazer com o Arduino ou com o Raspberry Pi. Acontece que só tenho LEDs por enquanto (e queimei meus três LEDs RGB pra melhorar ainda mais a situação), então é o que dá pra fazer.

Na verdade tem aqui uns leitores de térmicos, buzzer, push buttons... mas não tenho resistores suficientes para travar a tensão aonde quero, então, para não queimar mais componentes, vamos de LED mesmo.

É imprescindível entender que o objetivo principal de programar um microcontrolador é PROGRAMAR um microcontrolador. Sim, redundante. Não é só de conexões que vivem um projeto. Por isso, e começando a aprender um pouco mais da linguagem usada para programar o Arduino, decidi fazer um projeto novo.

Problema: fazer 3 LEDs, de cores diferentes, piscarem aleatoriamente.

Vou precisar de:
- Arduino;
- Cabo USB para transferência do sofware;
- 3 LEDs de 3 cores diferentes;
- 3 resistores;
- Fios;

Um programa típico

Aparentemente programamos em C quando escrevemos para Arduino. A estrutura básica de qualquer software é essa daqui:

void setup() {}; //Inicializa o sistema, criando associações, alterando configurações, etc.
void loop() {}; //Executa o software num loop infinito.

Se é C, então rola criar funções. Se for C++ ou C#, então rola criar classes também. Isso é da hora. Sempre é bom aprender uma linguagem com um código que faz algo útil, então...

Entendendo o problema e criando o código

Serão 3 LEDs. Cada LED usará uma porta digital do Arduino e essa porta sempre será a mesma (não vamos ficar trocando de porta a todo momento). Nesse caso podemos dizer que as portas serão constantes.

Nesse sentido, podemos determinar constantes com os valores dos pinos que vamos usar. Posso usar qualquer pino digital aqui, então escolho o 8, o 9 e o 10.

const int vermelho = 10;
const int verde = 9;
const int amarelo = 8;

No código, quando eu quiser acessar um LED qualquer, ao invés de chamar o pino, chamo o nome da cor. Se no futuro eu mudar o pino de uma determinada cor, basta alterar aqui.

Ainda falta uma coisa. Será que dá pra criar uma espécie de tabela ou coleção que conterá todos os LEDs que vamos usar? Sim, com certeza. Em qualquer linguagem de programação (pelo menos as que conheço) encontramos uma estrutura que pode organizar valores em uma coleção. Normalmente damos o nome de array. Em C, um array é definido por:

int nome[] = {item1, item2, ...}

Onde:
- int: é o tipo de dado de cada elemento. Significa "inteiro".
- nome: é o nome do array. Entre colchetes você pode definir o tamanho dele.
- = {item1, item2, ...}: os itens que compõem o array.

Então se fizermos...

int leds[] = {vermelho, verde, amarelo};

Criamos uma coleção com todos os LEDs disponíveis. Agora, querendo chamar um LED, é só dizer:

leds[0]; //Chama o LED vermelho
leds[1]; //Chama o LED verde
leds[2]; //Chama o LED amarelo

Mas podemos chamar o LED pela sua cor também. Criar uma coleção ajuda na hora de realizar uma chamada aleatória, que é exatamente o que vamos fazer daqui a pouco. Vai ajudar também na hora de configurar os pinos.

LEDs associados, coleção criada, agora falta configurar os pinos:

void setup() {
 for(int x = 0; x < 3; x++) {
  pinMode(leds[x], OUTPUT);
 }
}

Note que...
- pinMode(pino, modo): configura o pino para o determinado modo. Existem outros além do OUTPUT, mas vou ficar nele por hora.

Perceba que, já que temos uma coleção com os LEDs, fica mais fácil, ao invés de repetir vários pinMode(), realizar um loop e percorrer a coleção.

Como eu desconfio que estamos trabalhando com uma linguagem, no mínimo, like-C, então podemos criar funções também. Isso é útil pra várias coisas e, pro código aqui, uma função pode controlar o "pisca-pisca" do LED. Então vejamos...

void blink(int led, int msec) {
 digitalWrite(led, HIGH);
 delay(msec);
 digitalWrite(led, LOW);
}

Essa função recebe o LED e o número de milissegundos que ele ficará acesso. Note que:
- digitalWrite(pino, sinal): envia o sinal ao pino específico;
- delay(milissegundos): pausa o programa por um determinado tempo;

Quase tudo pronto. Fica faltando agora só o código da função loop():

void loop() {
 blink(leds[random(3)], random(150, 301));
}

Claro, a coisa nova aqui é...
- random(a[, b]): essa função gera um número aleatório entre 0 e "a - 1". Se "b" for informado, então recupera esse número entre "a" e "b". No primeiro random, pegamos aleatoriamente 0, 1 ou 2. No segundo, um número qualquer entre 150 e 300.

O código todo ficou assim:

E tem o circuito também

O circuito não muda em relação aos outros que fazem um LED acender ou piscar. Use resistores para limitar a tensão sobre os LEDs (usei de 300ohms, mas 270 ou 330 também servem). As pernas GND estão todas ligadas ao mesmo terra e as pernas positivas ligadas aos resistores que, por sua vez, estão ligados aos pinos 10, 9 e 8 do Arduino.

Envie o código para o seu Arduino e veja o efeito: