Kit de máquina tragaperras alienígena ATmega328P

Componentes y suministros

Microchip ATmega328P-PU	×	2	Uno para la SlotMachine, otro para el esclavo I2C de display de 7 segmentos.
Display 7 segmentos 8 dígitos	×	1	Para mostrar el saldo de créditos del jugador.
Matriz 8x8, 4 segmentos, MAX7219	×	1	Para simular rodillos giratorios y mostrar símbolos. Solo se usan 3 de los 4 segmentos.
Módulo LCD I2C 2004 Serial Blue Backlight 20x4	×	1	Para mostrar menú de opciones. Busca en AliExpress, no pagues envío.
Protoboard (genérica) 830 puntos	×	2	~4$ cada una.
Pulsadores momentáneos	×	6	Uno controla giro de rodillos, tres para navegar menú, dos para poner a masa pin 1 de los ATmega.
LED RGB difuso cátodo común	×	1	Para señalizar varios estados.
LED (genérico)	×	1	Indica si hay alimentación en las placas.
Resistencia 10k Ω	×	6	4 para pull-up de botones, 2 para pin 1 de los ATmega.
Resistencia 1k Ω	×	4	Entre cada botón y pines de entrada del ATmega.
Resistencia 330 Ω	×	3	Para pines rojo, verde y azul del LED RGB.
Cristal 16 MHz	×	2	Uno para ATmega de SlotMachine, otro para esclavo display. Ambos a 16MHz.
Interruptor deslizante	×	1	Para la alimentación.
Zumbador (buzzer)	×	2	Uno para chip SlotMachine, otro para esclavo display. Sería bueno modificar circuito para compartir uno solo.
Condensador 22 pF	×	4
Condensador 0.10 µF	×	6
Condensador 100 nF	×	1	Opcional, solo si usas adaptador serie USB Arduino Mini para programar el chip SlotMachine.
Condensador 10 µF	×	2	Para suavizar voltaje de alimentación.
Regulador lineal 7805	×	1	Regula voltaje a 5V.
Cables jumper (genéricos)	×	1	Necesitarás buena cantidad. Hago los míos, pero también uso jumpers.
Fuente 5V	×	1
Adaptador serie USB Arduino Mini	×	1	Opcional, puedes usar tu Arduino Uno para programar los ATmega328P-PU.
Adaptador FTDI USB a TTL Serie	×	1	Para programar los ATmega328P-PU in situ. No aparece en el esquemático.
Protoboard soldable (tamaño completo)	×	1
SparkFun Protoboard soldable Mini	×	1
Estaño 60/40 Rosin Core 0.031"	×	1
Caja de proyecto plástica transparente impermeable	×	1	Esta es la carcasa.

Herramientas necesarias

• Soldador (genérico)
• Tercera mano (Helping Hands)

Aplicaciones y servicios en línea

• Arduino IDE
• Librería Timer Free Tone
• Librería LED Control
• Librería LiquidCrystal/LCD
• Librería LiquidCrystal I2C

Sobre el proyecto

Máquina tragaperras temática alienígena con ATmega

Este proyecto es mi implementación de una máquina tragaperras temática alienígena usando dos microcontroladores ATmega328P-PU. Me inspiré en la Alien Invasion Slot Machine de Cory Potter y quise expandir esa idea. La máquina es solo para entretenimiento y fines educativos. Intenté hacer que el juego simule una máquina tragaperras real lo más fielmente posible. El proyecto está actualmente en protoboard. Se añadirá carcasa en cuanto lleguen las piezas de China y haya tenido tiempo de soldar todo. Me llevó unos dos meses en mi tiempo libre. La parte más difícil fue entender toda la matemática necesaria para que el juego se comporte como la industria del casino esperaría de una máquina tragaperras simple tras cientos de millones de simulaciones.

Cómo funciona el juego

El juego tiene tres rodillos con los mismos 25 símbolos únicos en cada rodillo (una de las 4 matrices 8x8 del componente no se usa). Hay cinco formas de ganar:

