Pantalla POV de Digilog_Bike: 14 pasos

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

Digilog

Digital + Analógico

Lo digital se encuentra con lo analógico

POV

Persistencia de lo visual

También conocido como visualización de imágenes persistentes, si se agita a alta velocidad, la imagen secundaria permanece.

Las personas piensan que están viendo videos cuando ven televisión. Pero, de hecho, está mirando varias imágenes consecutivas. Esto se confunde con una imagen debido al efecto de las imágenes residuales que permanecen en nuestras retinas al ver imágenes sucesivas. Este tipo de ilusión se llama POV.

Paso 1: Concepto de idea

El POV se implementa conectando una correa de LED a la rueda de una bicicleta.

Paso 2: Lista de materiales

Computación y E / S

1. Arduino Mega 2560 [arduino] x3

2. Módulo sensor Hall V2 [YwRobot] x3

3. WS2812-5050 Neopixel flexible [Adafruit] x3

4. Magnético (diámetro de 15 mm, espesor de 50 mm) x3

5. Arduino Mega Case x3

Línea eléctrica

5. Batería de litio de 5000 mAh / 3,7 V [TheHan] x3

6. Regulador AVR 5V, carga y módulo PCM: JBATT-U5-LC [Jcnet] x3

7. Kit de cables de 4 puentes 65PCS / SET [OR0012] x3

Paso 3: herramientas

No se necesitan demasiadas herramientas, sin embargo, necesitará:

1. Máquina de soldadura

2. Un soldador

3. Pistola de pegamento

4. Pinza

Paso 4: Hacer marco

Cortar la bicicleta y colocar la base

La amoladora se utilizó para cortar las ruedas de la bicicleta y placas de acero soldadas para asegurar las ruedas.

Paso 5: Dibujar imágenes y conceptos finales

Elegimos un dragón como imagen final. Porque la ola del dragón parecía estar mejor representada por el efecto de imagen residual.

Paso 6: hacer un corte de imagen en movimiento

Divida la imagen en tres partes que quepan en cada bicicleta y divida el total de 12 imágenes por color y movimiento.

Paso 7: Preparación del software

Subparte 1. Instalar Arduino

Descarga de Arduino:

(Instálelo para que se ajuste a la versión y al sistema de su sistema operativo).

-

Subparte 2. Instalar biblioteca

