Manufaturação industrial
Internet das coisas industrial | Materiais industriais | Manutenção e reparo de equipamentos | Programação industrial |
home  MfgRobots >> Manufaturação industrial >  >> Manufacturing Technology >> Processo de manufatura

Crie Sequências de Luz Incríveis com Registrador de Deslocamento Arduino

Componentes e Materiais

Componente Quantidade
Arduino UNO 1
Protoboard (genérica) 2
Fios jumpers (genéricos) 55
Registrador de deslocamento 74HC595 1
Botões 4
Potenciômetro rotativo (genérico) 1
LEDs (genéricos) 8
Resistor 221 ohm 9
Resistor 10k ohm 4

Ferramentas Necessárias

Mãos

Aplicativos e Serviços Online

Arduino IDE

Sobre o Projeto

Estava me divertindo com luzes e arrays e pensei em usar o registrador de deslocamento e a tela LCD para criar um programa onde você pode modificar e exibir suas animações de luz sem precisar alterar o código e criar uma animação manualmente a cada vez.

Há 4 botões, da esquerda para a direita numerados de 1 a 4. Eles permitem navegar no menu e alterar variáveis. O botão 1 é usado para incrementar valores e para definir o estado de uma luz como HIGH. O botão 2 decrementa valores e define o estado de uma luz como LOW. O botão 3 move o cursor para trás durante a criação de um quadro, e o botão 4 funciona como um botão "voltar".

O programa pode modificar a velocidade da animação e a quantidade de vezes que ela será repetida. Talvez eu lance outra versão permitindo múltiplas animações.

Você pode alterar os quadros mudando o ARR_SIZE no topo do código.

Divirta-se!

Código

Sequenciador de Luz

Conecte este código e execute-o, se a fiação estiver correta, não deve haver problemas!

#include <LiquidCrystal.h>
#define ARR_SIZE 16 // ALTERAR para qualquer número de quadros
#define LIGHTS 8 // Controla as entradas dos botões do jogo
const int btn1 = 7, btn2 = 8, btn3 = 9, btn4 = 10;
// Variável para ler o status do pushbutton
int bs1 = 0, bs2 = 0, bs3 = 0, bs4 = 0;
// Pino conectado ao ST_CP do 74HC595
const int latchPin = 11;
// Pino conectado ao SH_CP do 74HC595
const int clockPin = 13;
// Pino conectado ao DS do 74HC595
const int dataPin = 12;
// Variáveis para armazenar informações a serem passadas
byte data;
// Usado para ler 1 ou 0
bool ArrOne[ARR_SIZE][LIGHTS] = {false}; // animação
// Traduzido para o registrador como bytes
byte lightArrOne[ARR_SIZE] = {0xFF};
// Variáveis para afetar a animação
int animSpeed = 50; // ms entre cada quadro
int loopCount = 5; // quantidade de vezes que será executado
// Controla valores do LCD
const int rs = 15, en = 14, d4 = 3, d5 = 4, d6 = 5, d7 = 6;
LiquidCrystal lcd(rs, en, d4, d5, d6, d7);

void setup() {
  // Configura cada botão
  pinMode(btn1, INPUT_PULLUP);
  pinMode(btn2, INPUT_PULLUP);
  pinMode(btn3, INPUT_PULLUP);
  pinMode(btn4, INPUT_PULLUP);
  // Configura o número de colunas e linhas do LCD
  lcd.begin(16, 2);
  // Configura pino de latch do registrador
  pinMode(latchPin, OUTPUT);
  PrintMenu();
}

void loop() {
  bs1 = digitalRead(btn1);
  bs2 = digitalRead(btn2);
  bs3 = digitalRead(btn3);
  bs4 = digitalRead(btn4);
  // Executa a animação
  if(bs1 == HIGH) {
    bs1 = LOW; // apenas usado para evitar entrada ruim/dupla
    delay(150);
    Play();
  // Modifica a animação
  } else if(bs2 == HIGH) {
    bs2 = LOW;
    delay(150);
    Create(ArrOne);
  // Altera a velocidade da animação
  } else if(bs3 == HIGH) {
    bs3 = LOW;
    delay(150);
    SetSpeed();
  // Altera o número de vezes que a animação será executada
  } else if(bs4 == HIGH) {
    bs4 = LOW;
    delay(150);
    SetLoop();
  }
  PrintMenu();
  delay(150);
}