• Tres naves espaciales → Jackpot.
• Una o dos naves espaciales → gana algunos créditos.
• Dos o tres símbolos iguales (excepto naves) → gana créditos.
• Si sale una nave y dos símbolos iguales (como en la imagen), el juego paga según el evento ganador de menor probabilidad/mayor premio; es decir, los eventos ganadores son mutuamente excluyentes, no puedes ganar de dos formas distintas en una misma tirada. Esto simplificó la programación.

Características

La máquina tiene varias características interesantes accesibles vía display LCD I2C 20x4 usando dos botones de navegación y uno de selección. Los botones usan un algoritmo de anti-rebote sofisticado que aprovecha la capacidad de interrupción externa del microcontrolador. Este es el menú principal.

Como hay seis líneas en el menú, debes bajar con el botón «navigate down» para verlo completo. Hay un botón dedicado a «girar» los rodillos. Además, también puedes seleccionar «Play» del menú principal. Puedes cambiar tu apuesta en cualquier momento.

La característica más emocionante es el «modo auto»: seleccionas la opción auto en el menú de ajustes del LCD y el juego juega una y otra vez hasta que vuelves a seleccionar la opción o se alcanzan 1 millón de jugadas. Es crítico para testear el juego. También puedes desactivar el sonido aquí.

Desde el menú del LCD también puedes ver todas las métricas generadas por la simulación. Estas métricas también se muestran en el monitor serie si conectas tu microcontrolador via pines RX/TX con cable USB. La lista incluye: saldo de créditos, veces que hitteaste el jackpot, veces que ganaste créditos por otros medios. Esto me permitió correr simulaciones con distintas tablas de pagos y establecer/probar la tabla de pagos. La tabla de pagos no es configurable; una vez fijada debe permanecer igual. Sería posible hacer configurable el índice de volatilidad usándolo para impulsar las tablas de pagos, pero requeriría mucho más trabajo.

La opción Reset permite reiniciar todas las métricas (excepto escrituras en EEPROM) a cero. El chip aguanta unas 100.000 escrituras en EEPROM. Como hay 512k de EEPROM y usamos solo una fracción, sería posible mover la ubicación de las métricas en EEPROM conforme nos acerquemos a 100.000 escrituras. No he implementado esto pero sería una forma de alargar la vida del chip.

Finalmente, el «hold» (porcentaje de cada apuesta que se queda la casa a largo plazo) es configurable. Recuerda que tras un Reset el hold debe volver a configurarse.

El saldo de créditos del jugador siempre se muestra en el display de 7 segmentos de 8 dígitos.

La matemática

Mucho trabajo se dedicó a asegurar que el juego fuera realista. Se calcularon las probabilidades y se diseñó la tabla de pagos para que el juego tenga un Índice de Volatilidad (VI) aceptable. Este índice mide qué tan predecible es el comportamiento de la máquina. Una máquina con VI alto hace que el jugador (o la casa) gane más dinero de forma menos predecible. Es cierto que el mismo juego existe en distintos casinos con distintos VIs. El VI se cambia manipulando la tabla de pagos. Para nuestro juego, aquí están las probabilidades y pagos para cada tipo de ganancia:

Observa que las odds (extrema derecha) y el payout (extrema izquierda) son dramáticamente diferentes. Si el juego se programara para que la tabla de pagos siguiera de cerca las odds, su VI sería inaceptablemente alto. El hold se calcula como porcentaje del payout, y es la parte de la apuesta que se queda la casa. Como dijiste, puedes configurar el hold vía menú LCD. Ten en cuenta que distintas jurisdicciones tienen regulaciones distintas sobre el hold máximo permitido. Un hold máximo típico es 15%. Entiende que fijar el hold al máximo legal no necesariamente maximiza el beneficio de la máquina, porque un hold más alto podría disuadir a los jugadores. Sospecho que muchos jugadores ignoran el hold, típicamente en letra pequeña, y que la curva de demanda es relativamente vertical (el coste de uso, el hold, se ignora en gran medida), y que el beneficio depende más de la ubicación y el diseño del juego. Pero es solo especulación.

