6 Leds Piscando em Sequência

A importância das arrays na programação do Arduino é muito grande, basicamente, por ser um tipo de variável especial. As variáveis comuns armazenam um dado por vez na memória. Vejamos, então como funciona esse conceito.

Se, por exemplo, x é a variável que armazena a temperatura de um corpo, cada leitura da temperatura desse corpo gerará um dado a ser armazenado na memória. Da mesma forma, se g1 é a variável que armazena a rotação de um motor, cada leitura da rotação desse motor gerará um dado a ser armazenado na memória. Entretanto, nem tudo pode ser medido ou representado dessa maneira. Há situações em que apenas um dado não é suficiente para identificar um determinado evento que se deseja armazenar ou tratar no Arduino. Se agora, por outro lado, é necessário indicar a posição no espaço de um corpo – chamada de Pos apenas para efeito do nosso exemplo – será necessário usar três dimensões (x, y e z). Para fazer isso, poderíamos criar três variáveis para tratar cada uma das dimensões, mas isso certamente seria mais trabalhoso e bem menos eficiente. Nesse exemplo, usar o conceito de array é a melhor alternativa. A array para esse caso poderia ser declarada da seguinte forma: int Pos [3]. Essa array foi declarada com três elementos, sendo um elemento para cada dimensão espacial, com números inteiros, sem valor inicial.

Tenha sempre em mente que as arrays são coleções de variáveis de mesmo tipo, referenciadas por um nome comum. Para acessar um elemento específico em uma array são utilizados índices. Os elementos de uma array são armazenados de forma sequencial na memória.

Note também que uma Array tem notação própria para ser declarada que usa [ ] e não ( ), ou seja, não usa parênteses.

Para mais informações sobre arrays acesse >

https://www.arduino.cc/reference/pt/language/variables/data-types/array/

O projeto que vamos apresentar nesse artigo tem por objetivo fazer seis Leds piscarem em sequência, usando o conceito de array na construção do sketch.

Os Leds deverão piscar, um por vez e durante um certo tempo, conforme a sequência definida por seus pinos de ligação no Arduino. Isso se repetirá indefinidamente, enquanto o Arduino estiver ligado.

Os componentes usados nesse projeto são os seguintes:

1 Arduino Uno
2 Led de 5 mm, difuso, vermelho
2 Led de 5 mm, difuso, verde
2 Led de 5 mm, difuso, amarelo
6 Resistor de 330 Ohm, 1/4 Watt, 5%
1 Protoboard

Os pinos digitais 2, 3, 4, 5, 6 e 7 são saídas, onde cada pino é ligado a um Led. Entretanto, a ordem da sequência de ligar e desligar cada Led escolhida para esse projeto será 2, 7, 4, 6, 5 e 3. Para que isso ocorra, será usada uma array no sketch do Arduino.

Cada Led será ligado em série a um resistor de 330 ohm para limitar a corrente no mesmo.

Figura 1: 6 Leds conectados aos pinos digitais do Arduino

A seguir, apresentamos o sketch do projeto dos seis Leds piscando em sequência. Acompanhe seu funcionamento seguindo os comentários na parte final desse artigo.

Carregue o sketch e veja como tudo funciona!

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

// 6 Leds piscando em sequencia
// Usando o conceito de Array
// Declaracao da variavel inteira "espera" ...
// ... para ajuste do tempo de espera
int espera = 100;  

// Declarando a matriz Pinos{} com 6 elementos
// Os elementos sao os pinos do Arduino ligados aos Leds
int Pinos[] = {2, 7, 4, 6, 5, 3}; 

// Declarando a variável ContaPino com a ...
// ... quantidade de pinos usados (contador)
int ContaPino = 6; 

void setup() {
  // Os elementos da matriz sao numerados de 0 até (ContaPino -1) 
  // Usando um for() para definir cada pino digital ...
  // ... do Arduino como uma saída (OUTPUT)
  // PinoArdu é uma variavel inteira e local ...
  // ... para atribuir os numeros de pinos usados no Arduino
  // PinoArdu=0 --> Pinos[0] é 2 --> OUTPUT
  // PinoArdu=1 --> Pinos[1] = 7 --> OUTPUT
  // PinoArdu=2 --> Pinos[2] = 4 --> OUTPUT
  // PinoArdu=3 --> Pinos[3] = 6 --> OUTPUT
  // PinoArdu=4 --> Pinos[4] = 5 --> OUTPUT
  // PinoArdu=5 --> Pinos[5] = 3 --> OUTPUT
  
  for (int PinoArdu = 0; PinoArdu < ContaPino; PinoArdu++) {
    pinMode(Pinos[PinoArdu], OUTPUT);
  }
}

