Raspitone: Jukebox facile da usare: 7 passaggi

2024 Autore: John Day | [email protected]. Ultima modifica: 2024-01-30 10:01

Ciao, il mio prossimo progetto è, come di solito faccio, un progetto non molto utile:

Questo è un jukebox basato su un Raspberry 3 B+

Lo so, qualcosa del genere può essere fatto facilmente con uno smartphone e un altoparlante Bluetooth.

Ma per il mio progetto avevo due rigidi prerequisiti:

Volevo fare qualcosa di "vintage".

E nel complesso, dato che la mia signora è definitivamente senza speranza per computer o bluetooth o qualsiasi altra cosa del 21° secolo (e anche del 20°), ho dovuto fare qualcosa di molto semplice da usare………

Quindi, le specifiche erano le seguenti:

Un solo pulsante per avviare la macchina

Un touch screen (molto semplice) per gestire la musica.

Un solo tocco sullo schermo per fermare la macchina.

E per avere un buon suono………

Forniture

Per questo ho usato:

1 Lampone 3 B+

1 vecchio home cinema inutilizzabile a causa del lettore DVD OOS (un vecchio Samsung 2.1 con woofer e 2 altoparlanti che ho modificato per adattarlo alla scatola)

1 scheda HIFIBERRY DIGI+ (con uscita ottica per il finale di potenza)

1 touch screen capacitivo da 7 (il mio è Makeasy per lampone con ingresso HDMI e alimentato tramite USB ma qualsiasi touch screen HDMI dovrebbe essere OK)

1 alimentatore 5V 5A

1 schermo relè

1 Arduino nano per gestire il processo di accensione/spegnimento

1 led IR per pilotare l'home cinema (led pilotato da un transistor NPN 2N2222)

1 ricevitore IR (per l'apprendimento dei codici IR parte del progetto, il mio lo prendo da un vecchio hard disk multimediale con telecomando)

3 led

1 interruttore per la modalità di manutenzione

1 interruttore per lavorare su arduino (durante il caricamento l'arduino viene resettato)

alcuni connettori JST e Dupont

E per la scatola

Legno e compensato (ma non descriverò a fondo la realizzazione della scatola). solo per dire che, per quanto riguarda il boomer all'interno della scatola, sono obbligatori compensato da 10 mm e legno da 18 mm se non si vuole vedere il Jukebox attraversare il soggiorno mentre si gioca!!!!

Passaggio 1: descrizione della parte del lampone:

Il Raspi deve gestire diverse cose:

1) i comandi all'home cinema (tramite telecomando IR)

2) i file musicali

3) il touch screen

4) Il battito cardiaco all'Arduino (che gestisce il Wdt (watch dog timer))

