Raspitone: Jukebox fácil de usar: 7 pasos

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

Hola, mi próximo proyecto es, como solía hacer, un proyecto poco útil:

Esta es una máquina de discos basada en una Raspberry 3 B +

Lo sé, algo como esto se puede hacer fácilmente con un teléfono inteligente y un altavoz Bluetooth.

Pero para mi proyecto, tenía dos requisitos previos difíciles:

Quería hacer algo "vintage".

Y en general, dado el hecho de que mi señora definitivamente no tiene esperanzas para la computadora o el bluetooth o cualquier otra cosa del siglo XXI (e incluso del siglo XX), tuve que hacer algo muy simple de usar … …

Entonces, las especificaciones fueron las siguientes:

Un solo botón para encender la máquina

Una pantalla táctil (muy sencilla) para gestionar la música.

Un solo toque en la pantalla para detener la máquina.

Y tener un buen sonido ………

Suministros

Para esto utilicé:

1 frambuesa 3 B +

1 cine en casa antiguo que no sirvió de nada debido al lector de DVD OOS (un antiguo Samsung 2.1 con un woofer y 2 altavoces que modifiqué para encajar en la caja)

1 placa HIFIBERRY DIGI + (con salida óptica para el amplificador de potencia)

1 pantalla táctil capacitiva de 7 (la mía es Makeasy para frambuesa con entrada HDMI y se alimenta a través de USB, pero cualquier pantalla táctil HDMI debería estar bien)

1 fuente de alimentación 5V 5A

1 escudo de relé

1 Arduino nano para gestionar el proceso de encendido / apagado

1 LED IR para controlar el cine en casa (LED impulsado por un transistor NPN 2N2222)

1 receptor de infrarrojos (para los códigos de infrarrojos que aprenden parte del proyecto, obtengo el mío de un antiguo disco duro multimedia con mando a distancia)

3 leds

1 interruptor para modo de mantenimiento

1 interruptor para trabajar en el arduino (durante la carga, el arduino se reinicia)

algunos conectores JST y Dupont

Y para la caja

Madera y madera contrachapada (pero no describiré en profundidad la fabricación de la caja). solo para decir que, con respecto al boomer dentro de la caja, el contrachapado de 10 mm y la madera de 18 mm son obligatorios si no quieres ver el Jukebox cruzando la sala de estar mientras juegas.

Paso 1: Descripción de la parte de frambuesa:

La Raspi tiene que gestionar diferentes cosas:

1) los comandos para el cine en casa (a través del mando a distancia por infrarrojos)

2) los archivos de música

3) la pantalla táctil

4) El latido del Arduino (que administra el Wdt (temporizador del perro guardián))

Comencé con una distribución de strech de Raspbian en una tarjeta SD de 16 G (como solo leemos archivos de la tarjeta SD, no es necesario el uso de un disco duro). No dedicaré tiempo a esta parte ya que la web está llena de tuto al respecto.

Veamos las diferentes partes en los siguientes pasos….

Paso 2: los códigos del mando a distancia por infrarrojos

Como no pude encontrar el plano del circuito del cine en casa, decidí conducirlo a través de comandos remotos.

El primer paso que tuve que completar fue aprender a Raspi los códigos del mando a distancia del Home cinema. Para eso utilicé el muy buen tuto en Instructables de Austin Stanton IR codes

Tuve algunas diferencias, probablemente debido a la nueva versión ya que los instructables son bastante antiguos, el archivo hardware.conf ya no existe (al menos no lo encontré)

Parece también que el transistor usado en el tuto es un transistor PNP, por mi parte usé un 2N2222 que es NPN pero el resultado es el mismo. (Excepto el cableado !!!!!!!!)

La asignación de pines se da en /boot/config.txt:

#autorisation de lirc le 08/07 / 2019dtoverlay = lirc-rpi, gpio_out_pin = 22, gpio_in_pin = 23

El LED de infrarrojos estará conectado al pin 22 de la Raspi.

Un comentario importante: al aprender los códigos a Raspi, es obligatorio utilizar las palabras clave enumeradas en el comando

irrecord --list-namespace

Aquí está el archivo que construí para mi jukebox:

pi @ raspitone: / etc / lirc $ cat lircd.conf

# Tómese el tiempo para terminar este archivo como se describe en # https://sourceforge.net/p/lirc-remotes/wiki/Check… # y póngalo a disposición de otros enviándolo a # #

# Este archivo de configuración se generó automáticamente

# usando lirc-0.9.4c (predeterminado) el jueves 9 de mayo 17:33:37 2019 # Línea de comando usada: -d / dev / lirc0 /root/lircd.conf

# Versión del kernel (uname -r): 4.14.98-v7 + # # Nombre remoto (a partir del archivo de configuración): jukebox

# Marca del dispositivo remoto, lo que tiene en la mano: # Modelo de dispositivo remoto nr:

# URL de información del dispositivo remoto:

# ¿El dispositivo remoto tiene un dispositivo de captura incluido e. g., un

# ¿dispositivo USB?:

# Para dispositivos USB incluidos: ID de proveedor de USB, ID de producto