La hoja de cálculo (disponible con el código) con tres tablas se construyó para probar que el juego funciona correctamente (la primera tabla aparece arriba). El primer paso fue calcular exactamente las odds de cada tipo de ganancia (columnas Calculated Probability).

Tres naves espaciales

La probabilidad de que aparezcan tres naves es la inversa del total de combinaciones posibles. Combinaciones ganadoras: 1. Total combinaciones: 15625 (25³). Probabilidad = 1/15625 = 0,000064. Odds = 1/probabilidad - 1 = 1 a 15624.

Tres símbolos iguales (excepto naves)

Probabilidad = 24 (símbolos no nave) / 15625 = 0,001536. Odds ≈ 1 a 650,04.

Dos naves espaciales

Combinaciones: 24 (valores para el tercer símbolo) × 3 (posiciones de las dos naves: XXY, XYX, YXX) = 72. Probabilidad = 72/15625 = 0,004608. Odds = 1 a 216,01.

Una nave espacial aparece

Para cada rodillo hay 24×24 combinaciones para una sola nave. La nave puede aparecer en cualquiera de los 3 rodillos: 24×24×3 / 15625 = 0,110592. Odds = 1 a 8,04.

Dos símbolos iguales

Para cualquier par de símbolos (excepto naves): 23 (símbolos que no son nave ni el que haría triple) × 3 rodillos × 24 símbolos no nave = 1656. Probabilidad = 1656/15625 = 0,105984. Odds = 1 a 8,44.

Con estas probabilidades uso la hoja de cálculo para diseñar la tabla de pagos de forma que el VI sea aceptable (< ~20). Me basé en este post. Fui probando valores en la columna House Income de la primera tabla hasta que el VI quedó bajo 20 y el Total en celda J10 lo más cerca de cero posible. Esos valores los usé para definir los #define de pagos en SlotMachine.ino. Luego, con hold 0%, corrí 5 simulaciones de 1.000.001 jugadas y metí los valores del menú de métricas en la tabla Actual Results (tercera tabla).

Observé que las Probabilidades Actuales seguían de cerca a las Calculadas, y que la columna Pct Diff Prob era razonable. También comparé los valores de la fila House Pays con el rango de Income High/Low de la fila 1.000.000 de la tabla Understanding Potential Income (segunda tabla), y vi que los valores reales estaban dentro del rango. Esa tabla define el rango esperado de ingresos para un hold dado con intervalo de confianza 90%. En el ejemplo hold=0, así que ganar y perder son equiprobables. En 1 millón de jugadas hay 90% de probabilidad de que los ingresos estén entre 16.432 y -16.432.

Tras trabajar con la hoja de cálculo y el programa y correr millones de simulaciones, pude corregir defectos en el programa, ajustar la hoja de cálculo y definir valores de tabla de pagos que mantienen VI < 20. Finalmente cambié el hold a 15% y corrí otras 5 simulaciones para verificar que los ingresos del juego se alinean con expectativas si se desplegara en situación real. Aquí la tabla de ingresos para hold 15%.

Y aquí los resultados reales.

Si quieres entender toda la matemática detrás de los valores de pago, te animo a examinar las fórmulas en la hoja de cálculo. Si encuentras errores, por favor indícalos; no soy matemático ni programador C de oficio, así que se aplica la exención de responsabilidad estándar.

El código

No voy a explicar el código línea por línea. Está extensamente comentado y no hay trucos. Usa la Fuerza, lee la fuente. Si no estás familiarizado con la manipulación de registros del ATmega328 y quieres entender cómo programar AVR sin depender de la librería Arduino, te recomiendo el excelente libro de Elliott Williams «Make: AVR Programming». Si tienes suscripción a safaribooksonline.com, lo tienes ahí. Si no, en Amazon. En estos programas uso funciones Arduino en algunos sitios y manipulo registros directamente en otros. Disculpa por eso.

Lo primero que notarás es el uso extensivo de variables globales. Hay buena discusión en Stack Overflow. No voy a promover ni defender su uso intensivo, pero te animo a entender todas las perspectivas y reconocer que hay un fuerte argumento para usarlas en una aplicación embebida con un solo programador y recursos limitados.