Sono partito da una distribuzione Raspbian strech su una scheda SD da 16 G (Poiché leggeremo solo i file dalla scheda SD, l'uso di un HDD non è necessario). Non spenderò tempo su questa parte perché il web è pieno di tuto a riguardo..

Vediamo le diverse parti nei prossimi passi….

Passaggio 2: i codici del telecomando IR

Non trovando la planimetria dell'home cinema, ho deciso di pilotarlo tramite comandi remoti

Il primo passo che ho dovuto completare è stato quello di imparare a Raspi i codici del telecomando Home cinema. Per questo ho usato l'ottimo tutorial in Instructables dei codici IR di Austin Stanton

Ho avuto alcune differenze, probabilmente dovute alla nuova versione in quanto le istruzioni sono piuttosto vecchie, il file hardware.conf non esiste più (almeno non l'ho trovato)

Sembra anche che il transistor utilizzato nel tuto sia un transistor PNP, da parte mia ho usato un 2N2222 che è NPN ma il risultato è lo stesso. (tranne il cablaggio !!!!!!!!)

L'assegnazione dei pin è data in /boot/config.txt:

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

Il LED IR andrà così collegato al pin22 del Raspi.

Un'osservazione importante: quando si imparano i codici a Raspi è obbligatorio usare le parole chiave elencate nel comando

irrecord --list-namespace

Ecco il file che ho creato per il mio jukebox:

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

# Prenditi il tempo necessario per completare questo file come descritto in # https://sourceforge.net/p/lirc-remotes/wiki/Check… # e rendilo disponibile ad altri inviandolo a # #

# Questo file di configurazione è stato generato automaticamente

# using lirc-0.9.4c(default) on Thu May 9 17:33:37 2019 # Riga di comando utilizzata: -d /dev/lirc0 /root/lircd.conf

# Versione del kernel (uname -r): 4.14.98-v7+ # # Nome remoto (come da file di configurazione): jukebox

# Marca del dispositivo remoto, la cosa che tieni in mano: # Modello del dispositivo remoto nr:

# URL informazioni dispositivo remoto:

# Il dispositivo remoto ha un dispositivo di acquisizione in bundle e. g., a

# chiavetta USB?:

# Per i dispositivi USB in bundle: ID fornitore USB, ID prodotto

# e stringa del dispositivo (usa dmesg o lsusb):

# Tipo di dispositivo controllato

# (TV, VCR, Audio, DVD, Satellite, Cavo, HTPC, …):

# Dispositivo/i controllato/i da questo telecomando:

iniziare a distanza

nome jukebox

bit 16

flag SPACE_ENC|CONST_LENGTH

eps 30

aeps 100

testata 4470 4496

uno 542 1693

zero 542 581

ptrail 553

pre_data_bits 16

pre_data 0xC2CA

distanza 107863

toggle_bit_mask 0x0

frequenza 38000

codici di inizio

KEY_POWER 0x807F

KEY_AUX 0x8877

KEY_VOLUMEUP 0xCC33

KEY_VOLUMEDOWN 0xDC23

codici finali

fine remoto

Come puoi vedere, ho solo bisogno di 4 comandi per guidare l'Home Cinema

Alimentazione (ON/OFF)

AUX => per passare al canale di ingresso ottico (poiché l'HC si avvia sempre sul lettore DVD)

E volume +/-

I relativi comandi vengono eseguiti tramite i comandi LIRC:

ad esempio: "irsend SEND_ONCE jukebox KEY_VOLUMEUP"

Passaggio 3: programma principale

Il programma principale è scritto in Python:

Dato che sono nuovo in Python, immagino che ci siano molti miglioramenti che si possono fare, ma funziona…

Le specifiche:

1) gestire la schermata grafica:

Per questo, ho usato APPJAR che è TKINTER ma civilizzato per studenti (il mio caso), questo significa molto più facile da usare, probabilmente con meno possibilità, ma era sufficiente per il mio scopo.

2) riprodurre i file mp3:

Ho usato mplayer per Python.

3) generare numeri casuali per la riproduzione in modalità casuale:

Dato che non volevo ascoltare la stessa canzone ogni trimestre, ho creato un piccolo programma per verificare se il numero non era presente nell'elenco x dei numeri precedenti (x dipende dalla lunghezza della playlist).

La funzione randint in Python non è così "casuale" per quanto ho visto.

4) invia il "battito del cuore" ad Arduino

5) gestire i file player:

Poiché Mplayer è asincrono, quando il file viene avviato non c'è modo di sapere per Python quando è finito (almeno non ho trovato un modo semplice)

Per risolverlo ho usato i comandi mplayer dando la lunghezza del file e l'avanzamento nel file corrente

Sia per 4 che per 5 ho usato la possibilità data da Appjar di generare un task periodico (dato che appjar è un programma di eventi questo è un modo per creare un evento periodico). la funzione è:

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

p.setPollTime(1000)

Taskman per "task manager" che è un def nel programma che gestisce tutti gli eventi che non sono sullo schermo (fine del file riprodotto, popola la barra di avanzamento, invia il battito cardiaco a Nano, ….)

Una volta avviato lo schermo si presenta così:

Ecco il programma: (può essere aperto tramite Notepad ++ o Geany)

Passaggio 4: parte Raspberry: avvio automatico e aggiunta di nuovi file

Se guardi il programma puoi vedere che uso alcuni file bash:

1) Start_jukebox:

Infatti lo scopo è quello di accendere l'Home cinema e passare all'ingresso D. IN (ingresso ottico nel mio Home cinema)

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

invia il jukebox SEND_ONCE KEY_POWER

dormire 7

invia il jukebox SEND_ONCE KEY_AUX

dormire 2

2) stop_jukebox:

Per spegnere l'Home Cinema

pi@raspitone:/bin $ cat stop_jukebox

#!/bin/bash

invia il jukebox SEND_ONCE KEY_POWER

Questi due file bash vengono chiamati da Python con il comando os.system

Per avviare lo script Python ho fatto una piccola bash

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

cd /home/pi

python jukebox_gui.py

Per l'avvio automatico in modalità GUI ho appena modificato il file di avvio automatico in /etc/xdg/lxsession/LXDE-pi

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

@pcmanfm --desktop --profile LXDE-pi

@xscreensaver -no-splash

@lxterminal --command="dem_jukebox.bash"

punto-rpi

Aggiunta di nuovi file mp3:

Per aggiungere nuovi file, ho preferito creare un piccolo script Python dedicato:

new_song_file.py

Spiegherò prima l'organizzazione dei file di sistema:

Tutti i file sono in /home/pi

i file mp3 sono memorizzati nella directory /home/pi/Music

