Dado Eletrônico Arduino com Matriz LED Ativado por Chacoalhar

Componentes e Materiais

Componente	Quantidade
Arduino Nano R3	1
Matriz de Pontos 8x8 3mm com MAX7219	1
Módulo de chave de inclinação (tilt switch) com interface digital	1
Chave deslizante (slide switch)	1
Módulo Step-Up MT3608 DC 2A (2V-24V para 5V/9V/12V/28V)	1

Ferramentas Necessárias

• Ferro de solda
• Pistola de cola quente

Software e Serviços Online

• Arduino IDE
• Autodesk Fusion 360 (para design da caixa)

Sobre o Projeto

Cerca de um ano atrás, meu filho e eu construímos um dado eletrônico com Arduino e alguns LEDs. Ainda é um projeto ideal para iniciantes. Aprendemos muito desde então, então chegou a hora de uma atualização.

O dado continua sendo um projeto inicial perfeito. Sua função é clara para todos e é fácil entender as diferentes áreas: microcontrolador, eletrônica simples e programação.

Versão 2.0

O dado também é fantástico para dar um passo adiante: integrar outras áreas.

Hoje existem componentes prontos para quase tudo. Isso fica evidente ao procurar um kit inicial para Arduino ou Raspberry Pi. Componentes como LEDs, botões e sensores já vêm montados em placas de circuito e podem ser conectados com apenas alguns fios aos GPIOs.

Impressoras 3D simples estão disponíveis por menos de 140 €. Quase todas as variações de suportes, fixações ou caixas podem ser criadas com elas.

Há várias oportunidades para desenvolver seus próprios projetos. Um exemplo é nosso novo dado 2.0.

Sensores de Inclinação

Implementamos o dado de uma forma completamente diferente. Por questões de espaço, usamos um Arduino Nano. Ainda há uma chave liga/desliga, mas nenhum botão. O sorteio é feito chacoalhando o cubo inteiro.

Para isso, utilizamos sensores de inclinação ou vibração. Eles funcionam exatamente como um botão: dentro de um tubo de vidro, uma esfera metálica se move. Quando ela toca os contatos de conexão, o circuito é fechado. Esse contato, às vezes muito breve, é usado como sinal.

O movimento da esfera metálica pode ser ouvido claramente se você chacoalhar o sensor.

Normalmente, a posição de instalação é decisiva para um sensor de inclinação. Ele deve disparar um sinal em uma certa posição angular. No nosso caso, isso acontece chacoalhando a caixa. Aqui a orientação não é tão importante, pois chacoalhando em qualquer direção um sinal é disparado. Para garantir, usamos dois sensores no projeto, dispostos com um deslocamento de 90° entre si. Assim, sempre obtemos um sinal de chacoalhada confiável.

Interrupções

Para detectar a chacoalhada, os pinos de entrada dos sensores de inclinação teriam que ser consultados no sketch. No entanto, dependendo de quando isso acontece no tempo e do que mais o sketch tem a fazer, sempre existe a possibilidade de que um ou mais eventos passem despercebidos.

Uma solução melhor é usar interrupções de hardware. Isso é definido pela função attachInterrupt. Como parâmetro, especifica-se uma sub-rotina que deve ser chamada no sinal.

O Arduino fornece duas interrupções de hardware: pinos D2 e D3.

Display

Claro, a exibição da face do dado poderia ser feita novamente com 7 LEDs individuais. Mas também é mais interessante usar um componente pronto.

Nossa escolha para este projeto recaiu sobre uma matriz LED 8x8 com CI driver MAX7219. Ela ocupa muito pouco espaço, custa pouco e é fácil de programar.

Dependendo de onde você compra, pode ser necessário soldar e montar as peças individuais. Normalmente não é problema. O único erro que pode acontecer é encaixar a matriz LED girada nos soquetes.

Isso é mostrado na imagem acima. Basta puxar cuidadosamente a matriz dos soquetes e girá-la 180°.

Um Pouco de Física

A matriz LED não deve apenas mostrar o resultado do dado como resultado final. Ela deve oferecer alguns efeitos de animação. Os seis pontos do dado se movem na matriz: ricocheteiam nas bordas e perdem velocidade gradualmente.

