Faça um knight rider led scanner com Arduino

Já desejou ter seu próprio carro das Indústrias Knight Two Thousand (KITT) - você sabe, de Knight Rider? Faça seu sonho um passo mais perto da realidade construindo um scanner led!

Já desejou ter seu próprio carro das Indústrias Knight Two Thousand (KITT) - você sabe, de Knight Rider? Faça seu sonho um passo mais perto da realidade construindo um scanner led! Aqui está o resultado final:

O que você precisa

Não há muitas peças necessárias para este projeto, e você pode ter muitas delas já:

1 x Arduino UNO ou similar
1 x prancha
8 x LEDs vermelhos
8 x 220 ohm resistores
1 x 10k ohm potencialiômetro
Macho para macho ligar fios

Se você tem um kit de partida Arduino é provável que você tenha todas essas peças (o que você pode fazer com um kit de partida?

Quase qualquer Arduino vai funcionar, desde que tenha oito pinos disponíveis (Nunca usei um Arduino antes? Comece aqui). Você poderia usar um Registro de Turno para controlar os LEDs, embora isso não seja necessário para este projeto, já que o Arduino tem pinos suficientes.

Plano de construção

Este é um projeto muito simples. Embora possa parecer complexo a partir do grande número de fios, cada parte individual é muito simples. Cada diodo emissor de luz (LED) está conectado ao seu próprio pino Arduino. Isso significa que cada LED pode ser ligado e desligado individualmente. Um potencialiômetro é conectado ao analógico Arduino em pinos, que será usado para ajustar a velocidade do scanner.

O Circuito

Conecte o pino esquerdo externo (olhando para a frente, com os pinos na parte inferior) do potencialiômetro ao solo. Conecte o pino externo oposto a +5v. Se não funcionar corretamente, inverta esses pinos. Conecte o pino médio ao analógico Arduino em 2.

Conecte o ânodo (perna longa) de cada LED aos pinos digitais de um a oito. Conecte os cátodos (perna curta) ao solo de Arduino.

O Código

Crie um novo esboço e salve-o como "cavaleirorider". Aqui está o código:

const int leds[] = {1,2,3,4,5,6,7,8}; // Led pins
const int totalLeds = 8;
int time = 50; // Default speed
void setup() {
    // Initialize all outputs
    for(int i = 0; i <= totalLeds; ++i) {
        pinMode(leds[i], OUTPUT);
    }
}
void loop() {
    for(int i = 0; i < totalLeds - 1; ++i) {
        // Scan left to right
        time = analogRead(2);
        digitalWrite(leds[i], HIGH);
        delay(time);
        digitalWrite(leds[i + 1], HIGH);
        delay(time);
        digitalWrite(leds[i], LOW);
    }
    for(int i = totalLeds; i > 0; --i) {
        // Scan right to left
        time = analogRead(2);
        digitalWrite(leds[i], HIGH);
        delay(time);
        digitalWrite(leds[i - 1], HIGH);
        delay(time);
        digitalWrite(leds[i], LOW);
    }
}

Vamos acabar com isso. Cada pino LED é armazenado em uma matriz:

const int leds[] = {1,2,3,4,5,6,7,8};

Uma matriz é essencialmente uma coleção de itens relacionados. Esses elementos são definidos como constantes ("const"), o que significa que não podem ser alterados mais tarde. Você não precisa usar uma constante (o código funcionará perfeitamente se você remover "const"), embora seja recomendado.

Os elementos de uma matriz são acessados usando suportes quadrados ("[])) e um inteiro chamado índice. Os índices começam em zero, de modo que "leds[2]" retornariam o terceiro elemento na matriz - pino 3. Os arrays tornam o código mais rápido de escrever e mais fácil de ler, eles fazem o computador fazer o trabalho duro!

Um loop para for é usado para configurar cada pino como uma saída:

for(int i = 0; i <= totalLeds; ++i) {
        pinMode(leds[i], OUTPUT);
}

Este código está dentro da função "setup()", pois só precisa ser executado uma vez no início do programa. Para loops são muito úteis. Eles permitem que você execute o mesmo código várias vezes, com um valor diferente a cada vez. Eles são perfeitos para trabalhar com matrizes. Um inteiro "i" é declarado, e somente um código dentro do loop pode acessar essa variável (isso é conhecido como "escopo"). O valor de i começa em zero, e para cada iteração do loop, eu sou aumentado por um. Uma vez que o valor de i é menor ou igual à variável "totalLeds", o loop "quebra" (pára).

O valor de i é usado para acessar a matriz "leds". Este loop acessa cada elemento do array e configura-o como uma saída. Você pode digitar manualmente "pinMode(pino, OUTPUT)" oito vezes, mas por que escrever oito linhas quando você pode escrever três?

Embora algumas linguagens de programação possam dizer quantos elementos estão em uma matriz (geralmente com sintaxe como array.length), Arduino não o torna tão simples (envolve um pouco mais de matemática). Como o número de elementos na matriz já é conhecido, não é um problema.

Dentro do laço principal(loop vazio)estão mais dois para loops. O primeiro define os LEDs ON e depois OFF de 1 a 8. O segundo loop define os LEDs ON e, em seguida, OFF de 8 -1. Observe como o pino atual está configurado, e o pino atual mais um também está configurado. Isso garante que haja sempre dois LEDS ligados ao mesmo tempo, fazendo com que o scanner pareça mais realista.

No início de cada loop, o valor do pote é lido na variável "tempo":

time = analogRead(2);

Isso é feito duas vezes, uma dentro de cada loop. Isso precisa ser constantemente verificado e atualizado. Se isso estivesse fora dos loops, ainda funcionaria, no entanto haveria um pequeno atraso - ele só seria executado uma vez que um loop terminou de executar. Os potes são analógicos, daí porque "analogRead(pino)" é usado. Isso retorna valores entre zero (mínimo) e 1023 (máximo). Arduino é capaz de converter esses valores em algo mais útil, porém eles são perfeitos para este caso de uso.

O atraso entre a troca de LEDs (ou a velocidade do scanner) é definido em milissegundos (1/1000 segundo), de modo que o tempo máximo é de pouco mais de 1 segundo.

Scanner Avançado

Agora que você sabe o básico, vamos olhar para algo mais complexo. Este scanner acenderá os LEDs em pares começando por fora e trabalhando dentro Em seguida, ele vai reverter isso e ir de dentro para fora pares. Aqui está o código:

const int leds[] = {1,2,3,4,5,6,7,8}; // Led pins
const int totalLeds = 8;
const int halfLeds = 4;
int time = 50; // Default speed
void setup() {
    // Initialize all outputs
    for(int i = 0; i <= totalLeds; ++i) {
        pinMode(leds[i], OUTPUT);
    }
}
void loop() {
    for(int i = 0; i < (halfLeds - 1); ++i) {
        // Scan outside pairs in
        time = analogRead(2);
        digitalWrite(leds[i], HIGH);
        digitalWrite(leds[(totalLeds - i) - 1], HIGH);
        delay(time);
        digitalWrite(leds[i], LOW);
        digitalWrite(leds[(totalLeds - i) - 1], LOW);
        delay(time);
    }
    for(int i = (halfLeds - 1); i > 0; --i) {
        // Scan inside pairs out
        time = analogRead(2);
        digitalWrite(leds[i], HIGH);
        digitalWrite(leds[(totalLeds - i) - 1], HIGH);
        delay(time);
        digitalWrite(leds[i], LOW);
        digitalWrite(leds[(totalLeds - i) - 1], LOW);
        delay(time);
    }
}

Este código é um pouco mais complexo. Observe como ambos os loops vão de zero a "halfLeds - 1" (3). Isso faz um scanner melhor. Se ambos os loops fossem de 4 - 0 e 0 - 4, então os mesmos LEDs piscariam duas vezes na mesma sequência - isso não pareceria muito bom.

Você agora deve ter um scanner led Knight Rider funcionando! Seria fácil modificar isso para usar LEDs mais ou maiores, ou implementar seu próprio padrão. Este circuito é muito fácil de portar para um Raspberry Pi (novo para Pi? Comece aqui) ou ESP8266.

Está construindo uma réplica do KITT? Eu adoraria ver todas as coisas Knight Rider nos comentários.

Pesquisar este blog

Pulo do gato Dicas de Informatica.