Nosferatu

Nosferatu - Busto Interativo com Som e Luz

Que tal transformar uma impressão 3D em um personagem interativo? Neste projeto vamos criar um busto do Nosferatu que reage quando alguém se aproxima, reproduzindo um áudio e criando um efeito de iluminação com intensidade variável.

Para isso, utilizaremos uma BlackBoard EDGE, um sensor ultrassônico HC-SR04, um módulo de gravação e reprodução de áudio ISD1820 e um LED controlado por PWM.

Quando o sensor detectar um objeto a 7 cm ou menos, o sistema acionará o módulo de áudio e iniciará um efeito de iluminação com variações suaves e aleatórias de intensidade.

Vista frontal do busto Nosferatu impresso em 3D — Busto Nosferatu impresso em 3D

Lista de materiais

1x BlackBoard EDGE
1x Sensor Ultrassônico HC-SR04
1x Módulo de Gravação e Reprodução de Áudio ISD1820
1x LED externo para o efeito de iluminação, com resistor limitador adequado.
1x Resistor de 330 ohms para o LED, considerando um LED comum compatível.
1x Resistor de 2,2 kohms para o divisor de tensão do ECHO.
1x Resistor de 3,3 kohms para o divisor de tensão do ECHO.
Jumpers e fios para as conexões elétricas.
Alto-falante compatível com o módulo ISD1820.
Filamento Ender Fast PLA Laranja para imprimir o busto na cor apresentada.

Caso queira personalizar a aparência do personagem, você também pode utilizar outros filamentos PLA disponíveis na RoboCore, como cinza, preto, branco ou vermelho.

Impressão 3D

O busto do Nosferatu possui detalhes na face, orelhas, dentes e pescoço. Esses elementos ajudam a criar a expressão assustadora do personagem.

Abra o arquivo 3MF no programa de fatiamento de sua preferência. Confira a escala, a orientação do modelo e a necessidade de suportes antes de iniciar a impressão.

O modelo apresentado nas fotografias utiliza uma tonalidade alaranjada. Entretanto, você pode escolher outra cor de filamento para criar um acabamento personalizado.

Utilize o botão abaixo para baixar o arquivo 3MF.

Arquivo 3MF - Nosferatu

Preparação do personagem

Após a impressão, remova cuidadosamente os suportes e os resíduos de filamento. Tenha atenção especial às regiões dos dentes, orelhas e demais detalhes do rosto.

Antes de instalar os componentes eletrônicos, verifique os espaços disponíveis no modelo e planeje a passagem dos fios.

Sensor ultrassônico

O HC-SR04 é responsável por identificar quando uma pessoa ou objeto se aproxima do personagem.

O sensor emite pulsos ultrassônicos e calcula a distância a partir do tempo de retorno do som. Neste projeto, o acionamento acontece quando a distância medida é igual ou inferior a 7 cm.

Posicione o sensor de maneira que seus transdutores fiquem livres de obstáculos e apontados para a região que deverá ser monitorada.

Como a BlackBoard EDGE utiliza sinais de 3,3 V, a saída ECHO de 5 V do HC-SR04 não deve ser conectada diretamente ao ESP32.

Para proteger a entrada GPIO 4, utilize um divisor resistivo formado por um resistor de 2,2 kohms entre ECHO e GPIO 4 e outro de 3,3 kohms entre GPIO 4 e GND.

Módulo de áudio ISD1820

O ISD1820 permite gravar e reproduzir pequenos trechos de áudio utilizando um alto-falante conectado ao módulo.

Grave previamente o som desejado no ISD1820. No programa, a reprodução é iniciada pelo pino PLAYE, conectado ao GPIO 14 da BlackBoard EDGE.

Para este projeto, o GPIO 14 permanece em nível HIGH durante 8,30 segundos. A entrada PLAYE é acionada por borda; portanto, esse tempo de HIGH não determina necessariamente a duração real da gravação.

Iluminação do personagem

O LED é conectado ao GPIO 27 da BlackBoard EDGE, utilizando um resistor limitador de corrente adequado ao LED escolhido.

A iluminação utiliza PWM para variar a intensidade do brilho durante a reprodução.

Em vez de simplesmente piscar, o LED realiza transições suaves entre diferentes intensidades, com velocidades e níveis de brilho escolhidos aleatoriamente.

