Construa seu Próprio Monstro na Caixa: Projeto de Robótica com Arduino
Componentes e Materiais
| Componente | Quantidade |
|---|---|
| Caixa de madeira (crate) | 1 |
| Arduino UNO | 1 |
| Adafruit Wave Shield | 1 |
| Módulo Relé 4 Canais SainSmart | 1 |
| Motor de limpador de para-brisa (12V) | 1 |
| Luzes de Natal LED vermelhas (100 unidades) | 1 |
| Máquina de fumaça (400W) | 1 |
| Amplificador/Speaker alimentado (30W) | 1 |
Sobre o Projeto
*** Atualizado para Versão 4 ***
Recentemente reescrevi o código do Arduino para este projeto. Resumo das alterações:
- Loop principal implementado como máquina de estados (state machine)
- Todo temporização baseada em comparação entre tempo do evento e tempo atual
- Temporização não depende mais de frames
- Removido
delay()do loop principal - Eliminado problema de "porta ocupada" ao conectar na IDE do Arduino
- Relés agora usam contatos Normalmente Abertos (NO) em vez de Normalmente Fechados (NC) — *** Atualize suas conexões de relé! ***
- Adicionado LED de Movimento Detectado
- Adicionado LED de Pronto para Acordar
- Adicionado LED de Pausado
- Removido interruptor de gatilho de ação
- Adicionada capacidade de estender tempo das luzes vermelhas e fumaça
- Adicionados muitos comentários no código
Todo o código mais recente está disponível no GitHub.
Monstro na Caixa
Adoro adereços de Halloween e vi várias construções incríveis de "Monstro na Caixa" no ano passado. A ideia é simples: criar a ilusão de que um recipiente guarda um monstro perigoso prestes a escapar. A ilusão combina movimento, som, luz, fumaça e, claro, susto.
O que tem na Caixa?!
Você precisa de uma caixa grande o suficiente para parecer capaz de guardar algo grande e assustador. O aspecto envelhecido e desgastado reforça a ilusão de que a caixa mal contém a criatura. Como não encontrei uma caixa pronta ideal, construí a minha.
Usei 15 ripas de pinho de 1,8m (Home Depot) para fazer uma caixa de aprox. 90cm x 75cm x 75cm. Cortei as tábuas na serra de mesa e montei com pregador pneumático de 18 gauge. Depois percebi que os pregos não aguentavam o tranco da tampa batendo, então reforcei com parafusos de drywall de 1 polegada (por dentro para não aparecer).
Envelheci a madeira com chá preto, vinagre e lã de aço. Decorei com estênceis e rótulos impressos.

O Cérebro!!!
O adereço tem dois estados operacionais: "Dormindo" e "Acordado". No modo sono, a caixa fica relativamente calma, emitindo apenas sons de ronco e rosnados leves. O monstro acorda quando um sensor de movimento (PIR) detecta alguém. Ao acordar, o monstro ruge, solta fumaça, a tampa salta e o interior brilha em vermelho.
Usei um Arduino UNO com Wave Shield e Módulo Relé para orquestrar tudo. O Wave Shield armazena sons de sono e rugidos. O sensor PIR alterna entre os modos. No modo acordado, o Arduino aciona canais do relé para: motor da tampa, luzes vermelhas, gerador de fumaça e sons no Wave Shield. Adicionei também um botão de Pausa para silenciar temporariamente o monstro quando crianças pequenas passam.

Está Viiiiivo!
O levantador de tampa faz a tampa subir e descer rapidamente, simulando o monstro tentando escapar. As opções mais populares são atuadores pneumáticos e cames rotativos. Embora um atuador pneumático permitisse movimentos mais aleatórios, escolhi o came rotativo por ser mais simples e barato.
Comprei um motor de limpador de para-brisa usado em um ferro-velho por $15. Esses motores funcionam a 12V, têm bom torque e velocidade adequada. Dica: certifique-se de que vem com chicote de fios, braço de manivela e pino excêntrico; senão o came escorrega.
Montei o motor na parede lateral da caixa. O came (12" de diâmetro, compensado de 1/2") gira livre sem tocar fios ou outros componentes. Cortei "dentes" aleatórios no came com serra tico-tico para criar movimento irregular. Um rolete de nylon (parafuso de carruagem + espaçador + cantoneiras) fixado na tampa roda sobre os dentes.



