Accesorio de ojos de miedo de Halloween: 8 pasos

2024 Autor: John Day | [email protected]. Última modificación: 2024-01-30 08:42

A lo largo de los años, al realizar varios proyectos, hubo una

Toda una colección de módulos diferentes que estaban sin usar y quería usar al menos algunos de ellos para algo que fuera divertido y creativo al mismo tiempo.

Revisando el “Sitio instructables.com” de Ideas, me encontré con algunos proyectos que pensé que podrían mezclarse para hacer algo para este “Halloween”.

Debo darle crédito a Steve Quinn, Creador inesperado por usar sus ideas.

Suministros

ARTÍCULOS Y MÓDULOS UTILIZADOS

Módulos utilizados

1 tablero Atmega8 autónomo

2 tarjetas controladoras basadas en PIR para salida de 5 voltios

3 Placa amplificadora LM386

4 Módulo de reproductor MP3 genérico

5 módulos LED MAX7219 8x8

6 Módulo PIR (Genérico)

Altavoz de 7 4 4 ohmios

Otros materiales

una. Caja de cartón vacía

B. Botellas de agua vacías de un solo uso

C. LED que cambia de color 5V

D. Alambres surtidos

mi. Pistola de pegamento

F. Soldador

gramo. Herramientas y cortadores diversos

h. Transformador reductor de 12V 1A

Importante

1 IDE de Arduion

2 placa de programación para chips AVR

3 Software de programación (grabación)

Paso 1: los diferentes módulos

Primero, veremos cómo hacer los diferentes módulos, Ciertamente podría hacer solo una PCB para todos los componentes electrónicos y hacer que el proyecto funcione bien, pero, para mí, la idea era usar los diferentes elementos que ya había hecho antes para diferentes proyectos y ahora que la necesidad de ellos había terminado, solo quería reutilizar esos elementos.

La placa ATmega8

Estoy usando el chip ATmega8 sin ningún cristal externo. En realidad, estas placas se hicieron para ejecutar algunos módulos LED P10 16x32 y me sobraron algunos de este proyecto. La imagen de la placa y el diseño de la PCB es la siguiente (ver imágenes). Hay innumerables artículos sobre cómo hacer su propia placa Arduino en "instructables". Simplemente puede usar cualquier placa Arduino vieja que pueda tener por ahí.

Tarjeta controladora PIR

Esta placa PIR se hizo para encender y apagar algunas pequeñas decoraciones de festivales basadas en LED y ahora estaba por ahí y decidí ponerla en uso. El diseño del circuito se muestra en las imágenes.

La placa amplificadora LM 386

Este es el módulo amplificador que amplifica la salida de sonido del módulo reproductor MP3. el diseño y el circuito son bastante simples y las imágenes lo dicen todo. El diseño del circuito y la imagen de la placa completa se explican por sí mismos.

El módulo del reproductor MP3

He utilizado el módulo de reproductor MP3 que se muestra en la imagen. Está disponible en Amazon, etc., es barato y fácil de usar. La mejor parte de este módulo en particular es que no requiere ningún comando o conexión adicional para comenzar a jugar. En el momento en que se suministra la energía adecuada a la placa, comienza a hacer su trabajo.

Módulos LED MAX7219 8x8

Estos módulos de pantalla LED de 8x8 están disponibles en Amazon, etc. Se proporcionan imágenes de los que utilicé.

Módulo PIR

He utilizado el módulo de sensor PIR disponible. Está disponible en Amazon, etc., es barato y fácil de usar. Las imágenes se proporcionan como referencia.

Paso 2: La parte de ensamblaje 1

El concepto era combinar todos estos módulos y hacer un accesorio de Halloween que se activara cada vez que alguien cruzara frente al accesorio. Para esto, conecté la fuente de alimentación de 12 voltios a la placa de control PIR, que a su vez redujo el voltaje a 5 V CC con la ayuda del 7805 IC y este voltaje de 5 V CC se pasó al sensor PIR y más allá a los otros módulos., la placa ATmega8, el módulo amplificador y el módulo reproductor MP3 siempre que alguien se acerque al sensor PIR. El diagrama de flujo lo dice todo.

Como podemos ver, el sensor PIR activa la placa ATmega8, el módulo amplificador y el módulo reproductor MP3, el ATmega8 controla la matriz de LED "ojos", el reproductor MP3 reproduce los efectos de sonido y el módulo amplificador envía la señal al altavoz..

El Código Arduino es un despegue directo del instructable de Steve Quinn, excepto que la hora ha sido alterada en el código. El código utilizado se proporciona a continuación. También se adjunta el archivo INO.

El código

// D10 = Pin CS digital O / P

// D11 = Pin de reloj digital O / P

// D12 = Pin de datos digital O / P

//

#incluir

#incluir

const int numDevices = 2; // número de MAX7219 utilizados