* (Si desea instalar a través de Github, visite el enlace que se encuentra arriba de la Biblioteca Arduino de Github:

1. Ejecute el programa Arduino

2. Permitir el enlace Menú superior - bosquejo - incluir biblioteca - agregar biblioteca. Zip

3. Debe elegir el archivo. Zip que ya instaló la biblioteca github4

* (Si desea utilizar los servicios del programa Arduino)

1. Ejecute programas de Arduino

2. Permitir el enlace Menú superior - bosquejo - incluir biblioteca - biblioteca de administración - buscando "Adafruit neopixel" - puede ver "Adafruit Neopixel de Adafruit"

3. Instalar y actualizar la biblioteca

-

Subparte 3. Instalar el programa de conversión

1. Instale el programa Círculo de rotación (R. C. P):

2. Necesita leer un archivo README

Paso 8: hacer una fuente de alimentación de hardware

* Así es como se suministra voltaje Arduino 5V a través de la batería. Siga los pasos a continuación.

1. Conecte la batería de litio y el módulo de carga JBATT. (Como referencia, el módulo JBATT tiene un interruptor de encendido incorporado).

2. Conecte el terminal de salida de JBATT al terminal Vin de Arduino y al terminal de tierra.

3. Conecte el puerto USB Micro de 5 pines al puerto de carga para comprobar si el producto ha funcionado correctamente.

4. A continuación, coloque el interruptor integrado en ON.

5. Si el LED rojo se enciende y el LED verde se enciende en Arduino, la configuración de la etapa de potencia del producto se completa normalmente.

Paso 9: Realización de E / S de hardware y verificación de SALIDA (NeoPixel en funcionamiento)

* Esta parte consta de sensor y etapa de salida

1. Conecte los sensores Arduino y Hall. El pin de datos se conecta al pin 2 de Arduino.

2. Cuando se enciende el Arduino y el imán está en estrecho contacto con el sensor Hall, el LED rojo se iluminará.

3. Conecte Arduino y Neopixel. Solo se utilizan 30 Neopixels.

4. Conecte el pin de datos con el pin 6 de Arduino.

5. Conecte el Arduino y descargue el cable al puerto USB de su computadora y ejecute Arduino en su computadora.

6. Seleccione Herramienta - tablero - “Arduino / Genuino Mega o Mega 2560” en la barra de menú superior del programa Arduino.

7. Compruebe si hay una lista de productos que se pueden conectar directamente al puerto. Si no está marcado, haga clic para seleccionarlo.

8. Pegue el código a continuación y haga clic en Cargar en la parte superior izquierda. (Luego, todas las cargas de programas siguen los pasos 5-8).

9. La configuración está completa cuando se encienden los 30 píxeles neoled.

# 1. incluyendo archivo de encabezado y preprocesamiento

Primero necesitamos traer la biblioteca Adafruit_NeoPixel que puede actuar Neopixels.

La biblioteca se puede utilizar declarando objetos.

La clase Adafruit_NeoPixel puede ingresar 3 parámetros en público.

El primer parámetro es el número de LED.

El parámetro de segundos es el número de pin conectado a la entrada digital Neopixel.

El tercer parámetro es ingresar opciones de acuerdo con las características del producto. El producto WS2812b de tres colores utiliza la entrada 'NEO_GRB'

#incluir

#define PIN 6 Adafruit_NeoPixel strip = Adafruit_Neopixel (30, PIN, NEO_GRB + NEO_KHZ800);

# 2. configuración

En la parte de configuración, inicialice el objeto y prepárelo para su uso.

'Adafruit_Neopixle_Object.begin ()' establece que todos los LED se apaguen.

'Adafruit_Neopixle_Object.show ()' emite con el brillo establecido en el LED.

configuración vacía () {

strip.begin (); strip.show (); }

# 3. bucle principal

La acción del bucle principal utiliza un bucle for para emitir secuencialmente (0,1 segundos) los LED en blanco

bucle vacío () {

para (uint16_t i = 0; i <strip.numPixels (); i ++) {strip.setPixelColor (i, 255, 255, 255); strip.show (); retraso (100); }}

Paso 10: Montaje y fijación a la rueda

1. Conecte Neopixels. (Preste atención a la verificación del número de PIN)

2. Conecte el sensor Hall. (Consulte el paso 9)

3. Conecte el marco al Arduino entre las bicicletas. (Coloque la carcasa de Arduino paralela al cuadro de la bicicleta).

4. Inserte el Arduino conectado a Neopixel. (Cuidado porque la pistola de pegamento está caliente).

5. Inserte el sensor Hall conectado en Arduino, (Asegure la brida de cables para que el sensor Hall no se caiga).

6. Suelde para conectar la batería. (Tenga cuidado al soldar).

7. Fíjelo con una pistola de pegamento. (Coloque el módulo de carga en la batería para asegurar el espacio).

8. Conecte cada línea antes de conectarse a Arduino, 9. Enchufe de acuerdo con cada número de pin. (Conecte las líneas de salto para el módulo de carga sin confundirlas).

10. Termine con una pistola de pegamento una vez (tenga cuidado de no caerse).

Paso 11: Verificación de ENTRADA (datos del sensor HALL)

* Verifique el código del software para ver si el sensor está funcionando.

1. Pegue y cargue el código a continuación.

2. Haga clic en el botón Serial Monitor en la parte superior derecha del Arduino.

3. Cuando el imán está en contacto con el sensor Hall durante más de 1 segundo, la configuración se completa cuando aparece la palabra "contacto magnético" en el monitor en serie.

-------------------------------------------------- -------------------------------------------------- -------------------------------------------------- # 1. Definir el número de pin y la configuración

El primer número de pin de configuración para usar el sensor Hall y establecer el número de pin como un puerto de solo entrada.

Configure la comunicación para verificar los datos del sensor Hall en el monitor en serie.

#define HALL 2

configuración vacía () {pinMode (SALA, ENTRADA); Serial.begin (9600); }

# 2. bucle principal

Compruebe los datos del sensor Hall a intervalos de 0,1 segundos.

Si se detecta el imán y se cambian los datos, el "contacto magnético" se envía al monitor en serie.

bucle vacío () {

if (digitalRead (HALL)) {Serial.println ("contacto magnético"); } retraso (100); }

Paso 12: algoritmo de codificación

* Crear lógica y codificación para controlar Neopixels en función de los valores de los sensores.

1. Pegue y cargue el código a continuación.

2. Es normal que la imagen no se muestre correctamente porque no se produce ningún marco. Pero puedes ver que funciona de manera aproximada.

3. Toque y suelte rápidamente el sensor Hall y el imán en 1 segundo. Repita esta operación unas 10 veces.

4. La configuración está completa cuando los colores de los Neopixels cambian regularmente.

# 1. Incluyendo archivos de encabezado y preprocesamiento

Primero, debemos entender que la memoria del Arduino Mega no es lo suficientemente grande para contener un archivo de imagen.

Por lo tanto, el archivo de encabezado 'avr / pgmspace' se utiliza para utilizar un espacio de memoria diferente.

Para utilizar Neopixels, declara un objeto y configura un número de pin de E / S.

La matriz de imágenes es demasiado grande para la codificación, así que descargue y pegue los archivos adjuntos.

#incluir

#incluya #define PIN 6 #define NUMPIXELS 30 #define HALL 2 Adafruit_NeoPixel strip = Adafruit_NeoPixel (NUMPIXELS, PIN, NEO_RGB + NEO_KHZ800); // pegar matriz en 'image_array_1.txt' // "'image_array_2.txt' //" 'image_array_3.txt' // "'image_array_4.txt'

# 2. Configuración y variable global

Establezca una variable global.

Lo principal es configurar el brillo, se determina el ciclo de vida del producto.

int count = 0;

doble v = 0; double last_v = 0; temporizador doble = micros (); doble ex_timer = micros (); double last_timer = micros (); int grados = 36; int pix = 35; int rgb = 3; doble q_arr [2] = {0, 0}; int HALL_COUNT = 0; doble VELO; temporizador_procesamiento doble = micros (); configuración vacía () {strip.setBrightness (255); strip.begin (); strip.show (); Serial.begin (230400); }

# 3. bucle principal - parte de salida de expresión de imagen

Este código es una declaración condicional sobre cómo generar el tiempo que gira la rueda por resolución.

Esta parte utiliza el ciclo de girar la rueda de la bicicleta una vez como un parámetro muy importante.

Además, es importante leer los datos de la matriz de imágenes de la memoria.

bucle vacío () {

if ((count (ex_timer / 120.0) - (micros () - Processing_timer))) {timer = micros (); if (VELO> 360000) {for (int i = 0 + 5; i <pix; i ++) {strip.setPixelColor (i - 5, strip. Color (pgm_read_byte (& (image_1 [count] [1]))), pgm_read_byte (& (imagen_1 [recuento] [2])), pgm_read_byte (& (imagen_1 [recuento] [0])))); } strip.show (); } else if (VELO 264000) {for (int i = 0 + 5; i <pix; i ++) {strip.setPixelColor (i - 5, strip. Color (pgm_read_byte (& (image_2 [count] [1]))), pgm_read_byte (& (imagen_2 [recuento] [2])), pgm_read_byte (& (imagen_2 [recuento] [0])))); } strip.show (); } else if (VELO 204000) {for (int i = 0 + 5; i <pix; i ++) {strip.setPixelColor (i - 5, strip. Color (pgm_read_byte (& (image_3 [count] [1]))), pgm_read_byte (& (imagen_3 [recuento] [2])), pgm_read_byte (& (imagen_3 [recuento] [0])))); } strip.show (); } else if (VELO <= 204000) {for (int i = 0 + 5; i = 120)) {for (int i = 0 + 5; i <pix; i ++) {strip.setPixelColor (i - 5, strip. Color (0, 0, 0)); } strip.show (); }