O efeito começa com brilho fraco, varia durante 8,30 segundos e depois é desligado automaticamente.

Ligações elétricas

Realize as conexões de acordo com o mapeamento utilizado no programa:

HC-SR04 TRIG - GPIO 13
HC-SR04 ECHO - GPIO 4, através do divisor resistivo
HC-SR04 VCC - 5 V
HC-SR04 GND - GND
ISD1820 PLAYE - GPIO 14
ISD1820 VCC - 3,3 V
ISD1820 GND - GND
LED positivo - GPIO 27, através de resistor
LED negativo - GND

Todos os componentes devem compartilhar uma referência de GND comum. Confira também a capacidade de alimentação disponível para o módulo de áudio.

Funcionamento

Quando o sistema é ligado, a BlackBoard EDGE começa a medir a distância utilizando o HC-SR04.

Ao detectar um objeto a 7 cm ou menos, o programa inicia um ciclo de acionamento:

O GPIO 14 passa para HIGH, acionando a entrada PLAYE do ISD1820.
O LED inicia o efeito de respiração suave e aleatória.
Após 8,30 segundos, o GPIO 14 retorna para LOW e o LED é desligado.
Durante os primeiros 15 segundos após a detecção, o HC-SR04 não realiza novas medições.
Ao terminar o bloqueio, o sensor volta a medir a distância e pode iniciar outro ciclo.

Código

Programe a BlackBoard EDGE utilizando a Arduino IDE e o núcleo Arduino-ESP32 3.x.

O programa utiliza PWM para controlar o LED, enquanto a função millis() acompanha os tempos de reprodução, iluminação e bloqueio do sensor.

Os parâmetros de distância, tempo, brilho e velocidade das transições estão reunidos no início do programa, facilitando os ajustes.

/***************************************************************
 * PROJETO: NOSFERATU - AUDIO E LED ALEATORIO
 *
 * PLACA: BlackBoard EDGE - ESP32
 *
 * COMPONENTES:
 * - Sensor ultrassonico HC-SR04
 * - Modulo de audio ISD1820
 * - LED externo com resistor limitador
 *
 * FUNCIONAMENTO:
 * 1. Detecta um objeto a 7 cm ou menos.
 * 2. Mantem PLAYE em HIGH por 8.300 ms.
 * 3. Executa efeito LED suave e aleatorio.
 * 4. Desliga PLAYE e LED apos 8.300 ms.
 * 5. Bloqueia as medicoes por 15 segundos.
 *
 * Conceito e direcao: Alexandre Casemonstro
 * Desenvolvimento: Alexandre Casemonstro & Clio
 ***************************************************************/


// ============================================================
// 1. MAPEAMENTO DOS PINOS
// ============================================================

const uint8_t PINO_TRIG = 13;
const uint8_t PINO_ECHO = 4;
const uint8_t PINO_PLAY = 14;
const uint8_t PINO_LED  = 27;


// ============================================================
// 2. CONFIGURACOES DO PROJETO
// ============================================================

const float DISTANCIA_ACIONAMENTO = 7.0;

const unsigned long TEMPO_AUDIO = 8300UL;
const unsigned long TEMPO_ESPERA = 15000UL;

const unsigned long INTERVALO_MEDICAO = 100UL;
const unsigned long TIMEOUT_ECHO = 30000UL;


// ============================================================
// CONFIGURACAO DO LED
// ============================================================

const uint8_t BRILHO_MINIMO = 12;
const uint8_t BRILHO_MAXIMO = 255;

const unsigned long TRANSICAO_MINIMA = 350UL;
const unsigned long TRANSICAO_MAXIMA = 1300UL;

const unsigned long INTERVALO_LED = 10UL;

const uint32_t FREQUENCIA_PWM = 5000;
const uint8_t RESOLUCAO_PWM = 8;


// ============================================================
// 3. VARIAVEIS GLOBAIS
// ============================================================

unsigned long inicioCiclo = 0;
unsigned long ultimaMedicao = 0;
unsigned long ultimaAtualizacaoLED = 0;

bool cicloEmEspera = false;
bool audioAtivo = false;
bool efeitoLEDAtivo = false;

float brilhoAtual = 0.0;
float brilhoInicial = 0.0;

uint8_t brilhoDestino = 0;

unsigned long inicioTransicao = 0;
unsigned long duracaoTransicao = 0;


