Kit Caça-Níqueis Alienígena com ATmega328P

Componentes e Materiais

Microchip ATmega328P-PU (2 unidades: uma para caça-níqueis, outra para display I2C escravo)	×	2
Display 7 segmentos 8 dígitos (saldo de créditos)	×	1
Matriz 8×8, 4 segmentos, MAX7219 (simula rolos; usa 3 das 4 matrizes)	×	1
LCD Serial I2C 20×4 Backlight Azul (menu de opções)	×	1
Protoboard 830 pontos (2 unidades)	×	2
Botões Momentâneos (1 giro, 3 navegação menu, 2 ground pin 1 ATmegas)	×	6
LED RGB Difuso Cátodo Comum (sinalização)	×	1
LED Genérico (indica alimentação)	×	1
Resistor 10 kΩ (pull-up botões e pin 1 ATmegas)	×	6
Resistor 1 kΩ (entre botões e pinos entrada ATmega)	×	4
Resistor 330 Ω (leads R, G, B do LED RGB)	×	3
Cristal 16 MHz (2 unidades: 16 MHz cada ATmega)	×	2
Chave Deslizante (liga/desliga alimentação)	×	1
Buzzer Passivo (2 unidades: um por ATmega)	×	2
Capacitor 22 pF (4 unidades: cristal)	×	4
Capacitor 0,1 µF (100 nF) (6 unidades: desacoplamento)	×	6
Capacitor 100 nF (opcional: se usar adaptador USB serial Arduino Mini)	×	1
Capacitor 10 µF (suavizar alimentação)	×	2
Regulador Linear 7805 (5 V)	×	1
Jumpers (boa quantidade)	×	1
Fonte 5 V	×	1
Adaptador Serial USB Arduino Mini (opcional: programar ATmega328P-PU)	×	1
Adaptador FTDI USB-TTL Serial (2×: programar in-circuit)	×	1
Protoboard Soldável Tamanho Completo	×	1
Protoboard Soldável Mini SparkFun	×	1
Solda 60/40 Rosin Core 0,8 mm	×	1
Caixa Projeto Plástico Transparente À Prova d'Água (gabinete final)	×	1

Ferramentas Necessárias

• Ferro de solda
• Mão de obra auxiliar (Helping Hands)

Aplicativos e Serviços Online

• Arduino IDE
• Timer Free Tone Library
• LED Control Library
• LiquidCrystal/LCD Library
• LiquidCrystal I2C Library

Sobre o Projeto

Caça-Níqueis Temático Alienígena com ATmega

Inspirado no Alien Invasion Slot Machine de Cory Potter, expandi a ideia. Dois ATmega328P-PU: um principal (lógica do jogo, 3 matrizes 8×8 como rolos, LCD 20×4, botões, buzzer, LED RGB) e um escravo I2C (display 7 segmentos 8 dígitos para saldo de créditos). Projeto educacional/entretenimento – simula caça-níqueis real o mais fiel possível. Atualmente em protoboard; gabinete chegará da China para soldagem final. Levou ~2 meses no tempo livre. Maior desafio: matemática para comportamento realista (probabilidades, tabela de pagamentos, índice de volatilidade) após centenas de milhões de simulações.

Como o Jogo Funciona

3 rolos com 25 símbolos únicos cada (uma das 4 matrizes 8×8 não usada). 5 formas de ganhar:

• 3 naves espaciais = Jackpot
• 1 ou 2 naves = prêmios menores
• 2 ou 3 símbolos iguais (exceto naves) = prêmios
• Combinação nave + 2 símbolos iguais: paga apenas o evento de menor probabilidade/maior prêmio (eventos mutuamente exclusivos).

Funcionalidades

Menu no LCD 20×4 I2C com 2 botões navegação + 1 seleção. Debounce sofisticado usando interrupção externa (PCINT). Menu principal (role para ver 6 itens):

• Jogar (também botão dedicado "Girar")
• Aposta (alterável a qualquer momento)
• Configurações
• Métricas
• Reset
• Vantagem da Casa (Hold)

Modo Automático: Selecione "Auto" no menu Configurações → jogo roda sozinho até desativar ou 1.000.000 jogadas. Essencial para testes. Também desliga som aqui.

Métricas: Visualize no LCD ou Monitor Serial (RX/TX via USB): saldo, jackpots, vitórias por tipo. Permitiu simulações para validar tabela de pagamentos. Tabela não configurável (fixa após definição). Volatilidade configurável exigiria mais trabalho.

Reset: Zera métricas (exceto escritas EEPROM). ATmega328 suporta ~100.000 escritas/endereço. Com 512 kB EEPROM e uso fracionário, seria possível mover endereços das métricas próximo ao limite – não implementei.

Hold (vantagem da casa %): Configurável no menu. Lembre: após Reset, reconfigure o Hold. Jurisdições limitam hold máximo (típico 15%). Hold alto pode afugentar jogadores; lucro depende mais de localização/design do jogo.

Saldo de créditos sempre no display 7 segmentos 8 dígitos (escravo I2C).

