Dado Eletrônico Facil de Fazer.

 

Dado Eletrônico Simplificado com Microcontrolador (Arduino/ESP32/ESP8266)

O que faz?

É exatamente a mesma funcionalidade: simula um dado de 6 faces, rola ao pressionar um botão e exibe o resultado em LEDs. A diferença é a plataforma, tornando-o ainda mais plug-and-play.

Por que é genial?

Ainda Mais Simples: Menos componentes para configurar e nenhum sistema operacional para instalar no microcontrolador (apenas o código).

Portátil e Alimentado por USB/Bateria: Perfeito para ser um acessório de jogos que você pode levar para qualquer lugar.

Foco Total na Lógica: Você se concentra na programação dos LEDs e do botão, sem se preocupar com a interface do sistema.

Custo-benefício: Placas como o Arduino Nano ou ESP8266 Wemos D1 Mini são muito acessíveis.

Como funciona (de forma simplificada)?

A lógica é idêntica ao projeto com Raspberry Pi, mas a plataforma de execução muda:

Entrada (Botão): O pressionamento do botão é lido por um pino digital do microcontrolador.

Processamento (Microcontrolador): O microcontrolador (Arduino, ESP, etc.) executa o código que você carregou.

Geração Aleatória: Um número aleatório entre 1 e 6 é gerado.

Saída (LEDs): O microcontrolador controla os pinos digitais para acender a combinação correta de LEDs, representando o número sorteado.

Componentes Chave que Você Vai Precisar:

1x Microcontrolador:

Arduino Uno ou Nano: Excelente para iniciantes, muitos tutoriais e comunidade.

ESP32 ou ESP8266 (NodeMCU/Wemos D1 Mini): Ótimos se você já tem um e quer praticar.

7x LEDs: Para os pontos do dado (geralmente 5mm).

7x Resistores de 220Ω a 330Ω: Para proteger os LEDs.

1x Botão Push-button: Para "rolar" o dado.

1x Resistor de 10kΩ: Para o botão (resistência de pull-down).

Protoboard: Para montar o circuito.

Fios Jumper: Para as conexões.

Cabo USB: Para programar e alimentar o microcontrolador (ex: USB-A para USB-B para Arduino Uno, Micro USB para NodeMCU/Wemos D1 Mini).

Conexões na Protoboard:

A lógica das conexões é muito similar à do Raspberry Pi, mas os nomes dos pinos podem mudar um pouco (ex: D1, A0 no Arduino em vez de GPIO2).

LEDs:

Cada LED terá seu ânodo (+) conectado a um pino digital do microcontrolador através de um resistor (220Ω a 330Ω).

Todos os cátodos (-) dos LEDs serão conectados ao GND (terra) do microcontrolador.

Escolha 7 pinos digitais no seu microcontrolador para os LEDs (ex: pinos 2 a 8 no Arduino Uno).

Botão:

Uma perna do botão conectada a um pino digital do microcontrolador (ex: pino 9 no Arduino Uno).

A outra perna do botão conectada ao GND do microcontrolador através de um resistor de 10kΩ.

Conecte também essa mesma perna do botão diretamente ao GND do microcontrolador. (Isso forma um pull-down externo. Alternativamente, você pode usar o pull-up interno do microcontrolador, como no Pi, e conectar a outra perna do botão ao +V).

Exemplo de pinagem para Arduino Uno:

LEDs (ânodo via resistor): Pinos digitais 2, 3, 4, 5, 6, 7, 8

Todos os LEDs (cátodo): GND

Botão: Uma perna ao pino digital 9; outra perna ao GND (via resistor de 10kΩ) e diretamente ao GND.

Programação (Arduino IDE):

A programação será feita na Arduino IDE, que é usada para todos esses microcontroladores. A lógica é quase idêntica ao Python que vimos, mas em C++ (linguagem base do Arduino).

C++

const int LED_PINS[] = {2, 3, 4, 5, 6, 7, 8}; // Pinos dos LEDs

const int NUM_LEDS = 7;

const int BUTTON_PIN = 9; // Pino do botão

// Mapeamento dos LEDs para cada número do dado

// (Índice 0 não usado, começa do 1)

