Envío en 1 a 2 días hábiles en productos disponibles

Troxino
Categorías

El proyecto de fin de semana · 18 de noviembre 2026

El dado electrónico

Aprietas un botón, el display de 7 segmentos gira por números al azar, cada vez más lento, y se queda en un resultado del 1 al 6 con un pitido. Además cuenta cada tirada y la manda al Monitor Serie, así puedes comprobar si tu dado es justo.

  • Nivel principiante
  • 2 a 3 horas
  • 9 materiales

Sin soldar (Nano con pines soldados en protoboard y cables DuPont).

El dado electrónico

Para qué sirve en la escuela

  • Feria de ciencias: "¿Es justo mi dado?". Tira 100 o 300 veces, anota cuántas veces salió cada número y compara con lo esperado (1/6 cada uno). Sirve para hablar de probabilidad, azar y muestras grandes contra chicas.
  • Prepa y secundaria: salidas digitales, arreglos (arrays), números aleatorios (random) y una entrada con INPUT_PULLUP.
  • Ingeniería: cómo se maneja un display de 7 segmentos sin librerías, tabla de verdad por segmento y por qué cada segmento lleva su resistencia.

Cómo funciona

Qué vamos a hacer

Un dado que no se puede cargar con la mano. El Arduino espera a que aprietes el botón, muestra números al azar cada vez más lento (como un dado que rueda y se frena) y se queda en un resultado del 1 al 6. Lleva la cuenta de todas tus tiradas y te la muestra en el Monitor Serie.

Cómo funciona

  • El display: son siete LEDs en forma de rayitas, llamados segmentos, de la a a la g. Prendiendo algunos y otros no se forma cada número: el 1 usa solo b y c; el 6 usa todos menos b. En el código, la tabla NUMEROS dice qué segmentos prender para cada número.
  • El botón: el pin D9 está configurado con INPUT_PULLUP, que lo conecta por dentro a 5 V con una resistencia. Sin apretar, el Arduino lee HIGH. Al apretar, el botón une el pin con GND y lee LOW.
  • El azar: random(1, 7) da un número del 1 al 6. Mientras gira, el display muestra varios números al azar con una pausa que va creciendo, y al final se queda en el resultado.
  • La cuenta: un arreglo guarda cuántas veces salió cada número, y cada tirada lo imprime con una barrita de # por vez.

Por qué funciona

Una computadora no puede inventar números al azar de verdad: random() usa una fórmula que, a partir de un número inicial (la semilla), da una lista de números que parecen al azar. Con la misma semilla saldría siempre la misma lista. Por eso el código cambia la semilla dos veces:

  • Al arrancar, con analogRead(A0): A0 no está conectado a nada y su lectura brinca con el ruido eléctrico del ambiente.
  • Cada vez que aprietas, con micros(), los microsegundos que lleva prendido el Arduino. Nadie puede apretar un botón con precisión de millonésimas de segundo, así que ese número es imposible de repetir a propósito.

Un dado justo da cada número con probabilidad de 1/6. Eso no quiere decir que en 6 tiradas salga cada uno una vez: con pocas tiradas verás números que se repiten y otros que no salen. La ley de los grandes números dice que mientras más tires, más se acerca la proporción de cada número a 1/6 del total. Eso es lo que puedes comprobar con la cuenta del Monitor Serie.

Cada segmento es un LED y lleva su propia resistencia de 220 Ω. Si usaras una sola para todos (en el cátodo común), el 1 (dos segmentos) brillaría mucho más que el 6 (seis segmentos), porque la corriente se repartiría entre los que estén prendidos.

Conexiones

El Nano va a lo largo del protoboard, montado sobre el canal central. Usa un riel (−) como tierra común. El display, el botón y el buzzer quedan en la otra mitad del protoboard. Cada segmento lleva su propia resistencia de 220 Ω entre el pin del display y el pin del Nano.

Vista completa en el protoboard

El display 5161AS tiene 10 pines, 5 arriba y 5 abajo. Con el punto decimal (DP) hacia abajo a la derecha, los pines de abajo van de izquierda a derecha E, D, CC, C, DP y los de arriba, también de izquierda a derecha, G, F, CC, A, B.