A Matemática

Muito trabalho para realismo. Probabilidades calculadas e tabela de pagamentos desenhada para Índice de Volatilidade (VI) aceitável. VI mede previsibilidade: VI alto = mais imprevisível (jogador ou casa ganham mais). Mesmo jogo em cassinos diferentes pode ter VIs diferentes (alterando pagamentos).

Probabilidades e pagamentos para aposta 1 crédito:

Cálculos:

• 3 Naves: 1 combinação vencedora / 25³ = 1/15625 = 0,000064. Odds 1:15624.
• 3 Símbolos Iguais (exceto naves): 24/15625 = 0,001536. Odds ~1:650.
• 2 Naves: 3 posições × 24 outros símbolos = 72/15625 = 0,004608. Odds ~1:216.
• 1 Nave: 3 rolos × 24² = 1728/15625 = 0,110592. Odds ~1:8.
• 2 Símbolos Iguais: 23 × 3 × 24 / 15625 = 0,105984. Odds ~1:8,44.

Usei planilha (3 abas) para ajustar pagamentos até VI < 20 e lucro esperado ≈ 0 (hold 0%). Defini THREE_SPACESHIP_PAYOUT, THREE_SYMBOL_PAYOUT, etc. no código. Rodei 5 simulações de 1.000.001 jogadas (hold 0%), comparei resultados reais com calculados – probabilidades bateram. Verifiquei intervalo de confiança 90% da renda (tabela "Understanding Potential Income").

Depois, hold 15% e mais 5 simulações – renda real dentro do esperado.

Planilha (senha "password") no código GitHub. Se achar erros, me avise – não sou matemático nem programador C de profissão.

O Código

Não farei linha a linha. Código extensamente comentado. Use a Força, leia a fonte. Para manipulação de registradores AVR sem biblioteca Arduino, recomendo livro Make: AVR Programming de Elliott Williams.

• Uso intensivo de variáveis globais – debate no Stack Overflow. Em projeto embarcado de programador único com recursos limitados, há argumentos fortes a favor.
• Bibliotecas essenciais:
  • LedControl (matrizes 8×8 e display 7 seg)
  • Timer Free Tone (buzzer piezo sem usar timers)
  • LiquidCrystal I2C + New LiquidCrystal (LCD 20×4)
• Estados da máquina (machineState): IDLE, SPINNING, AUTO, SHOW_MENU (não mutuamente exclusivos).
• Eventos despachados em ProcessEvents(). Fila de eventos seria melhor, mas não implementei.
• Defeitos conhecidos/TODOs no código: às vezes rolos não giram (RNG escolhe mesmo símbolo); rolos não param esquerda→direita (design choice); adicionar brown-out e watchdog; 80% RAM globais usada – instabilidade se adicionar mais.
• Símbolos desenhados por mim (alguns inspirados em Space Invaders). Em SlotMachine.h em binário para fácil edição.

Código no GitHub: github.com/danmurphy/ATmega-Alien-Slot-Machine

Construindo o Caça-Níqueis

Usei placa FTDI USB-Serial para programar ambos ATmega in-circuit (conexões não no esquemático Fritzing). Para configurar FTDI na protoboard: guia SparkFun. Coloque capacitor 100 nF em série entre pino 1 (reset) do ATmega e RTS do FTDI para auto-reset na programação. Alternativamente, use Arduino Uno como programador: tutorial oficial. Se comprar chips na China/eBay, precisará gravar bootloader – use AVRISP mkII, USBtinyISP ou o próprio Arduino Uno.

Peças

Se tiver componentes pequenos (resistores, capacitores, cristal, regulador), gasta < US$ 40. Com gabinete e perfboard, ~US$ 60. Fornecedores: AliExpress, Amazon, eBay. LCD 20×2 também serve – mude LCD_SCREEN_HEIGHT de 4 para 2. LCD deve ser I2C; se não, use módulo adaptador I2C PCF8574.

Gabinete encomendado (AliExpress, US$ 13,80): 37×37×15 cm, tampa transparente. Espero que caiba tudo sem furos na tampa. Sugestões bem-vindas.

Software

Instale todas as bibliotecas listadas na seção "Componentes" no Arduino IDE. Como instalar bibliotecas.

Ferramentas Manuais

• Ferro de solda
• Mão de obra auxiliar (Helping Hands)

Esquemático

Esquemático Fritzing disponível no GitHub (arquivo .fzz incluso). Abaixo, guias de ligação (o Fritzing fica lotado):

Caça-Níqueis (Mestre)