// Função para imprimir informações do menu principal
void PrintMenu() {
  ClearScreen();
  lcd.print("1-Play 3-Speed");
  lcd.setCursor(0, 1);
  lcd.print("2-Create 4-Loops");
}

// Função para imprimir informações da criação de um quadro
void PrintCreate(bool Arr[][LIGHTS], int frame, int _bit) {
  ClearScreen();
  lcd.print("Frame:");
  lcd.print(frame+1);
  if(frame < 9) lcd.print(" ");
  for(int j = 0; j < _bit; j++) lcd.print(" ");
  lcd.print("v");
  lcd.setCursor(0, 1);
  lcd.print(" ");
  for(int j = 0; j < 8; j++) lcd.print(Arr[frame][j]);
}

// Função para imprimir informações para definir a velocidade
void PrintSetSpeed() {
  ClearScreen();
  lcd.print("Set Speed(ms)");
  lcd.setCursor(0, 1);
  lcd.print(animSpeed);
}

// Função para imprimir informações para alterar o número de loops da animação
void PrintSetLoop() {
  ClearScreen();
  lcd.print("Set Loop Count");
  lcd.setCursor(0, 1);
  lcd.print(loopCount);
}

// Função para executar a animação com os parâmetros dados
void Play() {
  // A animação
  for(int count = 0; count < loopCount; count++) {
    for(int i = 0; i < ARR_SIZE; ++i) {
      // Carrega a sequência de luz desejada do array
      data = lightArrOne[i];
      // Aterra latchPin e mantém baixo enquanto transmite
      digitalWrite(latchPin, 0);
      // Move os bits
      shiftOut(dataPin, clockPin, data);
      // Retorna o pino de latch alto para sinalizar ao chip que
      // não precisa mais ouvir informações
      digitalWrite(latchPin, 1);
      delay(animSpeed);
    }
  }
  data = 0;
  for(int i = 0; i < ARR_SIZE; ++i) {
    digitalWrite(latchPin, 0);
    shiftOut(dataPin, clockPin, data);
    digitalWrite(latchPin, 1);
  }
}

// Menu para criar um quadro
void Create(bool Arr[][LIGHTS]) {
  // Aguarda a entrada do usuário para um dos botões
  for(int frame = 0; frame < ARR_SIZE; frame++) {
    bool leaving = false;
    int b = 0;
    while((!leaving) && (b < LIGHTS)) {
      PrintCreate(Arr, frame, b);
      // Garante que b está dentro dos limites
      if(b < 0 && frame > 0) {
        b = LIGHTS-1;
        frame--;
      }
      bs1 = digitalRead(btn1);
      bs2 = digitalRead(btn2);
      bs3 = digitalRead(btn3);
      bs4 = digitalRead(btn4);
      if(bs1 == HIGH) {
        delay(150);
        Arr[frame][b] = true;
        b++;
      } else if(bs2 == HIGH) {
        delay(150);
        Arr[frame][b] = false;
        b++;
      } else if(bs3 == HIGH) {
        delay(150);
        b--;
      } else if(bs4 == HIGH) {
        delay(150);
        leaving = true;
      }
      delay(10);
    }
    PrintCreate(Arr, frame, b);
    IntToHexToByte(Arr);
    delay(500);
  }
}

// Função para converter o array em byte para o registrador ler
void IntToHexToByte(bool Arr[][LIGHTS]) {
  for(int row = 0; row < ARR_SIZE; row++) {
    lightArrOne[row] = BoolArrayToByte(Arr, row);
  }
}

// Função auxiliar para converter binário em byte
byte BoolArrayToByte(bool Arr[][LIGHTS], int row) {
  byte result = 0;
  for(int i = 0; i < LIGHTS; i++) {
    if(Arr[row][i]) result = result | (1 << i);
  }
  return result;
}