const int dicePatterns[7][NUM_LEDS] = {

// LEDs desligados (para limpar)

{0,0,0,0,0,0,0},

// 1 (apenas LED central aceso)

{0,0,0,1,0,0,0}, // Exemplo: se o LED central está no pino 5 (índice 3 do array)

// 2

{0,1,0,0,1,0,0}, // Exemplo: LEDs nos pinos 3 e 6

// 3

{0,1,0,1,1,0,0}, // Exemplo: LEDs nos pinos 3, 5 e 6

// 4

{1,1,0,0,1,1,0}, // Exemplo: LEDs nos pinos 2,3,6,7

// 5

{1,1,0,1,1,1,0}, // Exemplo: LEDs nos pinos 2,3,5,6,7

// 6

{1,1,1,0,1,1,1} // Exemplo: LEDs nos pinos 2,3,4,6,7,8

};

void setup() {

// Configura os pinos dos LEDs como OUTPUT

for (int i = 0; i < NUM_LEDS; i++) {

pinMode(LED_PINS[i], OUTPUT);

digitalWrite(LED_PINS[i], LOW); // Inicia todos desligados

}

// Configura o pino do botão como INPUT_PULLUP (se usar pull-up interno)

// Ou INPUT se usar resistor de pull-down externo (como no exemplo acima)

pinMode(BUTTON_PIN, INPUT); // Para resistor de pull-down externo

// pinMode(BUTTON_PIN, INPUT_PULLUP); // Se for usar pull-up interno e ligar botão ao GND

// Inicializa o gerador de números aleatórios

randomSeed(analogRead(0)); // Usa um pino analógico não conectado para obter aleatoriedade

}

void clearLEDs() {

for (int i = 0; i < NUM_LEDS; i++) {

digitalWrite(LED_PINS[i], LOW);

}

}

void displayNumber(int num) {

clearLEDs();

// Este mapeamento é simplificado. Na prática, você mapearia os índices do array

// aos pinos específicos que acendem para cada número.

// Você precisaria de uma lógica mais complexa para acender os LEDs certos

// com base no "dicePatterns" definido acima.

// Por exemplo:

// for (int i = 0; i < NUM_LEDS; i++) {

// if (dicePatterns[num][i] == 1) {

// digitalWrite(LED_PINS[i], HIGH);

// }

// }

// Exemplo MUITO simplificado para um dado de 7 LEDs, onde cada índice corresponde

// a um LED específico para o número. Você precisaria refinar o array dicePatterns

// e esta parte do código para acensder os LEDs corretos para cada número.

if (num == 1) digitalWrite(LED_PINS[3], HIGH); // LED central

else if (num == 2) { digitalWrite(LED_PINS[1], HIGH); digitalWrite(LED_PINS[4], HIGH); }

// ... e assim por diante para os outros números

}

void loop() {

// Lê o estado do botão

// Se estiver usando pull-down externo: HIGH quando pressionado

// Se estiver usando pull-up interno: LOW quando pressionado

if (digitalRead(BUTTON_PIN) == HIGH) { // Mude para LOW se usar pull-up interno

// Pequena animação de piscar

for (int i = 0; i < 10; i++) {

clearLEDs();

delay(50);

for (int j = 0; j < NUM_LEDS; j++) {

digitalWrite(LED_PINS[j], HIGH);

}

delay(50);

}

clearLEDs();

int diceRoll = random(1, 7); // Gera número entre 1 e 6

displayNumber(diceRoll);

delay(2000); // Mostra o resultado por 2 segundos

// Espera o botão ser solto para evitar múltiplas rolagens

while (digitalRead(BUTTON_PIN) == HIGH) { // Mude para LOW se usar pull-up interno

delay(10);

}

}

}

Observações Importantes sobre o Código:

randomSeed(analogRead(0));: Usa a "leitura de ruído" de um pino analógico não conectado para inicializar o gerador de números aleatórios. Isso o torna mais "aleatório" a cada vez que o Arduino liga.

displayNumber Lógica: A função displayNumber no exemplo de código é simplificada. Para acender a combinação exata de LEDs que formam o padrão de um dado (por exemplo, os 6 pontos de um "6"), você precisaria de uma lógica um pouco mais elaborada, mapeando os 7 LEDs para as 6 faces. O array dicePatterns é uma sugestão de como você pode fazer esse mapeamento no código.

Pull-up/Pull-down do Botão: Preste atenção se você vai usar um resistor de pull-down externo (como no exemplo de conexão acima) ou o pull-up interno do microcontrolador (configurado no código). Isso afeta se o digitalRead() do botão retornará HIGH ou LOW quando pressionado.

Este é um projeto fantástico para começar, pois ensina a base da interação de hardware e software em microcontroladores. Curtiu essa abordagem mais direta?