Através dos dois sensores de inclinação, podemos detectar a intensidade do chacoalhão. Essa informação é dada aos pontos do dado como "velocidade" para seu movimento.

Também usamos um efeito semelhante ao exibir o resultado do dado. Os pontos rolam de sua posição aleatória para a posição correta na imagem do cubo.

Alimentação

Inicialmente, instalamos duas pilhas de botão CR2032 de 3V por questões de espaço. No início funcionou bem. O Arduino e a matriz LED funcionaram e tudo operou. Após alguns minutos de operação, no entanto, a energia das pilhas de botão cai drasticamente.

Se você desligar o Arduino após cada jogada, poderia usar assim. Isso não é ideal, então instalamos duas pilhas AAA. No entanto, elas fornecem juntas apenas 3V. Portanto, ainda precisamos de um conversor step-up, que eleva a tensão para 5V. A conexão ainda ocorre no pino VIN do Arduino.

Design da Caixa

A melhor opção para uma caixa adequada é um design próprio e produção via impressão 3D. Existem muitos aplicativos para a construção. Usamos o Autodesk Fusion 360 para este projeto. Ele tem ótimos recursos e a impressão 3D é bem integrada com o software Print Studio.

Nossa caixa consiste em 3 partes:

• Tampa superior
• Base inferior com suporte para pilhas AAA
• Tampa de acrílico leitoso (opcional)

A matriz LED fica ainda melhor com uma tampa de acrílico leitoso na frente. Isso torna impossível reconhecer os LEDs apagados e a imagem fica mais nítida.

Sketch (Código)

Para controlar a Matriz LED, a biblioteca LedControl é necessária. Se ainda não estiver instalada, pode ser baixada em arduino.cc.

Em seguida, fazemos as outras definições de variáveis. Primeiro, determinamos como os pontos do dado são exibidos na matriz. Um ponto do dado consiste em 4 pontos LED. No array, o canto superior esquerdo é especificado como coordenada X/Y (-1 significa fora do display).

int DicePic[8][6][2] = {
  { // Matriz vazia e posição inicial:
    {9,9}, // 1. Ponto
    {9,8}, // 2. Ponto
    {9,7}, // 3. Ponto
    {9,6}, // 4. Ponto
    {9,5}, // 5. Ponto
    {9,4}  // 6. Ponto
  },
  { // 1:
    {4,4}, // 1. Ponto
    {-1,-1}, // 2. Ponto
    {-1,-1}, // 3. Ponto
    {-1,-1}, // 4. Ponto
    {-1,-1}, // 5. Ponto
    {-1,-1}  // 6. Ponto
  },
  { // 2:
    {2,2}, // 1. Ponto
    {6,6}, // 2. Ponto
    {-1,-1}, // 3. Ponto
    {-1,-1}, // 4. Ponto
    {-1,-1}, // 5. Ponto
    {-1,-1}  // 6. Ponto
  },
  // ... (demais faces 3 a 6 e posição inicial)
};

Claro, tudo é possível aqui. Deixe sua imaginação correr solta. Nem sempre precisa ser a imagem típica de pontos.

Outras observações você encontra diretamente no código.

Montagem

Colocamos nosso Arduino em uma barra de soquetes, como uma espécie de shield. Os cinco contatos da matriz LED são conectados da mesma forma. Se o Arduino for centralizado, o espaço é melhor aproveitado. Portanto, é melhor usar os pinos 5, 6, 7 para CS, CLK e DIN da matriz. Aqui, apenas os pontos de solda devem ser conectados. A conexão a 5V e GND é feita via um pequeno jumper.

Também conectamos os dois sensores de inclinação com fios curtos. Estes são conectados aos pinos 2 e 3 e a 5V e GND.

Agora tudo pode ser montado. O acrílico é fixado primeiro com cola quente. Fazemos o mesmo com a matriz LED. Um pequeno ponto de cola quente é suficiente.

Em seguida, o interruptor liga/desliga é instalado, fixado com cola quente e conectado aos fios apropriados.

Montagem da Alimentação

A alimentação é um pouco improvisada. Dependendo das opções e componentes que você tem, os contatos para mais e menos podem ser ajustados.

Usamos as molas e pinos de um compartimento de pilhas usado. Para fixar na base da caixa, usamos fios e um pouco de cola quente novamente.