Uso algunas librerías sin las cuales este proyecto habría sido imposible para mí:

• Timer Free Tone Library: genera varias frecuencias por el zumbador piezoeléctrico pasivo. En SlotMachine.h hay defines para notas musicales; úsalas para componer melodías. Solo uso unas pocas para tocar parte del tema de «Encuentros en la tercera fase» al arrancar.
• LED Control Library: usada en ambos SlotMachine.ino y slotCreditDisplaySlave.ino. En el primero controla las tres matrices 8x8 que sirven como rodillos. En el segundo facilita el acceso al display de 7 segmentos de 8 dígitos que muestra el saldo. Intenté evitar otro chip AVR solo para el saldo, pero no encontré forma de controlar matrices 8x8 y display 7 segmentos desde un solo microcontrolador. Así que creé un esclavo I2C para ese propósito. Podrías usar un AVR más barato, pero para simplificar usé otro ATmega328P-PU. Ventaja: al ganar un gran jackpot los créditos siguen contando en el display esclavo mientras puedes volver a girar.
• LiquidCrystal/LCD y LiquidCrystal I2C: necesarias para el display LCD 20x4. Puedes sustituir por un 20x2 cambiando LCD_SCREEN_HEIGHT de 4 a 2. Asegúrate que tu LCD sea I2C; si no, necesitas un módulo adaptador I2C SPI PCF8574 y soldarlo a tu LCD1602.

El juego puede estar en varios estados a la vez; la variable machineState los rastrea. Por ejemplo, puede estar «girando» y en «modo auto» a la vez. No hago uso intensivo de esto, pero hay ramificaciones condicionales basadas en el estado. También existe el concepto de eventos, despachados y manejados en ProcessEvents. Probablemente sería mejor una cola de eventos, pero no llegué tan lejos.

Hay lista de defectos conocidos y «to-dos» en los comentarios de SlotMachine.ino. A veces al «girar» (botón spin o «Play» del menú) uno o dos rodillos no se mueven. Porque el generador aleatorio eligió el símbolo que ya se muestra en ese rodillo. Podría arreglarse para parecer más realista, pero no es realmente un defecto. Los rodillos no terminan de girar de izquierda a derecha como en la mayoría de tragaperras. Es por diseño, para simplificar. Sería posible ordenar los tres números aleatorios generados por tirada en orden ascendente antes de girar, pero no me molesté.

Como «to-dos», me gustaría añadir protección contra brown-out y watchdog, solo por el ejercicio de aprender. Nota que el 80% del espacio para variables globales ya está consumido. Es el punto donde la cosa puede volverse inestable con ATmega328 y programas Arduino. Estamos en ese punto. He tenido que hacer presupuestos para mantener las cosas funcionando, y no recomendaría añadir más globales. Esto dificultaría añadir más funcionalidad al menú Settings, por ejemplo, porque el menú consume mucho espacio de variables globales. Intenté mover los menús a memoria de programa, pero no redujo el espacio usado por globales, creo que porque el compilador pre-asigna todo el espacio para los menús. Se podría mejorar el juego: más uso del LED RGB y zumbador, celebrar victorias, mejor sonido al perder, pero lo dejo a quien quiera trastear.

Tuve que diseñar todos los símbolos del juego. Algunos recuerdan al arcade clásico «Space Invaders», y puede que los tomara de algún lado. El resto los diseñé a mano, y algunos son poco profesionales. Usé este sitio para ayudar a diseñar los símbolos. Si quieres ajustar símbolos, hazlo en SlotMachine.h y juega con ellos; no afecta la lógica. Represento los números en base 2 / binario para diseñarlos con editor de texto.

El código está disponible en GitHub.

Construyendo la máquina tragaperras

Usé una placa FTDI USB-serie para programar ambos ATmega328P-PU in situ. Esas conexiones no aparecen en el esquemático Fritzing. Para instrucciones de montaje del FTDI breakout en tu protoboard sin soldar, sigue este enlace. Puede que necesites googlear un poco para afinar la configuración. Creo que este post también me ayudó a solucionar un problema para que el microcontrolador se reiniciara automáticamente al iniciar la programación vía FTDI. Recuerda poner un condensador de 100 nF en serie entre el pin reset del ATmega328 (posición 1/PC6/reset) y RTS del FTDI breakout para no tener que mantener pulsado reset al programar. Si eliges usar tu Arduino Uno para programar los chips, las instrucciones están aquí. Si solo vas a programar una vez con el código suministrado, probablemente sea más rápido y fácil programarlos desde el Arduino Uno.