const int dataPin = 12;

const int clkPin = 11;

const int csPin = 10;

LedControl lc = LedControl (dataPin, clkPin, csPin, numDevices);

// Suelta este código en el entorno de desarrollo Arduino

#define LeftEye1 0

#define RightEye1 1

#define LeftEye2 2

#define RightEye2 3

#define LeftEye3 4

#define RightEye3 5

#define LeftEye4 6

#define RightEye4 7

#define LeftEye5 8

#define RightEye5 9

#define LeftEye6 10

#define RightEye6 11

#define LeftEye7 12

#define RightEye7 13

#define LeftEye8 14

#define RightEye8 15

#define LeftEye9 16

#define RightEye9 17

#define LeftEye10 18

#define RightEye10 19

#define LeftEye11 20

#define RightEye11 21

#define LeftEye12 22

#define RightEye12 23

#define LeftEye13 24

#define RightEye13 25

#define LeftEye14 26

#define RightEye14 27

#define LeftEye15 28

#define RightEye15 29

#define LeftEye16 30

#define RightEye16 31

#define LeftEye17 32

#define RightEye17 33

#define LeftEye18 34

#define RightEye18 35

#define LeftEye19 36

#define RightEye19 37

#define LeftEye20 38

#define RightEye20 39

typedef struct {

const unsigned char array1 [8];

}

binaryArrayType;

binaryArrayType binaryArray [40] =

{

{// LeftEye1, 0

B01111110, B10000001, B10000001, B10011001, B10011001, B10000001, B10000001, B01111110

}, {// RightEye1, 1

B01111110, B10000001, B10000001, B10011001, B10011001, B10000001, B10000001, B01111110

}, {// LeftEye2, 2

B00000000, B00111100, B01000010, B01011010, B01011010, B01000010, B00111100, B00000000

}, {// RightEye2, 3

B00000000, B00111100, B01000010, B01011010, B01011010, B01000010, B00111100, B00000000

}, {// LeftEye3, 4

B00000000, B00111100, B00100100, B00110100, B00110100, B00100100, B00111100, B00000000

}, {// RightEye3, 5

B00000000, B00111100, B00100100, B00110100, B00110100, B00100100, B00111100, B00000000

}, {// LeftEye4, 6

B00011000, B00011000, B00011000, B00011000, B00011000, B00011000, B00011000, B00000000

}, {// RightEye4, 7

B00000000, B00011000, B00011000, B00011000, B00011000, B00011000, B00011000, B00011000

}, {// LeftEye5, 8

B01111110, B10000001, B10000001, B10011001, B10011001, B10000001, B10000010, B01111100

}, {// RightEye5, 9

B01111100, B10000010, B10000001, B10011001, B10011001, B10000001, B10000001, B01111110

}, {// LeftEye6, 10

B01111110, B10000001, B10000001, B10011001, B10011001, B10000010, B10000100, B01111000

}, {// RightEye6, 11

B01111000, B10000100, B10000010, B10011001, B10011001, B10000001, B10000001, B01111110

}, {// LeftEye7, 12

B01111110, B11000001, B10000001, B10011001, B10011010, B10000100, B10001000, B01110000

}, {// RightEye7, 13

B01110000, B10001000, B10000100, B10011010, B10011001, B10000001, B11000001, B01111110

}, {// LeftEye8, 14

B00111110, B01000001, B10000001, B10011001, B10011010, B10000100, B01001000, B00110000

}, {// RightEye8, 15

B00110000, B01001000, B10000100, B10011010, B10011001, B10000001, B01000001, B00111110

}, {// LeftEye9, 16

B01111110, B10000001, B10000001, B10011001, B10011001, B10000001, B10000001, B01111110

}, {// RightEye9, 17

B01111110, B10000001, B10000001, B10011001, B10011001, B10000001, B10000001, B01111110

}, {// LeftEye10, 18

B01111110, B10000001, B10000001, B10000001, B10011001, B10011001, B10000001, B01111110

}, {// RightEye10, 19

B01111110, B10000001, B10000001, B10000001, B10011001, B10011001, B10000001, B01111110

}, {// LeftEye11, 20

B01111110, B10000001, B10000001, B10000001, B10011001, B10011001, B10000001, B01111110

}, {// RightEye11, 21

B01111110, B10000001, B10000001, B10000001, B10011001, B10011001, B10000001, B01111110

}, {// LeftEye12, 22

B01111110, B10000001, B10000001, B10000001, B10000001, B10011001, B10011001, B01111110

}, {// RightEye12, 23

B01111110, B10000001, B10000001, B10000001, B10000001, B10011001, B10011001, B01111110

}, {// LeftEye13, 24

B01111110, B10000001, B10000001, B10000001, B10000001, B10000001, B10011001, B01111110

}, {// RightEye13, 25

B01111110, B10000001, B10000001, B10000001, B10000001, B10000001, B10011001, B01111110

}, {// LeftEye14, 26

B00000000, B00111100, B01000010, B01000010, B01000010, B01011010, B00111100, B00000000

}, {// RightEye14, 27

B00000000, B00111100, B01000010, B01000010, B01000010, B01011010, B00111100, B00000000

}, {// LeftEye15, 28

B00000000, B00111100, B00100100, B00100100, B00100100, B00111100, B00111100, B00000000

}, {// RightEye15, 29

B00000000, B00111100, B00100100, B00100100, B00100100, B00111100, B00111100, B00000000

}, {// LeftEye16, 30

B00011000, B00011000, B00011000, B00011000, B00011000, B00011000, B00011000, B00000000

}, {// RightEye16, 31

B00000000, B00011000, B00011000, B00011000, B00011000, B00011000, B00011000, B00011000

}, {// LeftEye17, 32

B00010000, B00010000, B00010000, B00010000, B00010000, B00010000, B00010000, B00000000

}, {// RightEye17, 33

B00000000, B00010000, B00010000, B00010000, B00010000, B00010000, B00010000, B00010000

}, {// LeftEye18, 34

B01111110, B10000001, B10000001, B10000001, B10000001, B10000001, B10001101, B01111110

}, {// RightEye18, 35

B01111110, B10000001, B10000001, B10000001, B10000001, B10000001, B10001101, B01111110

}, {// LeftEye19, 36

B01111110, B10000001, B10000001, B10000001, B10000001, B10000001, B10000111, B01111110

}, {// RightEye19, 37

B01111110, B10000001, B10000001, B10000001, B10000001, B10000001, B10000111, B01111110

}, {// LeftEye20, 38

B01111110, B10000001, B10000001, B10000001, B10000001, B10000011, B10000011, B01111110

}, {// RightEye20, 39

B01111110, B10000001, B10000001, B10000001, B10000001, B10000011, B10000011, B01111110

}

};