// ============================================================
// 4. CONFIGURACAO INICIAL
// ============================================================

void setup() {

  Serial.begin(115200);

  pinMode(PINO_TRIG, OUTPUT);
  pinMode(PINO_ECHO, INPUT);
  pinMode(PINO_PLAY, OUTPUT);

  digitalWrite(PINO_TRIG, LOW);
  digitalWrite(PINO_PLAY, LOW);

  if (!ledcAttach(PINO_LED,
                  FREQUENCIA_PWM,
                  RESOLUCAO_PWM)) {

    Serial.println("ERRO: Falha ao configurar PWM!");

    while (true) {
      delay(1000);
    }
  }

  ledcWrite(PINO_LED, 0);

  randomSeed(esp_random());

  delay(300);

  Serial.println();
  Serial.println("==========================================");
  Serial.println("       NOSFERATU - ROBOCORE");
  Serial.println("==========================================");

  Serial.println();
  Serial.println("MAPEAMENTO DOS PINOS:");
  Serial.println("------------------------------------------");

  Serial.print("HC-SR04 TRIG  -> GPIO ");
  Serial.println(PINO_TRIG);

  Serial.print("HC-SR04 ECHO  -> GPIO ");
  Serial.println(PINO_ECHO);

  Serial.print("ISD1820 PLAYE -> GPIO ");
  Serial.println(PINO_PLAY);

  Serial.print("LED PWM      -> GPIO ");
  Serial.println(PINO_LED);

  Serial.println();
  Serial.println("ALIMENTACAO E PROTECAO:");
  Serial.println("------------------------------------------");

  Serial.println("HC-SR04 VCC  -> 5V");
  Serial.println("HC-SR04 ECHO -> Divisor resistivo");
  Serial.println("R1: 2,2k ohms (ECHO ao GPIO 4)");
  Serial.println("R2: 3,3k ohms (GPIO 4 ao GND)");
  Serial.println("ISD1820 VCC  -> 3,3V");
  Serial.println("GND comum entre componentes");

  Serial.println();
  Serial.println("CONFIGURACOES:");
  Serial.println("------------------------------------------");

  Serial.print("Distancia: ");
  Serial.print(DISTANCIA_ACIONAMENTO);
  Serial.println(" cm");

  Serial.print("Tempo PLAYE / LED: ");
  Serial.print(TEMPO_AUDIO);
  Serial.println(" ms");

  Serial.print("Bloqueio do sensor: ");
  Serial.print(TEMPO_ESPERA);
  Serial.println(" ms");

  Serial.println();
  Serial.println("Sistema pronto.");
  Serial.println("==========================================");
}


// ============================================================
// 5. LOOP PRINCIPAL
// ============================================================

void loop() {

  unsigned long agora = millis();

  // Desliga PLAYE ao terminar o tempo do audio.

  if (audioAtivo &&
      (agora - inicioCiclo >= TEMPO_AUDIO)) {

    digitalWrite(PINO_PLAY, LOW);

    audioAtivo = false;

    Serial.println("[AUDIO] GPIO 14 -> LOW");
  }


  // Atualiza ou encerra o efeito do LED.

  if (efeitoLEDAtivo) {

    if (agora - inicioCiclo >= TEMPO_AUDIO) {

      ledcWrite(PINO_LED, 0);

      efeitoLEDAtivo = false;
      brilhoAtual = 0;

      Serial.println("[LED] Efeito finalizado.");

    } else {

      atualizarEfeitoLED(agora);
    }
  }


  // Suspende as medicoes durante 15 segundos.

  if (cicloEmEspera) {

    if (agora - inicioCiclo >= TEMPO_ESPERA) {

      cicloEmEspera = false;

      ultimaMedicao = agora - INTERVALO_MEDICAO;

      Serial.println();
      Serial.println("[SENSOR] Bloqueio encerrado.");
      Serial.println("[SENSOR] Retomando medicoes.");

    } else {

      return;
    }
  }


  // Realiza medicoes quando o sensor esta liberado.

  if (agora - ultimaMedicao >= INTERVALO_MEDICAO) {

    ultimaMedicao = agora;

    float distancia = medirDistancia();

    if (distancia < 0) {

      Serial.println("[SENSOR] Sem retorno valido.");
      return;
    }

    Serial.print("[SENSOR] Distancia: ");
    Serial.print(distancia, 1);
    Serial.println(" cm");

    if (distancia <= DISTANCIA_ACIONAMENTO) {

      iniciarCiclo(millis());
    }
  }
}