Ambos microcontroladores están montados con el chip «Arduino» (ATmega328P-PU) en protoboard. Si planeas soldar los componentes finalmente, o solo quieres copiar lo que hice en protoboard, querrás entender cómo montar Arduino en protoboard. Sigue las excelentes instrucciones aquí. Esas instrucciones incluyen el procedimiento para cargar el bootloader de Arduino en los dos chips, que probablemente necesitarás si compras los chips de un proveedor chino o vía eBay, como se sugiere en la lista de piezas. Para eso necesitarás un programador AVR como AVRISP mkII o USBTiny ISP. También puedes usar tu Arduino, si tienes uno, para grabar el bootloader. Todas las opciones se explican en el enlace.

Piezas

Si ya tienes algunos componentes pequeños en tu inventario (resistencias, condensadores, cristal, regulador) puedes gastar < $40 en piezas. Sumando carcasa y placa perforada, se acerca a $60. He intentado incluir el proveedor que usé para cada pieza. Uso AliExpress, Amazon y eBay para la mayoría de piezas y herramientas, y todas son fácilmente localizables en esos sitios. También, si no quieres comprar display LCD 20x4 y ya tienes uno 20x2, simplemente cambia LCD_SCREEN_HEIGHT en SlotMachine.ino de 4 a 2.

Aquí está la carcasa que pedí, en la que meteré los componentes:

Disponible aquí por $13.80. Un poco caro en mi opinión. Espero que todo quepa y que la tapa sea muy transparente para no tener que cortar agujeros para ver los rodillos y el display de créditos. ¡Ya veremos cuando llegue! Sugerencias bienvenidas.

Software

Todas las librerías listadas en la sección de piezas deben instalarse en tu entorno de desarrollo Arduino si quieres compilar el código para subirlo a tu chip ATmega. Esta página explica cómo instalar una librería Arduino.

Herramientas manuales

• Soldador
• Tercera mano (Helping Hands)

Esquemático

El esquemático Fritzing está disponible aquí, y el archivo .fzz se incluye con el código en GitHub.

A continuación incluyo algunas indicaciones de cableado de los microcontroladores, porque el diagrama Fritzing está saturado. No representa todas las conexiones necesarias, pero debería aclarar dudas. No he puesto a masa todos los pines no usados, pero probablemente lo haré en el producto final. Si tienes problemas siguiendo el diagrama Fritzing respecto al circuito de alimentación, recuerda mirar aquí, bajo Adding circuitry for a power supply. Recuerda poner el interruptor entre el rail de masa de la protoboard y el circuito de alimentación para poder encender/apagar sin desconectar la fuente. Eso será importante al meter todo en la carcasa.

Slot Machine (maestro)

• Pin 1 – RTS en FTDI USB-Serie breakout, botón reset
• Pin 2 – TXD en FTDI
• Pin 3 – RXD en FTDI
• Pin 4 – Resistencia 1k Ω – botón momentáneo «spin»
• Pin 5 – Resistencia 330 Ω – pin azul LED RGB
• Pin 6 – sin usar, considerar poner a masa
• Pin 7 VCC – rail alimentación protoboard, condensador 0.1µF
• Pin 8 GND – rail masa protoboard, condensador 0.1µF
• Pin 9 XTAL1 – Cristal 16MHz, condensador 22pF a masa
• Pin 10 XTAL2 – Cristal 16MHz, condensador 22pF a masa
• Pin 11 – sin usar, considerar masa
• Pin 12 – sin usar, considerar masa
• Pin 13 – sin usar, considerar masa
• Pin 14 – DIN en matrices 8x8
• Pin 15 – Resistencia 330 Ω – pin rojo LED RGB
• Pin 16 – Resistencia 330 Ω – pin verde LED RGB
• Pin 17 – Zumbador piezo positivo – negativo zumbador a masa
• Pin 18 – CS en matrices 8x8
• Pin 19 – CLK en matrices 8x8
• Pin 20 AVCC – rail alimentación, condensador 0.1µF
• Pin 21 AREF – rail alimentación
• Pin 22 GND – rail masa
• Pin 23 – dejar flotante, usado para semilla generador aleatorio
• Pin 24 – Resistencia 1k Ω – botón momentáneo «navigate up»
• Pin 25 – Resistencia 1k Ω – botón momentáneo «navigate down»
• Pin 26 – Resistencia 1k Ω – botón momentáneo «select»
• Pin 27 SDA – Pin 27 SDA en esclavo I2C display ATmega328P-PU
• Pin 28 SCL – Pin 28 SCL en esclavo I2C display ATmega328P-PU

