Raspitone: Jukebox fácil de usar: 7 etapas

2024 Autor: John Day | [email protected]. Última modificação: 2024-01-30 11:36

Olá, meu próximo projeto é, como costumo fazer, um projeto não muito útil:

Esta é uma jukebox baseada em um Raspberry 3 B +

Eu sei, algo assim pode ser feito facilmente com um smartphone e um alto-falante Bluetooth.

Mas para meu projeto, eu tinha dois pré-requisitos rígidos:

Eu queria fazer algo "vintage".

E no geral, dado o fato de que minha senhora está definitivamente sem esperança para computador ou bluetooth ou qualquer outra coisa do século 21, (e até mesmo do século 20), eu tive que fazer algo muito simples de usar ………

Portanto, as especificações eram as seguintes:

Um único botão para iniciar a máquina

Um ecrã táctil (muito simples) para gerir a música.

Um único toque na tela para parar a máquina.

E para ter um bom som ………

Suprimentos

Para isso usei:

1 framboesa 3 B +

1 home cinema antigo que era inútil devido ao leitor de DVD OOS (um Samsung 2.1 antigo com um woofer e 2 alto-falantes que modifiquei para caber na caixa)

1 placa HIFIBERRY DIGI + (com saída óptica para o amplificador de potência)

1 tela de toque capacitiva de 7 (a minha é Makeasy para framboesa com entrada HDMI e alimentada via USB, mas qualquer tela de toque HDMI deve funcionar bem)

1 fonte de alimentação 5V 5A

1 escudo de relé

1 Arduino nano para gerenciar o processo de LIGAR / DESLIGAR

1 IR conduzido para conduzir o home cinema (conduzido por um transistor NPN 2N2222)

1 receptor IR (para a parte de aprendizagem dos códigos IR do projeto, eu pego o meu em um disco rígido multimídia antigo com comando remoto)

3 led's

1 interruptor para modo de manutenção

1 interruptor para trabalhar no arduino (durante o upload, o arduino é reiniciado)

alguns conectores JST e Dupont

E para a caixa

Madeira e compensado (mas não descreverei profundamente a confecção da caixa). Só para dizer que, em relação ao boomer dentro da caixa, o compensado 10 mm e a madeira 18 mm são obrigatórios se você não quiser ver a Jukebox atravessando a sala enquanto joga !!!!

Etapa 1: Descrição da parte da framboesa:

O Raspi precisa gerenciar coisas diferentes:

1) os comandos para o home cinema (via controle remoto IR)

2) os arquivos de música

3) a tela de toque

4) A pulsação do Arduino (que gerencia o Wdt (watch dog timer))

Comecei a partir de uma distribuição Raspbian strech em um cartão SD 16 G (como iremos apenas ler arquivos do cartão SD, o uso de um HDD não é necessário). Não vou perder tempo com essa parte porque a web está cheia de tuto sobre isso..

Vamos ver as diferentes partes nas próximas etapas….

Etapa 2: Os Códigos Remotos IR

Como não consegui encontrar o plano de circuito do home cinema, decidi conduzi-lo por comandos remotos

O primeiro passo que tive de concluir foi aprender a Raspi os códigos do comando remoto do cinema em casa. Para isso usei o muito bom tuto em Instructables de Austin Stanton IR codes

Tive algumas diferenças, provavelmente devido à nova versão, pois os instructables são bastante antigos, o arquivo hardware.conf não existe mais (pelo menos não o encontrei)

Parece também que o transistor usado no tuto é um transistor PNP, da minha parte usei um 2N2222 que é NPN mas o resultado é o mesmo. (Exceto o cabeamento !!!!!!!!)

A atribuição do pin é fornecida em /boot/config.txt:

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

O LED IR será conectado ao pino 22 do Raspi.

Uma observação importante: ao aprender os códigos para Raspi é obrigatório usar as palavras-chave listadas no comando

irrecord --list-namespace

Aqui está o arquivo que criei para minha jukebox:

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

# Por favor, dedique algum tempo para terminar este arquivo conforme descrito em # https://sourceforge.net/p/lirc-remotes/wiki/Check… # e torná-lo disponível para outras pessoas enviando-o para # #

# Este arquivo de configuração foi gerado automaticamente

# using lirc-0.9.4c (padrão) em Thu May 9 17:33:37 2019 # Linha de comando usada: -d / dev / lirc0 /root/lircd.conf