Pieza Pin de la pieza A dónde va
Nano GND Riel − del protoboard
Display CC (pin 3 u 8, cátodo común) Riel −
Display A (pin 7) Resistencia de 220 Ω → Nano D2
Display B (pin 6) Resistencia de 220 Ω → Nano D3
Display C (pin 4) Resistencia de 220 Ω → Nano D4
Display D (pin 2) Resistencia de 220 Ω → Nano D5
Display E (pin 1) Resistencia de 220 Ω → Nano D6
Display F (pin 9) Resistencia de 220 Ω → Nano D7
Display G (pin 10) Resistencia de 220 Ω → Nano D8
Display DP (pin 5) Sin conectar
Botón Un lado Nano D9
Botón Lado opuesto Riel −
Buzzer pasivo + (pata marcada o más larga) Resistencia de 100 Ω → Nano D10
Buzzer pasivo − Riel −
Nano A0 Sin conectar (a propósito: su ruido hace que cada dado sea distinto)

Corrientes: cada segmento con 220 Ω queda en unos 13 mA (el 8 prendería los siete: unos 90 mA entre todos, dentro de lo que aguanta el Nano, y el dado solo llega al 6); el buzzer, con su resistencia de 100 Ω, queda por debajo de 20 mA. Cada pin va muy por debajo de su límite.

Paso a paso

  1. 01

    Monta el Nano sobre el canal central del protoboard, con el conector USB hacia afuera. Presiona parejo hasta que entren todos los pines.

  2. 02

    Tierra común: con un cable macho-macho, une el pin GND del Nano al riel − del protoboard.

  3. 03

    El display: colócalo del lado libre, con sus pines a cada lado del canal central. Del pin CC (3 u 8) un cable al riel −.

  4. 04

    Las siete resistencias de 220 Ω: una de cada pin A, B, C, D, E, F y G del display hacia una fila libre, y de ahí un cable al pin del Nano de la tabla (D2 a D8). No pongas nada en DP.

  5. 05

    El botón: ponlo sobre el canal central, de modo que sus lados opuestos queden en filas distintas. Un lado a D9 y el otro al riel −.

  6. 06

    El buzzer: pata − al riel −; pata + a una resistencia de 100 Ω y de ahí un cable a D10.

  7. 07

    Sube el código: conecta el Nano por USB, en el IDE elige Arduino Nano y el puerto. Si no sube, cambia el procesador a ATmega328P (Old Bootloader).

  8. 08

    Tira: el display recorre 1 al 6 al arrancar. Aprieta el botón: gira y se queda en un número. Abre el Monitor Serie a 9600 para ver la cuenta de cada tirada.

  9. 09

    Pon a prueba tu dado: tira 60 veces y anota cuántas veces salió cada número. Si es justo, cada uno debería rondar 10, pero con pocas tiradas verás diferencias. Mientras más tiras, más se parecen.

El paso a paso en imágenes

Código dado-electronico.ino

Ábrelo en el Arduino IDE, elige tu placa y puerto, y súbelo con la flecha.

// El dado electrónico
// El proyecto de fin de semana · Troxino.com
//
// Aprietas el botón, el display gira un momento y se queda en un número del 1 al 6.
// Cada tirada se cuenta y se manda al Monitor Serie para ver si el dado es justo.

const int SEGMENTOS[7] = {2, 3, 4, 5, 6, 7, 8};  // a, b, c, d, e, f, g (a D2 ... D8)
const int PIN_BOTON    = 9;                      // al otro lado del botón va GND
const int PIN_BUZZER   = 10;

// Qué segmentos prenden para cada número (1 = prendido), en orden a b c d e f g.
const byte NUMEROS[7][7] = {
  {0, 0, 0, 0, 0, 0, 0},  // 0: apagado
  {0, 1, 1, 0, 0, 0, 0},  // 1
  {1, 1, 0, 1, 1, 0, 1},  // 2
  {1, 1, 1, 1, 0, 0, 1},  // 3
  {0, 1, 1, 0, 0, 1, 1},  // 4
  {1, 0, 1, 1, 0, 1, 1},  // 5
  {1, 0, 1, 1, 1, 1, 1}   // 6
};

unsigned long cuenta[7];  // cuenta[1] = cuántas veces salió el 1, etc.
unsigned long tiradas = 0;