Ogni artista ha la sua sottodirectory che ospita i relativi file mp3

pi@raspitone:~/Music/Mike_oldfield $ ls -ltotal 760516

-rwxr----- 1 pi pi 2254923 30 giugno 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 30 giugno 2017 Castaway.mp3

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

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

-rwxr----- 1 pi pi 9403263 30 giugno 2017 Chariots.mp3

Nella directory Documenti possiamo trovare l'elenco dei file da riprodurre.

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

Franz_Ferdinand/evil_and_a_heathen.mp3

Franz_Ferdinand/Walk_Away_live.mp3

Franz_Ferdinand/love_and_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

Possiamo anche trovare i dati delle playlist (ma questo è costruito dallo script Python)

Il piccolo script Python aggiunge i nuovi brani, salvati in Musica, nel file list.txt dopo aver formattato i titoli in formato UNIX

Ecco lo script: (può essere aperto tramite Notepad ++ o Geany)

Passaggio 5: la gestione dell'alimentazione tramite Arduino Nano

Poiché volevo avere qualcosa di facile da iniziare, ho deciso di farlo fare da un piccolo nano:

Il principio:

Premendo il pulsante di avvio i dispositivi sono tutti alimentati, il nano si avvia (1 o 2 secondi) e assume la gestione dell'alimentazione attivando un relè che devia i contatti del pulsante.

Quindi Nano attende 35 secondi per ricevere l'heartbeat da Raspberry (significa che il processo di avvio è completo e il programma jukebox viene eseguito).

Finché nano riceve il battito cardiaco, mantiene attivo il relè (timer del cane da guardia)

Se non c'è più battito (significa che il programma del jukebox è fermo) Nano attende 20 secondi (per essere sicuro che il raspi sia completamente fermo) per rilasciare il relè di potenza.

Il jukebox viene quindi completamente spento

Ho aggiunto uno switch per attivare un input del nano per indicare la modalità di manutenzione (uso il jukebox per gestire gli altri miei server raspi tramite ssh et vnc). Nano quindi disattiva il processo di watch dog

Nota:

l'input per il battito cardiaco di Raspi deve essere abbassato (ma il 3.3V di Raspi è considerato di alto livello da Nano)

Potrebbe essere fatto con NE555 ma sono pigro e ho sempre dei nano nel mio cassetto !!!!

Ecco il breve programma C (può essere aperto con Notepad++)

Passaggio 6: il cablaggio

Per lo schermo:

Un cavo HDMI e un cavo USB vengono utilizzati su Raspi per alimentare e pilotare lo schermo.

Per il pannello frontale:

Dal Raspi viene anche collegato un cavo USB per poter caricare nuovi file o effettuare backup.

Un cavo USB è collegato dal Nano per poter accedere al software (per modifiche se necessario)

Inserisco anche un dongle per tastiera wireless sul lampone per poter effettuare la manutenzione senza utilizzare la presa USB esterna

Poiché vengono utilizzati Raspberry e Arduino, il cablaggio è piuttosto semplice.

Tutto si trova su una scheda matrice a strisce.

Da lampone 2 GPIO vengono utilizzati:

Pin22 per LED IR

Pin 27 per il battito cardiaco ad Arduino

su Arduino

Il pin 2 viene utilizzato come pin di interruzione per il battito cardiaco di Raspi.

I pin da 3 a 5 sono utilizzati per pilotare i led (Start, Wdt, Maintenance).

Il pin 6 è per l'interruttore di manutenzione.

Il pin 7 è in uscita allo schermo del relè.

Ecco il file fritzing:

Passaggio 7: la scatola

Non descriverò molto quello che ho fatto in quanto dipende dall'amplificatore di potenza e dagli altoparlanti utilizzati.

Come informazioni l'home cinema si trova nella parte inferiore della scatola.

Appena sopra gli altoparlanti:

1 woofer

2 altoparlanti medi, che ho modificato per inserirli nella scatola.

Sulla cima:

Il pannello frontale con lo schermo, i LED, gli interruttori e le prese USB.

Il legno:

Per i diffusori, i pannelli laterali, la parte superiore e quella inferiore, ho utilizzato una tavola di legno da 18 mm.

Il lato anteriore è in compensato da 10 mm con viti da 40 mm.

Per facilitare il cablaggio e la manutenzione (se serve!!!) ho messo la circuiteria in un cassetto dietro il pannello frontale

Per evitare il surriscaldamento è stato fatto un grosso foro sul fondo del pannello posteriore e ho messo una ventola da 5V (8 cm) sul pannello posteriore proprio accanto ai circuiti.

La foto sopra è solo per dare un'idea.

Allora è così!!!!!!!!!

Grazie per avermi letto

E alla prossima per nuove avventure