typedef struct {

int frameCount; // índice del puntero en binaryArray que significa el cuadro de animación

int frameDelay; // Retraso aproximado en milisegundos para mantener la visualización de este fotograma animado

int frameLuminance; // 0… 15, la intensidad de la matriz de led para un marco dado

} tipo de marco;

frameType movie =

{

// Parpadear

{LeftEye1, 1000, 1}, {LeftEye2, 5, 1}, {LeftEye3, 10, 1}, {LeftEye4, 10, 1}, {LeftEye17, 100, 1}, {LeftEye4, 10, 1}, {LeftEye3, 10, 1}, {LeftEye2, 5, 1}, // Completamente ancho de nuevo

{LeftEye1, 1500, 2}, // fruncir el ceño

{LeftEye5, 5, 3}, {LeftEye6, 5, 4}, {LeftEye7, 5, 5}, {LeftEye8, 1000, 11}, {LeftEye7, 5, 5}, {LeftEye6, 5, 4}, {LeftEye5, 5, 3}

};

void delayMillis (int milisegundos)

{

para (int i = 0; i <milisegundos; i ++)

delayMicroseconds (1000);

}

configuración vacía () {

para (int x = 0; x <numDevices; x ++) {

lc.shutdown (x, falso); // El MAX72XX está en modo de ahorro de energía al iniciarse

lc.setIntensity (x, 1); // Establecer el brillo al valor predeterminado

lc.clearDisplay (x); // y borra la pantalla

}

}

bucle vacío () {

lc.setIntensity (0, 3);

lc.setIntensity (1, 3);

while (verdadero) {

para (int a = 0; a <(tamaño de (película) / tamaño de (tipo de fotograma)); a ++)

{

para (int i = 0; i <8; i ++)

{

lc.setRow (0, i, binaryArray [película [a].frameCount].array1 );

lc.setRow (1, i, binaryArray [película [a].frameCount + 1].array1 );

lc.setIntensity (0, película [a].frameLuminance);

lc.setIntensity (1, película [a].frameLuminance);

}

delayMillis (película [a].frameDelay);

}

}

}

Paso 3: Montaje, parte 2

Una vez que tenga el IDE de Arduino en funcionamiento, debe copiar el código y compilar / verificar el código. Cuando compila el código, el archivo HEX se crea en la carpeta TEMP de la computadora. Antes de cerrar el IDE de Arduino, puede copiar el archivo HEX de la carpeta temporal y este archivo es lo que necesitamos grabar en el chip ATmega8 para que funcione.

Mientras compilaba el código, elegí la placa como "Arduino NG o más antiguo" y el procesador como "ATmega8" y después de compilar, copié el archivo HEX de la carpeta Temp de la computadora, antes de cerrar el IDE de Arduino.

