Manufaturação industrial
Internet das coisas industrial | Materiais industriais | Manutenção e reparo de equipamentos | Programação industrial |
home  MfgRobots >> Manufaturação industrial >  >> Manufacturing Technology >> Processo de manufatura

Construa seu Próprio Monstro na Caixa: Projeto de Robótica com Arduino

Componentes e Materiais

ComponenteQuantidade
Caixa de madeira (crate)1
Arduino UNO1
Adafruit Wave Shield1
Módulo Relé 4 Canais SainSmart1
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:

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.

Construa seu Próprio Monstro na Caixa: Projeto de Robótica com Arduino

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.

Construa seu Próprio Monstro na Caixa: Projeto de Robótica com Arduino

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.

Construa seu Próprio Monstro na Caixa: Projeto de Robótica com Arduino
Construa seu Próprio Monstro na Caixa: Projeto de Robótica com Arduino
Construa seu Próprio Monstro na Caixa: Projeto de Robótica com Arduino

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.

Construa seu Próprio Monstro na Caixa: Projeto de Robótica com Arduino
Construa seu Próprio Monstro na Caixa: Projeto de Robótica com Arduino
Construa seu Próprio Monstro na Caixa: Projeto de Robótica com 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.

Construa seu Próprio Monstro na Caixa: Projeto de Robótica com Arduino

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.

Construa seu Próprio Monstro na Caixa: Projeto de Robótica com Arduino

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.

Construa seu Próprio Monstro na Caixa: Projeto de Robótica com Arduino
Construa seu Próprio Monstro na Caixa: Projeto de Robótica com Arduino

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

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

Construa seu Próprio Monstro na Caixa: Projeto de Robótica com Arduino

Processo de manufatura

  1. Aparelhos de EEG: Design, Fabricação e Aplicações Emergentes
  2. A Revolução da Caixa de Suco: História, Design e Impacto Ambiental
  3. Máquinas de Venda Automática: Uma Indústria de US$ 36,6 Bilhões nos EUA
  4. Guia Especialista de Máquinas de Troco Modernas: Design, Componentes e Tendências Futuras
  5. A Evolução e Fabricação de Máquinas de Costura: Da Inovação do Século XIX à Automação Moderna
  6. Meia-Calça: O Guia Definitivo da Meia Feminina Elegante
  7. Construa Sua Própria Máquina de Escrever Deveres de Casa (Plotter de Caneta) em Casa
  8. Giftduino: Kit Presente Arduino Definitivo para Hobbyistas e Educadores
  9. Construa um Dispositivo de Levitação Ultrassônica com Arduino – Guia Passo a Passo
  10. Estação Meteorológica Compacta: Arduino Nano e ESP8266 com BMP280 e Display OLED/Nokia LCD