# 4. bucle principal: procesamiento y verificación y detección del tiempo de ciclo

Ésta es la parte más importante de todo el sistema.

Primero, verifique el tiempo necesario para ejecutar todo el código y ajuste el tiempo de salida del LED por ciclo.

El tiempo que se detecta cada vez que la rueda gira predice el tiempo del siguiente ciclo.

La aceleración se puede estimar restando el último tiempo de ciclo medido del tiempo de ciclo medido a tiempo.

El sistema calcula el tiempo de procesamiento y la aceleración para calcular cuánto tiempo los LED se encienden continuamente.

temporizador_procesamiento = micros ();

if ((digitalRead (HALL) == HIGH) && (HALL_COUNT == 1)) {VELO = v; v = micros () - último_timer; ex_timer = q_arr [0] - q_arr [1] + v; last_timer = micros (); q_arr [0] = q_arr [1]; q_arr [1] = v; cuenta = 0; HALL_COUNT = 0; } else if (digitalRead (HALL) == LOW) {HALL_COUNT = 1; }}

Paso 13: uso del software

* Utilice software para transformar la imagen e insertar datos de procesión en el código

1. Inserte la imagen del paso anterior en la carpeta de imágenes en la carpeta R. C. P instalada en el paso de preparación.

- Cómo poner imagen es el siguiente.- Renombrar 4 imágenes animadas del producto # 1 en orden de 1.png, 2.png, 3-p.webp

2. Ejecute el archivo Ver.5.exe.

3. Verifique que se hayan creado 12 archivos pro_1_code_1.txt a pro_3_code_4.txt en la carpeta R. C. P.

4. Si no se crea, cambie el contenido de config.txt como el siguiente archivo de configuración.

5. Una vez creado el archivo, copie todo el contenido del archivo pro_1_code_1.txt y péguelo en la parte que se muestra en el código siguiente.

6. Agregue los contenidos pro_1_code_2.txt, pro_1_code_3.txt y pro_1_code_4.txt a la parte marcada en el quinto orden.

7. Refiriéndose a 5 y 6, pro_2_code…, pro_3_code completa el código de la misma manera.

Paso 14: Completar

Completada la producción de un POV que crea una imagen con tres ruedas.