// ============================================================
// 6. FUNCOES ADICIONAIS
// ============================================================


// ------------------------------------------------------------
// MEDIR DISTANCIA
// ------------------------------------------------------------

float medirDistancia() {

  digitalWrite(PINO_TRIG, LOW);
  delayMicroseconds(2);

  digitalWrite(PINO_TRIG, HIGH);
  delayMicroseconds(10);

  digitalWrite(PINO_TRIG, LOW);

  unsigned long duracao =
      pulseIn(PINO_ECHO, HIGH, TIMEOUT_ECHO);

  if (duracao == 0) {
    return -1.0;
  }

  return (duracao * 0.0343) / 2.0;
}


// ------------------------------------------------------------
// INICIAR CICLO
// ------------------------------------------------------------

void iniciarCiclo(unsigned long agora) {

  inicioCiclo = agora;

  cicloEmEspera = true;
  audioAtivo = true;
  efeitoLEDAtivo = true;

  digitalWrite(PINO_PLAY, HIGH);

  brilhoAtual = BRILHO_MINIMO;
  brilhoInicial = brilhoAtual;

  ledcWrite(PINO_LED, BRILHO_MINIMO);

  ultimaAtualizacaoLED = agora;

  definirNovaTransicao(agora);

  Serial.println();
  Serial.println("==========================================");
  Serial.println("[EVENTO] OBJETO DETECTADO");
  Serial.println("[AUDIO] GPIO 14 -> HIGH por 8300 ms");
  Serial.println("[LED] Respiracao aleatoria iniciada.");
  Serial.println("[SENSOR] Leituras suspensas por 15 s.");
  Serial.println("==========================================");
}


// ------------------------------------------------------------
// DEFINIR NOVA TRANSICAO DO LED
// ------------------------------------------------------------

void definirNovaTransicao(unsigned long agora) {

  brilhoInicial = brilhoAtual;

  brilhoDestino = random(
      BRILHO_MINIMO,
      BRILHO_MAXIMO + 1
  );

  duracaoTransicao = random(
      TRANSICAO_MINIMA,
      TRANSICAO_MAXIMA + 1
  );

  inicioTransicao = agora;
}


// ------------------------------------------------------------
// ATUALIZAR EFEITO LED
// ------------------------------------------------------------

void atualizarEfeitoLED(unsigned long agora) {

  if (agora - ultimaAtualizacaoLED < INTERVALO_LED) {
    return;
  }

  ultimaAtualizacaoLED = agora;

  unsigned long tempoDecorrido =
      agora - inicioTransicao;

  if (tempoDecorrido >= duracaoTransicao) {

    brilhoAtual = brilhoDestino;

    definirNovaTransicao(agora);

    tempoDecorrido = 0;
  }

  float progresso =
      (float)tempoDecorrido / duracaoTransicao;

  float suavizado =
      progresso * progresso * (3.0 - 2.0 * progresso);

  brilhoAtual =
      brilhoInicial +
      (brilhoDestino - brilhoInicial) * suavizado;

  ledcWrite(PINO_LED, (uint8_t)brilhoAtual);
}

Boas práticas

Confira o acabamento da impressão antes de instalar os componentes eletrônicos.
Posicione o sensor ultrassônico sem obstáculos diretamente à frente dos transdutores.
Utilize obrigatoriamente o divisor resistivo na saída ECHO do HC-SR04 para proteger a entrada do ESP32.
Verifique a polaridade do LED e utilize um resistor limitador de corrente adequado.
Não conecte diretamente ao GPIO 27 uma carga de iluminação que exceda a capacidade elétrica do ESP32. Para LEDs de potência ou fitas, utilize um circuito de acionamento apropriado.
Grave e teste o áudio no ISD1820 antes de realizar a montagem definitiva.
Confira a alimentação e o GND comum entre todos os componentes.
Antes de fechar a montagem, acompanhe pelo Monitor Serial as leituras de distância, o acionamento do áudio e o bloqueio do sensor.
Evite expor a impressão em PLA a temperaturas elevadas ou ao sol intenso durante períodos prolongados.