// Menu para definir a velocidade da animação
void SetSpeed() {
  bool leaving = false;
  while(!leaving) {
    PrintSetSpeed();
    bs1 = digitalRead(btn1);
    bs2 = digitalRead(btn2);
    bs3 = digitalRead(btn3);
    bs4 = digitalRead(btn4);
    // Aumenta a velocidade
    if(bs1 == HIGH) {
      delay(10);
      animSpeed++;
    }
    // Diminui a velocidade
    if(bs2 == HIGH) {
      delay(10);
      if(animSpeed > 1) animSpeed--;
    }
    // Sai do menu
    if(bs4 == HIGH) {
      delay(150);
      leaving = true;
    }
    delay(30);
  }
}

// Função para alterar o número de vezes que a animação repete
void SetLoop() {
  bool leaving = false;
  while(!leaving) {
    PrintSetLoop();
    bs1 = digitalRead(btn1);
    bs2 = digitalRead(btn2);
    bs3 = digitalRead(btn3);
    bs4 = digitalRead(btn4);
    if(bs1 == HIGH) {
      delay(10);
      loopCount++;
    }
    if(bs2 == HIGH) {
      delay(10);
      if(animSpeed > 1) loopCount--; // Nota: verifica animSpeed, deveria ser loopCount
    }
    if(bs4 == HIGH) {
      delay(150);
      leaving = true;
    }
    delay(30);
  }
}

// Função para efetivamente deslocar os bits no registrador
void shiftOut(int myDataPin, int myClockPin, byte myDataOut) {
  // Desloca 8 bits MSB first,
  // na borda de subida do clock,
  // clock ocioso em low
  int i = 0;
  int pinState;
  pinMode(myClockPin, OUTPUT);
  pinMode(myDataPin, OUTPUT);
  // Limpa tudo por precaução para
  // preparar registrador de deslocamento para deslocamento de bits
  digitalWrite(myDataPin, 0);
  digitalWrite(myClockPin, 0);
  // Cada bit no byte myDataOut
  for (i = 7; i >= 0; i--) {
    digitalWrite(myClockPin, 0);
    if ( myDataOut & (1 << i) ) {
      pinState = 1;
    } else {
      pinState = 0;
    }
    // Define o pino como HIGH ou LOW dependendo do pinState
    digitalWrite(myDataPin, pinState);
    // Registrador desloca bits na subida do clock
    digitalWrite(myClockPin, 1);
    // Zera o pino de dados após deslocamento
    digitalWrite(myDataPin, 0);
  }
  // Para de deslocar
  digitalWrite(myClockPin, 0);
}

// Função para limpar o LCD imprimindo espaços
void ClearScreen() {
  // Percorre cada linha e imprime em branco
  lcd.setCursor(0, 0);
  for(int col = 0; col < 16; col++) lcd.print(" ");
  lcd.setCursor(0, 1);
  for(int col = 0; col < 16; col++) lcd.print(" ");
  lcd.setCursor(0, 0);
}

Esquemáticos

Siga as linhas cuidadosamente. Devido a limitações no comprimento dos resistores no programa e para fins de legibilidade, não consegui compactá-lo da mesma forma que fiz na minha montagem real. Após a montagem, desafio você a encontrar maneiras de limpá-lo.

Crie Sequências de Luz Incríveis com Registrador de Deslocamento Arduino

Processo de manufatura

  1. Detector de Idiomas TinyML com Edge Impulse no Arduino Nano 33 BLE Sense
  2. Construa um Jogo em Tempo Real com Giroscópio: Arduino Nano + Sensor MPU-6050
  3. Dados Digital com Arduino: Gere Números Aleatórios 1-6 em LCD 16x2
  4. Construa Seu Próprio Jogo de Roleta com 37 LEDs e Arduino Nano
  5. ATtiny85 Mini Arcade: Snake – Construa um Console Portátil de Jogos OLED
  6. Detector de Alcance Portátil – Kit DIY Arduino Nano com HC-SR04, Bateria 18650 e Gabinete 3D
  7. Lâmpada de Mesa Reativa a Áudio com Arduino Nano
  8. Carro Robô Autônomo de Rastreamento Facial com Arduino Nano e OpenCV
  9. Projeto de Galvanoplastia de Cobre: Construa um Sistema Inteligente com Arduino UNO
  10. Jogo Pong Neon em Matriz NeoPixel com Arduino Nano