# y cadena de dispositivo (use dmesg o lsusb):

# Tipo de dispositivo controlado

# (TV, VCR, Audio, DVD, Satélite, Cable, HTPC,…):

# Dispositivo (s) controlados por este control remoto:

comenzar a distancia

jukebox de nombre

bits 16

banderas SPACE_ENC | CONST_LENGTH

eps 30

aeps 100

encabezado 4470 4496

uno 542 1693

cero 542581

ptrail 553

pre_data_bits 16

pre_data 0xC2CA

brecha 107863

toggle_bit_mask 0x0

frecuencia 38000

comenzar códigos

KEY_POWER 0x807F

KEY_AUX 0x8877

KEY_VOLUMEUP 0xCC33

KEY_VOLUMEDOWN 0xDC23

códigos finales

final remoto

Como puede ver, solo necesito 4 comandos para manejar el Home Cinema

Encendido / apagado)

AUX => para cambiar al canal de entrada óptico (ya que el HC siempre se inicia en el lector de DVD)

Y volumen +/-

Los comandos relacionados se ejecutan a través de los comandos LIRC:

por ejemplo: "irsend SEND_ONCE jukebox KEY_VOLUMEUP"

Paso 3: Programa principal

El programa principal está escrito en Python:

Como soy nuevo en Python, creo que hay muchas mejoras que se pueden hacer, pero funciona….

Las especificaciones:

1) administrar la pantalla gráfica:

Para esto, usé APPJAR que es TKINTER pero civilizado para estudiante (mi caso), esto significa mucho más fácil de usar, probablemente con menos posibilidades, pero fue suficiente para mi propósito.

2) reproduce los archivos mp3:

Usé mplayer para python.

3) generar números aleatorios para jugar en modo aleatorio:

Como no quería escuchar la misma canción cada trimestre, construí un pequeño programa para verificar si el número no estaba presente en la lista de x números anteriores (x dependiendo de la longitud de la lista de reproducción).

La función randint en Python no es tan "aleatoria" por lo que vi.

4) envía el "latido" al Arduino

5) administrar el reproductor de archivos:

Como Mplayer es asincrónico, cuando se inicia el archivo, no hay forma de saber si Python está terminado (al menos no encontré una manera simple)

Para resolver que utilicé los comandos mplayer dando la longitud del archivo y el progreso en el archivo actual

Tanto para 4 como para 5 utilicé la posibilidad dada por Appjar para generar una tarea periódica (como appjar es un programa de eventos, esta es una forma de crear un evento periódico). la función es:

# ******************* start taskman ********************* app.registerEvent (taskman)

p.setPollTime (1000)

Taskman para "administrador de tareas", que es una definición en el programa que administra todos los eventos que no son de pantalla (final del archivo reproducido, completar la barra de progreso, enviar latidos a Nano,….)

Una vez iniciada, la pantalla se ve así:

Aquí está el programa: (se puede abrir a través de Notepad ++ o Geany)

Paso 4: parte de la frambuesa: inicio automático y adición de nuevos archivos

Si miras el programa, puedes ver que utilizo algunos archivos bash:

1) Start_jukebox:

De hecho, el propósito es encender el cine en casa y cambiar a la entrada D. IN (entrada óptica en mi cine en casa)

pi @ raspitone: / bin $ cat start_jukebox #! / bin / bash

irsend SEND_ONCE jukebox KEY_POWER

dormir 7

irsend SEND_ONCE jukebox KEY_AUX

dormir 2

2) stop_jukebox:

Para apagar el cine en casa

pi @ raspitone: / bin $ cat stop_jukebox

#! / bin / bash

irsend SEND_ONCE jukebox KEY_POWER

Python llama a estos dos archivos bash con el comando os.system

Para iniciar el script de Python hice un pequeño bash

pi @ raspitone: ~ $ cat dem_jukebox.bash #! / bin / bash

cd / home / pi

python jukebox_gui.py

Para el inicio automático en modo GUI, acabo de modificar el archivo de inicio automático en / etc / xdg / lxsession / LXDE-pi

pi @ raspitone: / etc / xdg / lxsession / LXDE-pi $ cat autostart @ lxpanel --perfil LXDE-pi

@pcmanfm --desktop --profile LXDE-pi

@xscreensaver -no-splash

@lxterminal --command = "dem_jukebox.bash"

punto-rpi

Adición de nuevos archivos mp3:

Para agregar nuevos archivos, preferí hacer un pequeño script Python dedicado:

new_song_file.py

Primero explicaré la organización de los archivos del sistema:

Todos los archivos están en / home / pi

Los archivos mp3 se almacenan en el directorio / home / pi / Music

Cada artista tiene su propio subdirectorio que aloja los archivos mp3 relacionados.

pi @ raspitone: ~ / Música / Mike_oldfield $ ls -ltotal 760516

-rwxr ----- 1 pi pi 2254923 juin 30 2017 A_New_Beginning.mp3

-rwxr ----- 1 pi pi 2691736 juin 30 2017 Arrival.mp3

-rwxr ----- 1 pi pi 8383244 juin 30 2017 Ascension.mp3

-rwxr ----- 1 pi pi 5410816 juin 30 2017 Blue_Night.mp3