Este archivo HEX se grabó en el chip ATmega8 con un quemador AVR externo. Usé el software “Extreme Burner_AVR” y una placa AVR Burner para este propósito. Se adjunta la imagen del tablero. Puede utilizar cualquier software de programación AVR con el que se sienta cómodo.

La razón para usar un programador externo fue que no quería grabar el cargador de arranque en los chips Atmega8 y sin el cargador de arranque, no funcionarían en la placa Arduino normal o con el IDE de Arduion. Es bastante fácil extraer los archivos HEX una vez que compila el código con el IDE de Arduino y eso es lo que hice.

NOTA

ES MUY IMPORTANTE elegir los ajustes correctos de los bits del fusible mientras se utiliza un programador externo.

En este caso, dado que no estamos usando un cristal externo y confiamos en el reloj interno del chip ATmega8, es importante que configuremos los bits de fusible en consecuencia. He elegido los siguientes ajustes de fusibles.

Lfuse- E4

Hfuse - D9

LO QUE ESTO SIGNIFICA

Significa que no estamos usando cristal externo o resonador.

El reloj está configurado en un reloj interno de 8 MHz.

Una vez que se programó el chip ATmega8, llegó el momento de armar el proyecto y probarlo.

Paso 4: Conectando LOS ojos

La matriz LED MAX7219 8x8 se conectó como se muestra a continuación.

Placa ATmega8 a matriz MAX7219

Pin IO D10 AL PIN CS

Pin IO D11 A CLK PIN

Pin IO D12 A PIN DIN

VCC A VCC

TIERRA A TIERRA

Consulte la imagen

Paso 5: Conexión del sensor y módulo PIR

A continuación, el sensor PIR se conectó al controlador PIR

Junta, las conexiones son las siguientes

Tablero del controlador PIR al sensor PIR

VCC a VCC

CTRL a CTRL

GND a GND

Consulte el diagrama

Esta es la parte que hace que todo suceda. El sensor PIR capta el movimiento de cualquier criatura de sangre caliente y conecta la fuente de alimentación a todos los diferentes circuitos / módulos. el tiempo en el sensor PIR se ha ajustado según el requisito y, en este caso, es de aproximadamente 40 a 45 segundos. Envía 5 voltios CC a todos los circuitos conectados a él durante un período de aproximadamente 40 a 45 segundos.

Paso 6: el reproductor MP3 y el amplificador

A CONTINUACIÓN, el módulo del reproductor MP3 y el módulo amplificador.

El reproductor MP3 que utilicé no necesita que se presione ningún botón para encenderlo, en el momento en que se le suministra el voltaje adecuado, comienza a reproducir automáticamente. Solo necesitaba una pista, así que encontré la tarjeta SD con la menor memoria que pude (4 GB porque es casi imposible obtener una tarjeta con menor capacidad en estos días). Los sonidos que descargué de Internet, de hecho, hubo una serie de efectos de sonido que se descargaron y todos se compilaron para hacer una sola pista MP3 utilizando el software de edición de sonido. Usé “Wave Editor” y finalmente cargué esta única pista en la tarjeta SD. La tarjeta SD se montó en el módulo del reproductor MP3 y la salida se conectó al módulo amplificador para obtener el sonido del altavoz.

Consulte la imagen

El chip amplificador LM386 requiere muy pocos componentes externos y ofrece un sonido bastante bueno con altavoces pequeños. El circuito es bastante fácil de ensamblar de una placa perfilada y me tomó entre 15 y 20 minutos ensamblar este. La imagen es bastante autoexplicativa.

Paso 7: El ensamblaje final

Antes de colocar todo en el gabinete, quería probar todo y distribuir los módulos según fuera necesario y realizar las conexiones finales. Después quedé satisfecho con el funcionamiento de las piezas. Los arreglé dentro de la caja de cartón hecha para ese propósito.

Adjunto un video después del montaje final del utilería.

Paso 8: EL CERRAMIENTO

El recinto

El recinto se hizo con una vieja caja de cartón, pintada de rojo. El lugar para los ojos y el sensor PIR se cortó con una cuchilla afilada. Se pegó una impresión del cráneo en la caja y los ojos, etc.recortó en consecuencia y el contorno se volvió a dibujar con un rotulador permanente negro. Hice el cabello con botellas de agua desechadas, las corté en tiras finas y las pegué con Hot Melt Glue en la cabeza y los lados. Arreglé 2 LED que cambiaban de color en los lados y estos se conectaron a la salida de la placa controladora PIR.

Se hicieron pequeños orificios para el altavoz y todos los elementos se arreglaron con la ayuda de Hot Melt Glue en el interior de la caja. El cable de alimentación se sacó de la parte posterior de la caja y eso es todo.

¡Espero que disfruten haciendo este accesorio de Halloween para los niños!

Pronto adjuntaré el clip de audio utilizado en este proyecto.

Feliz Halloween a todos !!