void loop() {
  // Pisca Leds na ordem crescente
  for (int PinoArdu = 0; PinoArdu < ContaPino; PinoArdu++) {
    // liga Led 
    digitalWrite(Pinos[PinoArdu], HIGH);
    delay(espera);
    // desliga Led
    digitalWrite(Pinos[PinoArdu], LOW);

  }

  // Pisca Leds em ordem descrescente
  for (int PinoArdu = ContaPino - 1; PinoArdu >= 0; PinoArdu--) {
    // liga Led
    digitalWrite(Pinos[PinoArdu], HIGH);
    delay(espera);
    // desliga Led
    digitalWrite(Pinos[PinoArdu], LOW);
  }
}

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

Observações sobre o Código!

O sketch usa a variável inteira “espera” para ajuste do tempo que os Leds irão acender e apagar.

Por sua vez, os Leds estão ligados aos pinos digitais 2, 3, 4, 5, 6 e 7 do Arduino. Aqui é dito onde os pinos serão ligados, mas não a ordem em que serão ligados e desligados.

Na instrução int Pinos[] = {2, 7, 4, 6, 5, 3} …

Pinos[] é uma array de 6 elementos, com os números do pinos digitais do Arduino, na ordem em que serão ligados e desligados.

A instrução que declara a variável ContaPino, que contém a quantidade de pinos usados, é int ContaPino = 6;

A função void setup() usa a variável pinoArdu (pino do Arduino) dentro da função for(). PinoArdu varia de PinoArdu=0 até PinoArdu<ContaPino, ou seja, de zero à 5, estabelecendo – via pinMode() – que todos os pinos digitais indicados na array Pinos[] são saídas.

for (int PinoArdu = 0; PinoArdu < ContaPino; PinoArdu++) {

pinMode(Pinos[PinoArdu], OUTPUT);

}

Por sua vez, a função void loop() é dividida em duas partes, sendo a primeira responsável por piscar os Leds em ordem crescente e segunda por picar os Leds em ordem decrescente.

O uso da array Pinos[] torna o sketch mais compacto. Para fazer os Leds piscarem em ordem crescente uma função for() é usada da seguinte maneira:

for (int PinoArdu = 0; PinoArdu < ContaPino; PinoArdu++) {

…
}

A variável PinoArdu varia de 0 até 5, funcionando como o índice da array Pino[], sendo incrementada de 1 (PinoArdu++) em cada rodada do for(). PinoArdu=0 corresponde ao pino digital 2. PinoArdu=1 corresponde ao pino digital 7. PinoArdu=2 corresponde ao pino digital 4. PinoArdu=3 corresponde ao pino digital 6. PinoArdu=4 corresponde ao pino digital 5. E finalmente, PinoArdu=5 corresponde ao pino digital 3.

A cada rodada da função for() a instrução …

digitalWrite(Pinos[PinoArdu], HIGH);

… faz com que o Led definido no índice PinoArdu seja colocado em nível lógico alto (+ 5 V). Com isso o Led é aceso, permanecendo aceso pelo tempo definido pela variável “espera”.

delay(espera);

No caso do sketch esse tempo é igual a 100 milisegundos. Em seguida, o Led é desligado através da instrução …

digitalWrite(Pinos[PinoArdu], LOW);

Para fazer os Leds piscarem em ordem decrescente uma função for() é usada da seguinte maneira:

for (int PinoArdu = ContaPino – 1; PinoArdu >= 0; PinoArdu–) {

…

}

Note que a variável PinoArdu varia de (ContaPino -1) até 0, sendo decrementada de 1 (pinoArdu–) em cada rodada do for(). Em outras palavras, a variável pinoArdu, que é o índice da array Pinos[], varia de 5 até 0. O restante do sketch faz o Led apontado na array Pinos[] acender e apagar de forma idêntica a apresentada anteriormente.

Se você ficou com alguma dúvida sobre esse artigo, nos envie suas perguntas. Continue nos seguindo no blog. Bem, é isso aí. Até a próxima.