Alimentei o motor com o trilho de 12V de uma fonte ATX via relé controlado pelo Arduino. Após alguns ajustes de posição do rolete, a tampa saltou conforme planejado!
Sopro de Fogo: Fumaça e Luzes
Usei uma máquina de fumaça barata de 400W (originalmente radiocontrolada). Abri o receptor e soldei fios nos contatos do botão de disparo, ligando a um canal do relé controlado pelo Arduino. Adicionei mangueira de aspirador para direcionar a fumaça para sair sob a tampa — melhora o efeito visual e reduz condensação nos eletrônicos.
Para as luzes, cortei um cabo de extensão e passei por um canal do relé. A string de 100 LEDs vermelhos liga/desliga pelo Arduino.



Use sua Voz Exterior
O Wave Shield tem saída P10 (1/8") e pinos de I/O para conexão direta. Usei cabo P10-P10 para ligar a um amplificador de baixo de 30W (emprestado da sala de ensaio). Qualquer speaker amplificado funciona, mas algo com boa resposta de graves faz diferença.

Corrente nele!
Comprei correntes plásticas em loja de Halloween e imprimi um cadeado em 3D. Envolver a caixa com isso adiciona profundidade à ilusão.

Halloween!!!
Coloquei a caixa no quintal e escondi o sensor PIR num arbusto próximo. Usei fio de speaker longo para testar posicionamento: o monstro acorda quando alguém chega a ~1,5m. Conforme escureceu, os detalhes da caixa ficaram invisíveis; iluminei com um holofote estroboscópico — efeito excelente.
As crianças notavam a caixa rosnando: umas curiosas, outras assustadas. Ao se aproximarem e o monstro rugir, pulavam, gritavam e algumas aplaudiam. Sucesso total!
Melhorias
Cansei de esconder o sensor no mato, então colei um dentro de um rato plástico posicionável na entrada. Instalei conector RJ11 na traseira da caixa para ligar o "rato sensor" via cabo telefônico de 15m — muito melhor que fio de speaker.


Adicionei chave e LEDs indicadores nessa placa nova. A chave PAUSA todas as funções sem desligar a energia (a chave principal é a régua de tomadas interna, de difícil acesso). Esta chave usa apenas sinal de 5V — ótima para parar o monstro para crianças pequenas ou curiosos que querem espiar dentro.
As correntes plásticas atrapalhavam quando eu precisava abrir a caixa à noite. Solução: prendi mosquetões de mola pretos (zip tie) nas pontas das correntes. Assim desengancho/engacho rápido nos olhais parafusados nos cantos inferiores. Baixa tecnologia, mas muito prático.
O Futuro
- Controle R/C para pausar/ativar o monstro à distância
- Feedback do levantador de tampa para o Arduino saber se a tampa está aberta/fechada (várias vezes parou no ponto alto, expondo as "entranhas")
- Conectar iluminação externa/estrobos ao Arduino para controle programado ou via controle remoto
Repositório GitHub
Código mais recente e diagramas de fiação aqui no GitHub.
Código
Monster In A Box Sketch (C/C++)
/* Pinos do Wave Shield em uso: 2, 3, 4, 5, 10, 11, 12 e 13
Pinos 13, 12, 11 sempre usados pelo cartão SD (SPI de alta velocidade).
Outros 5 pinos para DAC e SD card; por padrão a biblioteca usa:
pino 10 (SD card) e pinos 2, 3, 4, 5 para DAC.
Para alterar, modifique a biblioteca (referências por nomes de hardware: PORTD, etc).
Pinos livres: 6, 7, 8, 9 e 6 analógicos (digitais 14-20).
https://learn.adafruit.com/adafruit-wave-shield-audio-shield-for-arduino/faq */
#include "MonsterSounds.h"
#define RESERVED_00 0 // Serial RX
#define RESERVED_01 1 // Serial TX
#define RESERVED_02 2 // Wave Shield
#define RESERVED_03 3 // Wave Shield
#define RESERVED_04 4 // Wave Shield
#define RESERVED_05 5 // Wave Shield
#define FOG_MACHINE 6 // Pino Digital -> Módulo Relé
#define RED_LEDS 7 // Pino Digital -> Módulo Relé
#define LID_BOUNCER 8 // Pino Digital -> Módulo Relé
#define RESERVED_09 9 // Pino Digital -> Módulo Relé
#define RESERVED_10 10 // Wave Shield
#define RESERVED_11 11 // Wave Shield
#define RESERVED_12 12 // Wave Shield
#define RESERVED_13 13 // Wave Shield
#define PIR_SENSOR A0 // Entrada PIR
#define MOTION_LED A1 // LED: acende quando movimento detectado
#define PAUSED_LED A2 // LED: acende quando sistema pausado
#define READY_LED A3 // LED: acende quando monstro em READY_TO_WAKE
#define PAUSE_BUTTON A4 // Entrada botão Pausa
#define DEBUG_BUTTON A5 // Entrada botão Debug
// Configurações de Tempo dos Efeitos - em Segundos (EDITE ESTES)
#define WAKE_DELAY 30 // Tempo mínimo entre ocorrências 'acordado' (seg)
#define WAKE_DELAY_DEBUG 10 // Override WAKE_DELAY quando DEBUG ativado
#define SLEEP_SOUND_DELAY 1 // Segundos entre tentativas de tocar som de 'sono'
#define WAKE_MIN 3 // Tempo mínimo 'acordado' (seg)
#define WAKE_MAX 5 // Tempo máximo 'acordado' (seg)
#define RED_LIGHT_EXTRA_TIME 1 // Luzes vermelhas rodam mais que tampa, se desejado
#define SMOKE_EXTRA_TIME 2 // Fumaça roda mais que tampa, se desejado
// Configurações em Milissegundos (NÃO EDITE)
#define WAKE_DELAY_MILLIS WAKE_DELAY * 1000
#define WAKE_DELAY_DEBUG_MILLIS WAKE_DELAY_DEBUG * 1000
#define SLEEP_SOUND_DELAY_MILLIS SLEEP_SOUND_DELAY * 1000
#define WAKE_MIN_MILLIS WAKE_MIN * 1000
#define WAKE_MAX_MILLIS WAKE_MAX * 1000
#define RED_LIGHT_EXTRA_TIME_MILLIS RED_LIGHT_EXTRA_TIME * 1000
#define SMOKE_EXTRA_TIME_MILLIS SMOKE_EXTRA_TIME * 1000
MonsterSounds sounds;
static unsigned long timeSinceLastSnore = 0;
static unsigned long wakeAllowedTimer = 0;
static unsigned long lidBounceTimer = 0;
static unsigned long lidBounceDuration = 0;
static unsigned long smokeTimer = 0;
static unsigned long smokeDuration = 0;
static unsigned long redLightTimer = 0;
static unsigned long redLightDuration = 0;
enum States {
STATE_INITIALIZE, // Apenas durante setup() e primeira entrada no loop()
STATE_PAUSED, // Desliga todos sons e efeitos
STATE_SLEEPING, // Sem efeitos, sons de sono, não permite acordar
STATE_READY_TO_WAKE, // Caso especial de sono: permite acordar
STATE_AWAKE // Dispara efeitos e sons de monstro acordado
};
States state = STATE_INITIALIZE;
void setup() {
Serial.begin(9600);
pinMode(LID_BOUNCER, OUTPUT);
pinMode(RED_LEDS, OUTPUT);
pinMode(FOG_MACHINE, OUTPUT);
pinMode(PAUSED_LED, OUTPUT);
pinMode(MOTION_LED, OUTPUT);
pinMode(READY_LED, OUTPUT);
stopAllEffects();
pinMode(PIR_SENSOR, INPUT);
pinMode(PAUSE_BUTTON, INPUT_PULLUP);
pinMode(DEBUG_BUTTON, INPUT_PULLUP);
sounds.initialize();
sounds.playSystemReady();
delay(1000);
Serial.println();
Serial.print("*** Sistema Pronto ***");
Serial.println();
}
/* NOTA: Botões usam pull-up, logo LOW = PRESSIONADO.
Lógica invertida: HIGH = solto, LOW = pressionado.
O sensor PIR NÃO se comporta assim. */
void loop() {
boolean pauseSwitchClosed = digitalRead(PAUSE_BUTTON) == LOW;
boolean motionDetected = digitalRead(PIR_SENSOR) == HIGH;
digitalWrite(MOTION_LED, digitalRead(PIR_SENSOR));
switch (state) {
case STATE_INITIALIZE:
if (pauseSwitchClosed) goToPause();
else goToSleep();
break;
case STATE_PAUSED:
if (!pauseSwitchClosed) { goToSleep(); digitalWrite(PAUSED_LED, LOW); }
else digitalWrite(PAUSED_LED, HIGH);
break;
case STATE_SLEEPING:
if (pauseSwitchClosed) goToPause();
else if (isAllowedToWake()) goToReadyToWake();
else processSleeping();
break;
case STATE_READY_TO_WAKE:
if (pauseSwitchClosed) { goToPause(); digitalWrite(READY_LED, LOW); }
else if (motionDetected) { goToAwake(); digitalWrite(READY_LED, LOW); }
else processSleeping();
break;
case STATE_AWAKE:
if (pauseSwitchClosed) goToPause();
else if (processAwakeAnimation()) goToSleep();
break;
default:
Serial.println("ESTADO DESCONHECIDO");
break;
}
}
inline void goToPause() {
Serial.println("PAUSADO");
state = STATE_PAUSED;
stopAllEffects();
sounds.stopAll();
}
inline void goToSleep() {
Serial.println("INDO DORMIR");
state = STATE_SLEEPING;
wakeAllowedTimer = millis();
}
inline void goToReadyToWake() {
Serial.println("PRONTO PARA ACORDAR");
state = STATE_READY_TO_WAKE;
}
inline void goToAwake() {
Serial.println("ACORDADO");
state = STATE_AWAKE;
wakeMonster();
}
inline void processSleeping() {
if ((millis() - timeSinceLastSnore) > SLEEP_SOUND_DELAY_MILLIS) {
sounds.playSnore();
timeSinceLastSnore = millis();
}
}
inline boolean isAllowedToWake() {
boolean isDebug = digitalRead(DEBUG_BUTTON) == LOW;
unsigned long requiredDelay = WAKE_DELAY_MILLIS;
if (isDebug) requiredDelay = WAKE_DELAY_DEBUG_MILLIS;
boolean isAllowed = (millis() - wakeAllowedTimer) > requiredDelay;
if (isAllowed) digitalWrite(READY_LED, HIGH);
return isAllowed;
}
void wakeMonster() {
int activityDuration = random(WAKE_MIN_MILLIS, WAKE_MAX_MILLIS);
Serial.print(" duracao acordado: ");
Serial.print(activityDuration);
Serial.println(" ms");
bounceLid(activityDuration);
flashRedLight(activityDuration + RED_LIGHT_EXTRA_TIME_MILLIS);
activateSmoke(activityDuration + SMOKE_EXTRA_TIME_MILLIS);
sounds.playRoar();
}
boolean processAwakeAnimation() {
printTimersToLog();
boolean done1 = false, done2 = false, done3 = false;
if (millis() - lidBounceTimer > lidBounceDuration) { bounceLid(0); done1 = true; }
if (millis() - redLightTimer > redLightDuration) { flashRedLight(0); done2 = true; }
if (millis() - smokeTimer > smokeDuration) { activateSmoke(0); done3 = true; }
return done1 && done2 && done3;
}
inline void bounceLid(unsigned long duration) {
if (duration <= 0) { energizeRelay(LID_BOUNCER); lidBounceDuration = 0; }
else { de_energizeRelay(LID_BOUNCER); lidBounceTimer = millis(); lidBounceDuration = duration; }
}
inline void flashRedLight(unsigned long duration) {
if (duration <= 0) { energizeRelay(RED_LEDS); redLightDuration = 0; }
else { de_energizeRelay(RED_LEDS); redLightTimer = millis(); redLightDuration = duration; }
}
inline void activateSmoke(unsigned long duration) {
if (duration <= 0) { energizeRelay(FOG_MACHINE); smokeDuration = 0; }
else { de_energizeRelay(FOG_MACHINE); smokeTimer = millis(); smokeDuration = duration; }
}
inline void stopAllEffects() {
bounceLid(0); flashRedLight(0); activateSmoke(0);
}
inline void printTimersToLog() {
static unsigned long timeofLastTimerLog = 0;
if (millis() - timeofLastTimerLog >= 1000) {
Serial.print(" tampa: ");
Serial.print((millis()-lidBounceTimer) > lidBounceDuration ? 0 : (lidBounceDuration-(millis()-lidBounceTimer)));
Serial.print(" luzes: ");
Serial.print((millis()-redLightTimer) > redLightDuration ? 0 : (redLightDuration-(millis()-redLightTimer)));
Serial.print(" fumaça: ");
Serial.println((millis()-smokeTimer) > smokeDuration ? 0 : (smokeDuration-(millis()-smokeTimer)));
timeofLastTimerLog = millis();
}
}
inline void energizeRelay(int channel) { digitalWrite(channel, HIGH); }
inline void de_energizeRelay(int channel) { digitalWrite(channel, LOW); }
MonsterSounds.h (C/C++)
/* NOTA SOBRE PINOS DO ARDUINO
Pinos 13, 12, 11 sempre usados pelo cartão SD (SPI high-speed).
Outros 5 pinos para DAC e SD card; por padrão: pino 10 (SD) e 2,3,4,5 (DAC).
Para alterar, modifique a biblioteca (referências por hardware: PORTD, etc).
Pinos livres: 6,7,8,9 e 6 analógicos (digitais 14-20). */
#include
#include
#include
#include
static const char roar0[] = "ROAR0000.wav";
static const char roar1[] = "ROAR0001.wav";
static const char roar2[] = "ROAR0002.wav";
static const char * const roarSounds[] = {roar0, roar1, roar2};
static const char sleep0[] = "SNORE000.wav";
static const char sleep1[] = "SNORE001.wav";
static const char sleep2[] = "SNORE002.wav";
static const char * const sleepSounds[] = {sleep0, sleep1, sleep2};
int previousRoarSound = -1;
class MonsterSounds {
private:
SdReader card;
FatVolume vol;
FatReader root;
FatReader file;
WaveHC wave;
void playfile(char *name);
public:
void initialize();
void playSystemReady();
void playRoar();
void playSnore();
void stopAll();
};
MonsterSounds.ino (C/C++)
void MonsterSounds::initialize() {
Serial.println("Inicializando Sons...");
if(!card.init()) Serial.println(F("Falha init cartão!"));
if(!vol.init(card)) Serial.println(F("Sem partição!"));
if(!root.openRoot(vol)) Serial.println(F("Não abriu diretório"));
Serial.println(F("Arquivos encontrados:"));
root.ls();
randomSeed(analogRead(0));
}
void MonsterSounds::playSystemReady() { this->playfile("WELCOME0.WAV"); }
void MonsterSounds::playRoar() {
int index = random(3);
while (index == previousRoarSound) index = random(3);
previousRoarSound = index;
this->playfile(roarSounds[index]);
}
void MonsterSounds::playSnore() {
if (!wave.isplaying) {
int index = random(3);
this->playfile(sleepSounds[index]);
}
}
void MonsterSounds::stopAll() { wave.stop(); }
void MonsterSounds::playfile(char *name) {
PgmPrint("Tocando som: "); Serial.println(name);
if (wave.isplaying) { wave.stop(); }
if (!file.open(root, name)) { PgmPrintln("Arquivo não encontrado"); return; }
if (!wave.create(file)) { PgmPrintln("WAV inválido"); return; }
wave.play();
}
Peças Personalizadas e Gabinetes
monstersounds_7vLZD3NU4t.zip
Esquemáticos
Processo de manufatura
- Aparelhos de EEG: Design, Fabricação e Aplicações Emergentes
- A Revolução da Caixa de Suco: História, Design e Impacto Ambiental
- Máquinas de Venda Automática: Uma Indústria de US$ 36,6 Bilhões nos EUA
- Guia Especialista de Máquinas de Troco Modernas: Design, Componentes e Tendências Futuras
- A Evolução e Fabricação de Máquinas de Costura: Da Inovação do Século XIX à Automação Moderna
- Meia-Calça: O Guia Definitivo da Meia Feminina Elegante
- Construa Sua Própria Máquina de Escrever Deveres de Casa (Plotter de Caneta) em Casa
- Giftduino: Kit Presente Arduino Definitivo para Hobbyistas e Educadores
- Construa um Dispositivo de Levitação Ultrassônica com Arduino – Guia Passo a Passo
- Estação Meteorológica Compacta: Arduino Nano e ESP8266 com BMP280 e Display OLED/Nokia LCD