Display Slave (esclavo)

• Pin 1 – RTS en FTDI USB-Serie breakout, botón reset
• Pin 2 – TXD en FTDI
• Pin 3 – RXD en FTDI
• Pin 4 – sin usar, considerar masa
• Pin 5 – sin usar, considerar masa
• Pin 6 – sin usar, considerar masa
• Pin 7 VCC – rail alimentación, condensador 0.1µF
• Pin 8 GND – rail masa, condensador 0.1µF
• Pin 9 XTAL1 – Cristal 16MHz, condensador 22pF a masa
• Pin 10 XTAL2 – Cristal 16MHz, condensador 22pF a masa
• Pin 11 – sin usar, considerar masa
• Pin 12 – sin usar, considerar masa
• Pin 13 – sin usar, considerar masa
• Pin 14 – sin usar, considerar masa
• Pin 15 – Zumbador piezo positivo – negativo a masa
• Pin 16 – CS en display 7 segmentos
• Pin 17 – CLK en display 7 segmentos
• Pin 18 – DIN en display 7 segmentos
• Pin 19 – sin usar, considerar masa
• Pin 20 AVCC – rail alimentación, condensador 0.1µF
• Pin 21 AREF – rail alimentación
• Pin 22 GND – rail masa
• Pin 23 – sin usar, considerar masa
• Pin 24 – sin usar, considerar masa
• Pin 25 – sin usar, considerar masa
• Pin 26 – sin usar, considerar masa
• Pin 27 SDA – Pin 27 SDA en maestro Slot Machine ATmega328P-PU
• Pin 28 SCL – Pin 28 SCL en maestro Slot Machine ATmega328P-PU

Resumen

Este proyecto fue muy divertido de construir. La parte más desafiante fue entender toda la matemática necesaria para crear una tabla de pagos que funcione. Espero que tú también te diviertas si decides construirlo. Si tienes problemas, preguntas, o, lo más importante, descubres defectos en el código o en la matemática, ¡contáctame para que pueda arreglarlos! Mi email: dan-murphy@comcast.net. Crearé la parte II de este artículo cuando encierre todos los componentes.

Código

• SlotMachine.ino
• SlotMachine.h
• slotCreditsDisplaySlave.ino

SlotMachine.ino Arduino

(Código completo disponible en GitHub. Aquí se muestra el inicio truncado.)