# Versão do kernel (uname -r): 4.14.98-v7 + # # Nome remoto (a partir do arquivo de configuração): jukebox

# Marca do dispositivo remoto, aquilo que você segura na mão: # Número do modelo do dispositivo remoto:

# URL de informações do dispositivo remoto:

# O dispositivo remoto possui um dispositivo de captura agrupado e. g., a

# usb dongle?:

# Para dispositivos USB incluídos: usb vendor id, product id

# e string de dispositivo (use dmesg ou lsusb):

# Tipo de dispositivo controlado

# (TV, VCR, Áudio, DVD, Satélite, Cabo, HTPC, …):

# Dispositivo (s) controlado (s) por este controle remoto:

começar remoto

nome jukebox

bits 16

sinalizadores SPACE_ENC | CONST_LENGTH

eps 30

aeps 100

cabeçalho 4470 4496

um 542 1693

zero 542 581

ptrail 553

pre_data_bits 16

pre_data 0xC2CA

lacuna 107863

toggle_bit_mask 0x0

frequência 38.000

começar códigos

KEY_POWER 0x807F

KEY_AUX 0x8877

KEY_VOLUMEUP 0xCC33

KEY_VOLUMEDOWN 0xDC23

códigos finais

fim remoto

Como você pode ver, só preciso de 4 comandos para acionar o Home Cinema

Energia (LIGADO / DESLIGADO)

AUX => para mudar para o canal de entrada óptica (como o HC sempre começa no leitor de DVD)

E Volume +/-

Os comandos relacionados são executados por meio dos comandos LIRC:

por exemplo: "irsend SEND_ONCE jukebox KEY_VOLUMEUP"

Etapa 3: Programa Principal

O programa principal é escrito em Python:

Como sou novo em Python, acho que há muitas melhorias que podem ser feitas, mas funciona….

As especificações:

1) gerenciar a tela gráfica:

Para isso, usei o APPJAR que é TKINTER mas civilizado para aluno (o meu caso), isso significa muito mais fácil de usar, provavelmente com menos possibilidades, mas foi o suficiente para o meu propósito.

2) reproduzir os arquivos mp3:

Usei o mplayer para python.

3) gerar números aleatórios para jogar no modo aleatório:

Como não queria ouvir a mesma música a cada trimestre, construí um pequeno programa para verificar se o número não estava presente na lista de x números anteriores (x dependendo da duração da playlist).

A função randint em python não é tão "aleatória" até onde eu vi.

4) enviar a "pulsação" para o Arduino

5) gerenciar o reprodutor de arquivos:

Como o Mplayer é assíncrono, quando o arquivo é iniciado não há como saber para o Python quando ele é finalizado (pelo menos não encontrei uma maneira simples)

Para resolver isso, usei os comandos do mplayer informando o comprimento do arquivo e o progresso no arquivo atual

Para 4 e 5, usei a possibilidade dada pelo Appjar para gerar uma tarefa periódica (como appjar é um programa de evento, esta é uma forma de criar um evento periódico). a função é:

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

p.setPollTime (1000)

Taskman para o "gerenciador de tarefas", que é uma definição no programa que gerencia tudo o que não é eventos da tela (fim do arquivo reproduzido, preencher a barra de progresso, enviar batimento cardíaco para o Nano, …)

Depois de iniciada, a tela fica assim:

Aqui está o programa: (pode ser aberto via Notepad ++ ou Geany)

Etapa 4: parte da framboesa: início automático e adição de novos arquivos

Se você olhar para o programa, verá que uso alguns arquivos bash:

1) Start_jukebox:

Na verdade, o objetivo é ligar o cinema em casa e mudar para a entrada D. IN (entrada óptica no meu cinema em 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 desligar o cinema em casa

pi @ raspitone: / bin $ cat stop_jukebox

#! / bin / bash

irsend SEND_ONCE jukebox KEY_POWER

Esses dois arquivos bash são chamados pelo Python com o comando os.system

Para iniciar o script Python eu fiz um pequeno bash

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

cd / home / pi

python jukebox_gui.py

Para o início automático no modo GUI, acabei de modificar o arquivo de início automático em / 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"

point-rpi

Adicionando novos arquivos mp3:

Para adicionar novos arquivos, preferi fazer um pequeno script Python dedicado:

new_song_file.py

Vou primeiro explicar a organização dos arquivos do sistema:

Todos os arquivos estão em / home / pi

Os arquivos mp3 são armazenados no diretório / home / pi / Music

Cada artista tem seu próprio subdiretório que hospeda os arquivos mp3 relacionados

pi @ raspitone: ~ / Music / 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 30 de junho de 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 junho 30 2017 Chariots_ (Instrumental).mp3

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

No diretório Documentos, podemos encontrar a lista construída de arquivos para reproduzir.

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

Também podemos encontrar os dados das listas de reprodução (mas isso é construído pelo script Python)

O pequeno script Python adiciona as novas canções, salvas em Música, no list.txt após ter formatado os títulos no formato UNIX

Aqui está o script: (pode ser aberto via Notepad ++ ou Geany)

Etapa 5: o gerenciamento de energia via Arduino Nano

Como eu queria ter algo fácil para começar, decidi fazê-lo por um pequeno nano:

O princípio:

Ao apertar o botão de início, os dispositivos são todos energizados, o nano inicia (1 ou 2 segundos) e assume o gerenciamento de energia acionando um relé que desvia os contatos do botão.

Em seguida, o Nano aguarda 35 segundos para receber a pulsação do Raspberry (significa que o processo de inicialização está concluído e o programa da jukebox é executado).

Enquanto o nano receber o batimento cardíaco, ele mantém o relé ligado (cronômetro de vigilância)

Se não houver mais pulsação (significa que o programa da jukebox está parado), o Nano espera 20 segundos (para ter certeza de que o raspi está completamente parado) para liberar o relé de energia.

A jukebox é totalmente desligada

Eu adicionei um switch para ativar uma entrada do nano para indicar o modo de manutenção (eu uso a jukebox para gerenciar meus outros servidores raspi via ssh et vnc). O Nano então desativa o processo do cão de guarda

Observação:

a entrada para a pulsação do Raspi precisa ser puxada para baixo (mas o 3,3 V do Raspi é considerado de alto nível pelo Nano)

Poderia ser feito com NE555, mas eu sou preguiçoso e sempre tenho alguns nano's na minha gaveta !!!!

Aqui está o programa C curto (pode ser aberto com o Notepad ++)

Etapa 6: o cabeamento

Para a tela:

Um cabo HDMI e um cabo USB são usados no Raspi para alimentar e conduzir a tela.

Para o painel frontal:

Um cabo USB também é conectado a partir do Raspi para poder carregar novos arquivos ou fazer backups.

Um cabo USB é conectado do Nano para ser capaz de acessar o software (para modificações, se necessário)

Também ligo um dongle de teclado sem fio no raspberry para poder fazer manutenção sem usar o plugue USB externo

Como o Raspberry e o Arduino são usados, o cabeamento é bastante simples.

Tudo está localizado em uma placa de matriz de tira.

De raspberry 2 GPIO são usados:

Pin22 para LED IV

Pin 27 para heartbeat para Arduino

no Arduino

O pino 2 é usado como um pino de interrupção para a pulsação do Raspi.

Os pinos 3 a 5 são usados para acionar os LEDs (Iniciar, Wdt, Manutenção).

O pino 6 é para a chave de manutenção.

O pino 7 é enviado para a blindagem do relé.

Aqui está o arquivo fritzing:

Etapa 7: a caixa

Não vou descrever muito o que fiz, pois depende do amplificador de potência e dos alto-falantes usados.

Como informação, o home cinema está localizado na parte inferior da caixa.

Apenas nos alto-falantes:

1 woofer

2 alto-falantes médios, que modifiquei para inseri-los na caixa.

No topo:

O painel frontal com a tela, os LEDs, os interruptores e os plugues USB.

A Madeira:

Para os alto-falantes, os painéis laterais superior e inferior eu usei prancha de madeira de 18 mm.

A parte frontal é em contraplacado de 10 mm com parafusos de 40 mm.

Para facilitar o cabeamento e a manutenção (se necessário !!!) coloquei os circuitos em uma gaveta atrás do painel frontal

Para evitar superaquecimento, um grande orifício é feito na parte inferior do painel traseiro e coloquei uma ventoinha de 5V (8 cm) no painel traseiro ao lado do circuito.

A foto acima é apenas para dar uma ideia.

Então é isso !!!!!!!!!

Obrigado por me ler

E até a próxima para novas aventuras