O conversor step-up boost deve ser ajustado para aproximadamente 5V antes da instalação. Para isso, o trimpot deve ser girado um pouco.

Então, a tampa superior e inferior são encaixadas. Devido ao encaixe de 0,1 mm, a união sem fixação adicional é suficiente. E ainda podem ser abertas novamente para troca de pilhas.

E está pronto! A diversão do dado 2.0 pode começar!

O Que Você Precisa

• Arduino Nano (ou ESP8266)
• 2 x sensores de inclinação (com resistores integrados)
• Matriz LED 8x8 com MAX7219 IC, SPC
• Barra de soquetes
• Interruptor Liga/Desliga
• Placa de circuito impresso (PCI)
• 2 x pilhas AAA

Mais Informações

Se quiser ler mais, visite nosso site techpluscode.de/arduino-wuerfel-2-0.

Desculpe, este blog estendido está disponível apenas em alemão ;-)

Código

wuerfel8x8.ino (Arduino)

/* Artigo do Blog: Dado Chacoalhável com Matriz LED e Simulação de Movimento
   https://techpluscode.de/schuettel-wuerfel-mit-led-matrix-und-bewegungssimulation/
   techpluscode.de Copyright 2019 por Thomas Angielsky */

#include "LedControl.h"

int PinTiltX = 2; // Pino para sensor de inclinação X
int PinTiltY = 3; // Pino para sensor de inclinação Y

// Pinos da matriz LED
int PinCLK = 7;
int PinCS = 6;
int PinDIN = 5;

LedControl lc = LedControl(PinDIN, PinCLK, PinCS, 1);

// Coordenadas dos pontos do dado na matriz LED
int DicePic[8][6][2] = {
  { // Matriz vazia e posição inicial
    {9,9}, {9,8}, {9,7}, {9,6}, {9,5}, {9,4}
  },
  { // 1
    {4,4}, {-1,-1}, {-1,-1}, {-1,-1}, {-1,-1}, {-1,-1}
  },
  { // 2
    {2,2}, {6,6}, {-1,-1}, {-1,-1}, {-1,-1}, {-1,-1}
  },
  { // 3
    {2,6}, {6,2}, {4,4}, {-1,-1}, {-1,-1}, {-1,-1}
  },
  { // 4
    {2,2}, {2,6}, {6,2}, {6,6}, {-1,-1}, {-1,-1}
  },
  { // 5
    {2,2}, {2,6}, {6,2}, {6,6}, {4,4}, {-1,-1}
  },
  { // 6
    {2,1}, {2,4}, {2,7}, {6,1}, {6,4}, {6,7}
  },
  { // Inicial
    {-1,-1}, {-1,-1}, {-1,-1}, {-1,-1}, {-1,-1}, {-1,-1}
  }
};

// Variáveis dos pontos do dado: posição, direção, velocidade para X e Y
float DiceXpos[6];
float DiceXdir[6];
volatile byte DiceXspeed[6];
float DiceYpos[6];
float DiceYdir[6];
volatile byte DiceYspeed[6];

int DiceValue;
unsigned long timestamp;
byte Mode;
int volatile shakes;
int ShakesPerSecond;
int step;

void InterruptChecks() {
  shakes = shakes + 1;
  timestamp = millis();
}

void SetSpeedX() {
  if (Mode == 0) {
    for (int i = 0; i < 6; i++) {
      if (DiceXspeed[i] < 255) DiceXspeed[i] = DiceXspeed[i] + 5;
    }
  }
  InterruptChecks();
}

void SetSpeedY() {
  if (Mode == 0) {
    for (int i = 0; i < 6; i++) {
      if (DiceYspeed[i] < 255) DiceYspeed[i] = DiceYspeed[i] + 5;
    }
  }
  InterruptChecks();
}

void ShowLed(int x, int y, bool onoff) {
  if ((x < 8) && (y < 8) && (x >= 0) && (y >= 0)) {
    lc.setLed(0, x, y, onoff);
  }
}

void ShowDot(int x, int y, bool onoff) {
  ShowLed(x-1, y-1, onoff);
  ShowLed(x, y-1, onoff);
  ShowLed(x-1, y, onoff);
  ShowLed(x, y, onoff);
}