/*SlotMachine.ino Version: 1.0 Date: 2018/07/01 - 2018/08/29 Device: ATMega328P-PU @ 16mHz Language: C
Purpose ======= Máquina tragaperras para entretenimiento y fines educativos únicamente, con:
- ATmega328P a 16MHz
- Display I2C 7 segmentos personalizado para saldo, también con ATmega328P a 16MHz (programa aparte)
- Tres matrices 8x8 LED驱动 por MAX7219
- Display LCD I2C 20x4 para menús
- Varios zumbadores, botones y LED RGB
- Capacidad de actualizar ajustes vía menú LCD
- Cambio de apuesta
Known Defects ============= - A veces uno o dos rodillos no giran (no es defecto real). - Crash si payout supera 1,000,000.
TODO ==== - añadir detección brown-out - añadir watchdog protection
Warnings ======== - Cuidado con activar mucho debugging, agota memoria de datos y vuelve inestable el micro.
- El juego está diseñado para devolver ~%hold de cada apuesta a la casa.
- Por qué no usar LedControl para el display de créditos? Intenté y no pude hacer funcionar más de un objeto LedControl a la vez. Tuve que crear esclavo I2C y usar otro AVR.
Suggestions =========== - Mejor visto en editor con 160 columnas.
- Por favor reporta defectos para mejorar calidad y aprender más.
Author ====== - Copyright 2018, Daniel Murphy <dan-murphy@comcast.net>
- Colaboradores: Código fuente de todo internet, imposible citar todos. Gracias a Elliott Williams por "Make: AVR Programming". Gracias a Cory Potter por la idea.
License ======= Daniel J. Murphy renuncia a todo copyright. Software libre bajo GPL v3 o posterior.
Libraries ========= - https://github.com/wayoda/LedControl
- https://bitbucket.org/teckel12/arduino-timer-free-tone/wiki/Home
- https://github.com/fdebrabander/Arduino-LiquidCrystal-I2C-library
- https://bitbucket.org/fmalpartida/new-liquidcrystal/wiki/Home
*/
#include 
#include 
#include 
#include "LedControl.h"
#include "SlotMachine.h"
#include 
#include 
#include 
#include 
// ... (resto del código truncado, descarga completo desde GitHub)

SlotMachine.h Archivo cabecera C

(Define símbolos, notas musicales, etc. Ver archivo completo en GitHub.)

const byte reel[] = { // 25 símbolos de 8x8 cada uno (8 bytes por símbolo)
// 0 estrella, 1 dado 1 punto, 2 tres barras, 3 corazón, 4 dado 2 puntos, 5 siete, 6 signo $, 7 dado 3 puntos,
// 8 hashtag inverso, 9 una barra, 10 dado 4, 11 siete inverso, 12 9 puntos, 13 dado 5, 14 dos barras,
// 15 Alien 0, 16 carita sonriente, 17 dado 6, 18 Nave espacial, 19 Alien 1, 20 Alien 2, 21 Alien 3,
// 22 uno, 23 dos, 24 tres
... (datos binarios de cada símbolo)
};
// Definición de notas musicales (NOTE_B0 = 31 Hz ... NOTE_DS8 = 4978 Hz)
#define NOTE_B0 31
#define NOTE_C1 33
... // hasta NOTE_DS8 4978

slotCreditsDisplaySlave.ino Arduino

(Código del esclavo I2C para display 7 segmentos. Ver completo en GitHub.)

/*slotCreditsDisplaySlave.ino Version: 1.0 Date: 2018/07/01 - 2018/07/29 Device: ATMega328P-PU @ 16mHz
Purpose ======= Esclavo I2C para mostrar créditos en máquina tragaperras
*/
#include 
#include "LedControl.h"
#define BAUD_RATE 38400
#define CREDITS_SLAVE_ADDR 16
#define DISPLAY_DELAY 5
#define DEBUG 1
#define BUZZER_DDR DDRB
#define BUZZER_PORT PORTB
#define BUZZER_PIN DDB1
#define TONE_PIN 9
#define BEEP_LENGTH 100
LedControl lc = LedControl(12, 11, 10, 1); // DIN, CLK, LOAD, 1 chip
static const int slaveAddress = CREDITS_SLAVE_ADDR;
long volatile theCredits[10] = {0};
signed long volatile displayedBalance = 0;
signed long volatile startingCreditBalance = 0;
signed long volatile endingCreditBalance;
signed int volatile increment;
boolean volatile updateDisplayFlag = false;
// ... setup, loop, receiveEvent, showBalance, scrollDigits, etc.

Esquemáticos

slotmachine_1nXzMvYVPH.fzz

Esta hoja de cálculo se usó para probar que la tabla de pagos es correcta. Contraseña de la hoja: «password».

slotpayouttablecalc_v1_1_SfcpHOBOvf.xlsx

Close Encounters Slot Machine

Enlace a archivos en Fritzing.org

Esquemáticos en Fritzing.org