-rwxr ----- 1 pi pi 13125199 juin 30 2017 Castaway_ (Instrumental).mp3

-rwxr ----- 1 pi pi 12903583 juin 30 2017 Castaway.mp3

-rwxr ----- 1 pi pi 2969869 juin 30 2017 Celt.mp3

-rwxr ----- 1 pi pi 9047745 juin 30 2017 Chariots_ (Instrumental).mp3

-rwxr ----- 1 pi pi 9403263 juin 30 2017 Carros.mp3

En el directorio Documentos podemos encontrar la lista construida de archivos para reproducir.

pi @ raspitone: ~ / Documentos $ cat list.txtFranz_Ferdinand / Michael_live.mp3

Franz_Ferdinand / evil_and_a_heathen.mp3

Franz_Ferdinand / Walk_Away_live.mp3

Franz_Ferdinand / amor_y_destroy.mp3

Franz_Ferdinand / his_fffire.mp3

Franz_Ferdinand / eleanor_put_your_boots_on.mp3

Franz_Ferdinand / missing_you.mp3

Franz_Ferdinand / this_fire_ (playgroup_remix).mp3

Franz_Ferdinand / Jacqueline.mp3

También podemos encontrar los datos de las listas de reproducción (pero esto está construido por el script de Python)

El pequeño script de Python agrega las nuevas canciones, guardadas en Música, en el list.txt después de haber formateado los títulos en formato UNIX.

Aquí está el script: (se puede abrir a través de Notepad ++ o Geany)

Paso 5: la gestión de energía a través de Arduino Nano

Como quería tener algo fácil para comenzar, decidí hacerlo con un pequeño nano:

El principio:

Al presionar el botón de inicio, todos los dispositivos están encendidos, el nano se inicia (1 o 2 segundos) y se hace cargo de la administración de energía activando un relé que desvía los contactos del botón.

Luego, Nano espera 35 segundos para recibir el latido de Raspberry (significa que el proceso de inicio está completo y se ejecuta el programa jukebox).

Mientras nano reciba el latido del corazón, mantiene el relé encendido (temporizador de perro guardián)

Si ya no hay latidos (significa que el programa de la máquina de discos está detenido), Nano espera 20 segundos (para asegurarse de que el raspi esté completamente detenido) para liberar el relé de potencia.

Luego, la máquina de discos se apaga por completo.

Agregué un interruptor para activar una entrada del nano para indicar el modo de mantenimiento (uso el jukebox para administrar mis otros servidores raspi a través de ssh et vnc). Nano luego desactiva el proceso de perro guardián

Observación:

la entrada para el latido del corazón de Raspi debe reducirse (pero Nano considera que los 3.3V de Raspi son de alto nivel)

¡Se podría hacer con NE555 pero soy holgazán y siempre tengo algunos nano en mi cajón!

Aquí está el programa corto en C (se puede abrir con Notepad ++)

Paso 6: el cableado

Para la pantalla:

Un cable HDMI y un cable USB se utilizan en Raspi para alimentar y controlar la pantalla.

Para el panel frontal:

También se conecta un cable USB desde la Raspi para poder subir nuevos archivos o hacer copias de seguridad.

Se conecta un cable USB desde el Nano para poder acceder al software (para modificaciones si es necesario)

También conecto un dongle de teclado inalámbrico en la frambuesa para poder realizar el mantenimiento sin usar el conector USB externo

Como se utilizan Raspberry y Arduino, el cableado es bastante simple.

Todo está ubicado en una placa de matriz de tiras.

De la frambuesa se utilizan 2 GPIO:

Pin22 para LED IR

Pin 27 para latido a Arduino

en Arduino

El pin 2 se utiliza como pin de interrupción para el latido de Raspi.

Los pines 3 a 5 se utilizan para activar los LED (Inicio, Wdt, Mantenimiento).

El pin 6 es para el interruptor de mantenimiento.

El pin 7 se envía al blindaje del relé.

Aquí está el archivo fritzing:

Paso 7: la caja

No describiré mucho lo que hice, ya que depende del amplificador de potencia y de los altavoces utilizados.

Como información, el cine en casa se encuentra en la parte inferior de la caja.

Justo por encima de los altavoces:

1 altavoz de graves

2 altavoces medianos, que modifiqué para insertarlos en la caja.

En la parte superior:

El panel frontal con la pantalla, los LED, los interruptores y los enchufes USB.

La madera:

Para los altavoces, los paneles laterales de la parte superior e inferior utilicé un tablón de madera de 18 mm.

La parte frontal es de madera contrachapada de 10 mm con tornillos de 40 mm.

Para facilitar el cableado y el mantenimiento (¡si es necesario!), Coloco los circuitos en un cajón detrás del panel frontal.

Para evitar el sobrecalentamiento, se hace un gran agujero en la parte inferior del panel trasero y coloco un ventilador de 5V (8 cm) en el panel trasero justo al lado del circuito.

La imagen de arriba es solo para dar una idea.

Eso es todo !!!!!!!!!

Gracias por leerme

Y nos vemos la próxima vez para nuevas aventuras