// Muestra un número (0 apaga el display).
void mostrar(int numero) {
  for (int i = 0; i < 7; i++) {
    digitalWrite(SEGMENTOS[i], NUMEROS[numero][i] ? HIGH : LOW);
  }
}

// El display "gira" por números al azar, cada vez más lento, y se queda en uno.
int tirar() {
  int final = random(1, 7);
  int espera = 40;
  while (espera < 300) {
    mostrar(random(1, 7));
    tone(PIN_BUZZER, 1800, 15);
    delay(espera);
    espera += 25;
  }
  mostrar(final);
  tone(PIN_BUZZER, 2600, 120);
  return final;
}

// Una línea por número: cuántas veces salió y una barrita para compararlas.
void mostrarCuenta() {
  Serial.print("Tirada ");
  Serial.println(tiradas);
  for (int n = 1; n <= 6; n++) {
    Serial.print(n);
    Serial.print(": ");
    Serial.print(cuenta[n]);
    Serial.print(" ");
    for (unsigned long i = 0; i < cuenta[n]; i++) {
      Serial.print("#");
    }
    Serial.println();
  }
}

void setup() {
  for (int i = 0; i < 7; i++) {
    pinMode(SEGMENTOS[i], OUTPUT);
  }
  pinMode(PIN_BOTON, INPUT_PULLUP);  // sin apretar = HIGH, apretado = LOW
  pinMode(PIN_BUZZER, OUTPUT);

  randomSeed(analogRead(A0));  // A0 sin conectar: ruido para variar la semilla
  Serial.begin(9600);
  Serial.println("Dado listo. Aprieta el boton.");

  // Prueba al arrancar: del 1 al 6.
  for (int n = 1; n <= 6; n++) {
    mostrar(n);
    delay(200);
  }
  mostrar(0);
}

void loop() {
  if (digitalRead(PIN_BOTON) == LOW) {
    randomSeed(micros());  // el momento exacto en que aprietas también cuenta
    int resultado = tirar();
    cuenta[resultado]++;
    tiradas++;
    mostrarCuenta();
    while (digitalRead(PIN_BOTON) == LOW) {
      delay(10);  // espera a que sueltes el botón
    }
    delay(50);
  }
}

Cómo probarlo

  1. Al conectar el Nano, el display muestra 1, 2, 3, 4, 5, 6 uno tras otro y se apaga: segmentos y resistencias están bien.
  2. Aprieta el botón: se oyen clics rápidos que se hacen más lentos, el número se queda fijo y suena un pitido más agudo.
  3. En el Monitor Serie aparece "Tirada 1" con una línea por cada número y una barrita de # por cada vez que salió.
  4. Suelta el botón y vuelve a apretarlo: otra tirada, y el resultado no debe repetirse siempre igual.

Problemas comunes

  • Un segmento no prende: revisa su resistencia (que comparta fila con el pin del display y con el cable al Nano) y que el cable vaya al pin correcto de la tabla.
  • Los números salen como símbolos raros: algún segmento está en otro pin. Compara la tabla de conexiones con tu display.
  • Todo el display se ve muy tenue o no prende: que el CC esté en el riel − y que el display sea de cátodo común (el de ánodo común trabaja al revés).
  • El botón no hace nada o tira solo: probablemente quedó en el lado equivocado del canal. En un botón de 4 pines, dos pines ya están unidos entre sí; usa pines de lados opuestos.
  • No sube el código: elige ATmega328P (Old Bootloader) y, si la computadora no ve el puerto, instala el driver CH340.
  • El buzzer no suena o suena muy bajito: que sea el pasivo (el código usa tone), con su pata + hacia D10.

Para mejorarlo

  • Dos dados: otro display de 7 segmentos (con más resistencias) para tirar dos dados y sumar.
  • Gráfica para la feria: copia los datos del Monitor Serie a una hoja de cálculo y haz una gráfica de barras de las tiradas.
  • Dado de pruebas: compara contra un dado de plástico de verdad con el mismo número de tiradas.

¿Te atoraste?

Escríbenos por WhatsApp con una foto de tus conexiones y te ayudamos.

Cookies

Usamos cookies para tu sesión y tu carrito, y Google Analytics y Microsoft Clarity para ver qué funciona en la tienda. Nada de publicidad. Aviso de privacidad