• Pino 1 – RTS FTDI, botão reset
• Pino 2 – TXD FTDI
• Pino 3 – RXD FTDI
• Pino 4 – 1kΩ → botão "Girar"
• Pino 5 – 330Ω → LED RGB azul
• Pino 6 – livre (considere ground)
• Pino 7 VCC – rail alimentação, 0,1µF
• Pino 8 GND – rail terra, 0,1µF
• Pino 9 XTAL1 – cristal 16 MHz, 22pF → terra
• Pino 10 XTAL2 – cristal 16 MHz, 22pF → terra
• Pinos 11-13 – livres (ground)
• Pino 14 – DIN matrizes 8×8
• Pino 15 – 330Ω → LED RGB vermelho
• Pino 16 – 330Ω → LED RGB verde
• Pino 17 – Buzzer + (– → terra)
• Pino 18 – CS matrizes
• Pino 19 – CLK matrizes
• Pino 20 AVCC – rail alimentação, 0,1µF
• Pino 21 AREF – rail alimentação
• Pino 22 GND – rail terra
• Pino 23 – flutuante (seed RNG)
• Pino 24 – 1kΩ → botão "Navegar ↑"
• Pino 25 – 1kΩ → botão "Navegar ↓"
• Pino 26 – 1kΩ → botão "Selecionar"
• Pino 27 SDA – Pino 27 SDA escravo I2C
• Pino 28 SCL – Pino 28 SCL escravo I2C

Display Escravo (Créditos)

• Pino 1 – RTS FTDI, botão reset
• Pino 2 – TXD FTDI
• Pino 3 – RXD FTDI
• Pinos 4-6 – livres (ground)
• Pino 7 VCC – rail alimentação, 0,1µF
• Pino 8 GND – rail terra, 0,1µF
• Pino 9 XTAL1 – cristal 16 MHz, 22pF → terra
• Pino 10 XTAL2 – cristal 16 MHz, 22pF → terra
• Pinos 11-14 – livres (ground)
• Pino 15 – Buzzer + (– → terra)
• Pino 16 – CS display 7 seg
• Pino 17 – CLK display 7 seg
• Pino 18 – DIN display 7 seg
• Pino 19 – livre (ground)
• Pino 20 AVCC – rail alimentação, 0,1µF
• Pino 21 AREF – rail alimentação
• Pino 22 GND – rail terra
• Pinos 23-26 – livres (ground)
• Pino 27 SDA – Pino 27 SCA mestre
• Pino 28 SCL – Pino 28 SCL mestre

Resumo

Projeto muito divertido. Maior desafio: matemática para tabela de pagamentos funcional. Espero que se divirtam construindo. Problemas, dúvidas ou defeitos no código/matemática: dan-murphy@comcast.net. Farei Parte II quando enclausurar tudo.

Código

• SlotMachine.ino (principal)
• SlotMachine.h (símbolos, notas musicais, constantes)
• slotCreditsDisplaySlave.ino (escravo I2C display 7 segmentos)

SlotMachine.ino (trecho)

/* SlotMachine.ino v1.0 2018/07/01-2018/08/29 ATmega328P-PU @16MHz C
   Caça-níqueis educacional/entretenimento com:
   - ATmega328P @16MHz
   - Display 7 seg 8 dígitos I2C escravo (ATmega328P @16MHz, código separado)
   - 3 matrizes 8×8 LED MAX7219 (rolos)
   - LCD I2C 20×4 (menus)
   - Buzzer, botões, LED RGB
   - Configurações via menu LCD
   - Aposta ajustável
   Defeitos: às vezes rolos não giram; crash se payout > 1.000.000.
   TODO: brown-out detection, watchdog.
   Avisos: debug excessivo gasta RAM; jogo retorna ~hold% à casa.
   Autor: Daniel Murphy 
   Licença: GPL v3+
   Bibliotecas: LedControl, TimerFreeTone, LiquidCrystal_I2C, Wire
*/
#include 
#include 
#include 
#include "LedControl.h"
#include "SlotMachine.h"
#include 
#include 
#include 
#include 

// Tabela de pagamentos (hold 0%, VI=16.43)
#define THREE_SPACESHIP_PAYOUT 600
#define THREE_SYMBOL_PAYOUT 122
#define TWO_SPACESHIP_PAYOUT 50
#define ONE_SPACESHIP_PAYOUT 3
#define TWO_SYMBOL_PAYOUT 2

// ... (código completo no GitHub)

SlotMachine.h (trecho – símbolos e notas)

const byte reel[] = {
  // 0 estrela
  B10011001, B01011010, B00111100, B11111111, B11111111, B00111100, B01011010, B10011001,
  // 1 um ponto no dado
  B00000000, B00000000, B00000000, B00011000, B00011000, B00000000, B00000000, B00000000,
  // 2 três barras
  B11111111, B11111111, B00000000, B11111111, B11111111, B00000000, B11111111, B11111111,
  // ... (25 símbolos de 8 bytes cada)
  // 18 Nave Espacial (índice 144)
  B00000000, B00000000, B00111100, B01111110, B10101011, B01111110, B00111100, B00000000,
  // ... demais símbolos
};

#define NOTE_B0 31
#define NOTE_C1 33
// ... até NOTE_DS8 4978

slotCreditsDisplaySlave.ino (trecho)

/* slotCreditsDisplaySlave.ino v1.0 2018/07/01-2018/07/29 ATmega328P-PU @16MHz C
   Escravo I2C para display 7 segmentos 8 dígitos (saldo créditos)
*/
#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)