void ShowDicePic(int value) {
  boolean done;
  for (int i = 0; i < 6; i++) {
    DiceXspeed[i] = 100;
    DiceYspeed[i] = 100;
    DiceXdir[i] = 0;
    if (int(DiceXpos[i]) > DicePic[value][i][0]) DiceXdir[i] = -1;
    else if (int(DiceXpos[i]) < DicePic[value][i][0]) DiceXdir[i] = 1;
    DiceYdir[i] = 0;
    if (int(DiceYpos[i]) > DicePic[value][i][1]) DiceYdir[i] = -1;
    else if (int(DiceYpos[i]) < DicePic[value][i][1]) DiceYdir[i] = 1;
  }

  do {
    for (int i = 0; i < 6; i++) {
      if (int(DiceXpos[i]) != DicePic[value][i][0]) DoStep(DiceXpos[i], DiceXdir[i], DiceXspeed[i], false);
      if (int(DiceYpos[i]) != DicePic[value][i][1]) DoStep(DiceYpos[i], DiceYdir[i], DiceYspeed[i], false);
    }
    lc.clearDisplay(0);
    for (int i = 0; i < 6; i++) ShowDot(int(DiceXpos[i]), int(DiceYpos[i]), true);
    delay(50);
    done = true;
    for (int i = 0; i < 6; i++) {
      if (int(DiceXpos[i]) != DicePic[value][i][0]) done = false;
      if (int(DiceYpos[i]) != DicePic[value][i][1]) done = false;
    }
  } while (!done);

  lc.clearDisplay(0);
  for (int i = 0; i < 6; i++) ShowDot(DicePic[value][i][0], DicePic[value][i][1], true);
}

void DoStep(float &pos, float &dir, volatile byte &sp, bool check) {
  pos = pos + float(sp)/255 * dir;
  if (check) {
    if (pos > 7) { pos = 7; dir = dir * -1; }
    if (pos < 1) { pos = 1; dir = dir * -1; }
  }
  if (sp > 0) sp = sp - 1;
}

void MoveDots() {
  for (int i = 0; i < 6; i++) {
    DoStep(DiceXpos[i], DiceXdir[i], DiceXspeed[i], true);
    DoStep(DiceYpos[i], DiceYdir[i], DiceYspeed[i], true);
  }
  lc.clearDisplay(0);
  for (int i = 0; i < 6; i++) ShowDot(int(DiceXpos[i]), int(DiceYpos[i]), true);
}

void setup() {
  lc.shutdown(0, false);
  lc.setIntensity(0, 8);
  lc.clearDisplay(0);
  randomSeed(analogRead(0));
  DiceValue = 0;
  for (int i = 0; i < 6; i++) {
    DiceXpos[i] = DicePic[7][i][0];
    DiceYpos[i] = DicePic[7][i][1];
    DiceXdir[i] = random(3) - 1;
    DiceYdir[i] = random(3) - 1;
    DiceXspeed[i] = random(126) + 120;
    DiceYspeed[i] = random(126) + 120;
  }
  pinMode(PinTiltX, INPUT_PULLUP);
  pinMode(PinTiltY, INPUT_PULLUP);
  attachInterrupt(digitalPinToInterrupt(PinTiltX), SetSpeedX, CHANGE);
  attachInterrupt(digitalPinToInterrupt(PinTiltY), SetSpeedY, CHANGE);
  lc.clearDisplay(0);
  timestamp = millis();
  Mode = 1;
  ShowDicePic(6);
  delay(1000);
  lc.clearDisplay(0);
  Mode = 0;
  Serial.begin(9600);
  step = 0;
  shakes = 0;
}

void loop() {
  delay(50);
  step++;
  if (step > 20) {
    step = 0;
    ShakesPerSecond = shakes;
    shakes = 0;
  }
  if (Mode == 0) {
    MoveDots();
    if (millis() - timestamp > 2000) {
      Mode = 1;
      DiceValue = random(6) + 1;
      ShowDicePic(DiceValue);
    }
  }
  if (ShakesPerSecond > 5) {
    Mode = 0;
  }
}

Peças Personalizadas e Caixas

Os arquivos STL para impressão 3D estão disponíveis na seção de anexos.

Esquemático

Este é meu esboço para o circuito.