RPi 3 Estibordo / Gerador de partículas: 6 etapas (com imagens)

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

Você está se sentindo entediado com seu Raspberry Pi? Você está pronto para comandar as próprias forças elementais do universo, convocando e dispensando fótons à vontade? Você quer apenas algo interessante para pendurar na sua sala, ou um projeto chique para postar no Facebook para mostrar a Denise que você está indo muito bem atualmente, muito obrigado? Você está preso em uma simulação de computador e passando horas até ser libertado ou excluído? Se algum ou todos eles descrevem você, então [voz do locutor] Bem-vindo!

Este tutorial mostrará como montar e configurar um display gerador de partículas usando um Raspberry Pi 3 e alguns painéis de matriz RGB. Deve demorar entre uma e duas horas, e o produto final será de aproximadamente 30 "x8" (sem incluir o Pi) e pode ser montado na parede. É uma decoração bem legal para uma sala de estar, escritório, sala de jogos ou onde você quiser.

Antes de começar, aqui está o que você precisa e quais são os custos aproximados:

• Rpi 3 + SD Card + Case + Power Supply: $ 70 (da Canakit, mas você provavelmente pode conseguir as peças mais baratas se comprá-las separadamente).
• 4x 32x32 RGB LED Matrix (de preferência p6 interno com 1/16 de varredura): $ 80- $ 100 enviado no Alibaba ou Aliexpress; $ 160 em Adafruit ou Sparkfun.
• Chapéu Adafruit RGB Matrix: $ 25
• Fonte de alimentação 5V 4A: $ 15
• Clipes impressos em 3D: $ 1ish (estes são para conectar os painéis e pendurá-los na parede; se você não tiver acesso a uma impressora 3D, você pode usar uma tira furring para prendê-los juntos e alguns suportes da loja de ferragens para pendure-o na parede. Tentei encontrar os arquivos de design ou os.stls para eles, mas eles parecem ter saído da terra. Os clipes são muito fáceis de modelar.
• 14x parafusos M4x10: $ 5ish
• Quatro cabos 4x8 IDC e três cabos de alimentação para as matrizes RGB (não sei como são chamados!). Eles deveriam ter sido incluídos com seus painéis de LED.
• Total: cerca de $ 200, mais ou menos.

O projeto não requer solda ou conhecimento de programação específico; pressupõe que você sabe como gravar uma imagem em um cartão microSD. Se você não tiver certeza de como fazer isso, a base Raspberry Pi tem um bom tutorial aqui.

Também pressupõe que você tenha um conhecimento básico de como fazer as coisas na linha de comando no Linux, e o passo a passo do código pressupõe que você conhece os fundamentos do Python (mas - você não precisa seguir o passo a passo do código para ser capaz de construir e execute o gerador de partículas.) Se você travar em qualquer uma das etapas, sinta-se à vontade para fazer uma pergunta ou postar em / r / raspberry_pi (que também é, suponho, o público principal para este instrutível)

Etapa 1: montar a placa de LED

Primeiro, você vai montar os painéis individuais de LED de 32x32 em um grande painel de 128x32. Você precisará olhar suas placas e encontrar as pequenas setas que indicam a ordem de conexão; no meu, eles estão bem próximos aos conectores HUB75 / 2x8 IDC. Certifique-se de ter as setas apontando de onde o Rpi se conectará (à direita na foto acima) ao longo do comprimento da placa.

Você também precisará conectar os cabos de alimentação. A maioria desses cabos tem dois conectores fêmeas que se conectam às placas e um conjunto de terminais em forma de espada que se conectam à fonte de alimentação. Os painéis com os quais estou trabalhando têm os indicadores de 5V e GND quase totalmente escondidos sob os próprios conectores, mas os cabos se conectam apenas em uma direção. Você vai querer ter certeza de que está conectando todos os 5Vs juntos e todos os GNDs juntos, porque se você ligá-los ao contrário, é quase certo que irá fritá-los.

Como os cabos de alimentação incluídos com minhas placas eram tão curtos, tive que estender um inserindo os pinos do terminal em forma de espada no conector de outro (isso é bastante simples - você pode ter que dobrar os terminais em forma de espada ligeiramente para dentro, mas eu ' incluí uma foto para o caso). Acabei com dois conjuntos de terminais em espada e um conector IDC 2x8 à direita da minha placa de LED agora alongada.

Você também notará que tenho dois parafusos não fixados em nada em nenhuma das extremidades da placa; eles ficarão no topo assim que tudo for virado e serão usados para fixá-lo na parede.

Então - depois de conectar todos os painéis com clipes, cabos IDC 2x8 e cabos de alimentação, você está pronto para passar para a próxima etapa!

Etapa 2: preparar o Raspberry Pi

Em seguida, você vai deixar a placa de LED de lado (por enquanto) e deixar o Pi 3 pronto para executá-la. Estaremos usando Raspbian Stretch Lite e a biblioteca de matriz RGB do hzeller (em vez da biblioteca de matriz da Adafruit, que é mais antiga e sem manutenção).

Primeiro, você vai querer gravar a imagem Raspbian Lite em um cartão SD; depois de fazer isso, conecte um monitor e um teclado ao pi e inicialize-o. (Você também pode fazer isso sem cabeça, por ssh ou um conector serial, mas se é assim que você está indo, provavelmente não precisa que eu lhe diga como fazer.) Você precisará de uma conexão com a Internet para isso; Se você tiver wi-fi, conecte o Pi à sua rede sem fio editando /etc/wpa_supplicant/wpa_supplicant.conf e executando wpa_cli -i wlan0 reconfigure. (Se você nunca fez isso, você pode obter instruções aqui).

Assim que estiver conectado à Internet, atualizaremos as configurações do repositório dpkg e baixaremos as bibliotecas de que precisamos, executando os seguintes comandos:

sudo apt-get update

sudo apt-get install git python-dev python-pil

git clone

Agora temos que compilar e instalar o código da matriz. Então, você irá para a pasta que contém a biblioteca:

cd rpi-rgb-led-matrix

e compilá-lo (isso pode levar um minuto):

make && make build-python

e instale os vínculos python:

sudo make install-python

Se você receber algum erro ao compilar o código da biblioteca, volte e certifique-se de instalar o python-dev e o python-pil corretamente! As ligações python não compilarão sem ambos os pacotes instalados.

Você também precisará desabilitar a saída de som do seu Pi (o som integrado interfere no código da matriz) editando /boot/config.txt. Procure a linha que diz dtparam = audio = on e mude para dtparam = audio = off.

Se tudo compilou OK (você receberá alguns avisos sobre Wstrict-protoypes), seu pi deve estar pronto para executar a placa de matriz. Vá em frente e desligue-o (sudo shutdown now), desconecte-o e conectaremos a placa de luz ao pi na próxima etapa.

Etapa 3: Conecte Pi + Matrix Hat + Placa de LED

Então, agora que seu Pi está desligado e desconectado, vamos conectar o chapéu da matriz ao pi e a placa de LED ao chapéu da matriz. Se o seu Pi ainda não estiver na caixa, agora é uma boa hora para colocá-lo lá.

Instale o chapéu de matriz alinhando-o com os pinos GPIO no Pi e empurrando-o suavemente para baixo com força uniforme em ambos os lados. Certifique-se de que os pinos estejam alinhados corretamente, de modo que os cabeçotes femininos no chapéu cubram exatamente os pinos GPIO no pi. Se você desalinha-o, não é uma catástrofe; apenas puxe-o com cuidado para fora e endireite todos os pinos que tenham sido dobrados.

Depois de colocar o chapéu, coloque o Pi à direita da placa de LED montada (verifique novamente as conexões de alimentação e certifique-se de que as setas estão apontando do Pi para baixo ao longo da placa) e conecte o IDC cabo para o chapéu da matriz.

Em seguida, você desejará conectar os terminais de espadas para a alimentação no bloco de terminais do chapéu de matriz. Você tem dois conectores de espada de cada lado, mas os dois devem se encaixar perfeitamente. Afrouxe os parafusos primeiro e - isso não deve ser dito - certifique-se de colocar os terminais de 5 V no lado marcado com + (eles devem ser vermelhos, mas - novamente - verifique seus conectores e não presuma que foram fabricados corretamente) e os terminais GND (devem ser pretos) no lado marcado -. Assim que eles estiverem lá, aperte os parafusos na parte superior do bloco de terminais e você deverá ter algo que se pareça com a imagem do cabeçalho para esta etapa.

Agora - você deve ter notado que esta configuração em particular deixa metade do terminal tipo pá de cada lado exposto, pairando meros milímetros acima do chapéu da matriz (e não muito longe um do outro). E - os terminais pá logo estarão carregando vários volts e vários amperes de Raw Power. Esta é, (posso ouvir você perguntando do outro lado da tela) realmente a maneira certa de fazer isso? É, (você se aproxima e sussurra), uma boa ideia?

E a resposta é (eu respondo, encolhendo os ombros) - não, não é. A maneira certa de fazer isso seria descascar os terminais forquilha dos cabos de alimentação e crimpá-los novamente no conector correto para aquele bloco de terminais (ou deixá-los como fios desencapados e conectá-los sem um conector no bloco). Caso contrário, você pode colocar um tubo termorretrátil ao redor do lado exposto do conector tipo pá ou apenas envolvê-lo com fita isolante. Mas o mundo caiu e o homem é preguiçoso e vaidoso, então não fiz isso.

Mas - embrulhados ou desembrulhados - os terminais em forma de espada estão conectados ao bloco de terminais e estamos prontos para passar para a próxima etapa.

Etapa 4: teste a matriz RGB

Agora que seu Pi está conectado à placa de luz, vire a placa e ligue o Pi novamente. Você pode energizar o chapéu de matriz depois que o Pi for conectado; se você ligar o chapéu antes do Pi, no entanto, o Pi tentará inicializar sem corrente suficiente e reclamará amargamente (e pode causar um pânico no kernel e nem mesmo inicializar).

Se você estiver tendo problemas para fazer o Pi inicializar com o chapéu de matriz colocado, certifique-se de usar uma fonte de alimentação robusta o suficiente para o Pi (2A + deve ser bom) e tente conectar a fonte de alimentação do chapéu e do Pii no mesmo filtro de linha ou cabo de extensão e ligando-os juntos.

Assim que o Pi for inicializado, estamos prontos para testar as matrizes. Vá para onde estão as amostras de ligação python (cd / rpi-rgb-led-matrix / bindings / python / samples) e experimente o gerador de bloco rotativo com o seguinte comando:

sudo./rotating-block-generator.py -m adafruit-hat --led-chain 4

Você deve executá-lo como sudo porque a biblioteca de matriz precisa de acesso de baixo nível ao hardware na inicialização. O -m especifica a maneira como os painéis são conectados ao pi (neste caso, um chapéu adafruit) e o --led-chain especifica - você adivinhou - quantos painéis encadeamos. O padrão de linhas e colunas por painel é 32, então estamos bem.

Agora - depois de executar o programa, uma de duas (ou, na verdade, uma de três) coisas vai acontecer:

• Nada acontece
• Você obtém um bom bloco giratório no meio de sua placa de luz.
• O quadro de luz funciona, uh, eu acho, mas parece … estranho (metade dele é verde, algumas linhas não estão acendendo, etc.)

Se nada acontecer, ou se o painel parecer estranho, pressione ctrl + c para sair do programa de amostra, desligue o pi e verifique todas as suas conexões (cabo IDC, energia, certifique-se de que ambas as fontes de alimentação estejam conectadas, etc.) Verifique também se o chapéu está conectado corretamente; se isso não resolver o problema, leve-o para um painel (certifique-se de usar --led-chain 1 ao testá-lo) e veja se um dos painéis pode estar danificado. Se ISSO não funcionar, verifique as dicas de solução de problemas do hzeller. se ISSO AINDA não funcionar, tente postar em / r / raspberry_pi (ou nos fóruns da Adafruit, se você obteve seus painéis da Adafruit, ou troca de pilha, etc, etc.)

Se funcionar, mas ainda parecer estranho (talvez como a imagem do cabeçalho desta seção) depois de verificar as conexões, é possível que você tenha tudo conectado corretamente, que os painéis estejam funcionando corretamente, mas que algo mais está acontecendo sobre. O que nos levará à nossa próxima etapa - mais uma diversão do que uma etapa - nas taxas de multiplexação e varredura. (Se seu quadro de led está funcionando bem e você não está interessado no funcionamento interno desses painéis, fique à vontade para pular a próxima etapa.)

Etapa 5: Multiplexação e taxas de varredura (ou: um desvio momentâneo no caminho para o túmulo)

Então, um dos erros que cometi quando encomendei meu primeiro conjunto de painéis do Alibaba é que comprei painéis externos (por que não, pensei - eles são à prova d'água e mais brilhantes!). E, quando eu os conectei ao meu chapéu de matriz, as coisas pareciam … não certas.

Para entender por que isso acontece, vamos dar uma olhada em Phil Burgess na descrição de Adafruit de como esses painéis funcionam. Você notará que Burgess aponta que os painéis não acendem todos os LEDs de uma vez - eles acendem conjuntos de linhas. A relação entre a altura do painel em pixels e o número de linhas que acendem de uma vez é chamada de taxa de varredura. Então, por exemplo - Em um painel de 32x32 com varredura de 1/16, duas linhas (1 e 17, 2 e 18, 3 e 19, etc) são iluminadas de uma vez, por toda a parte inferior da placa e, em seguida, o controlador repete. A maioria das bibliotecas que controlam matrizes RGB são construídas para painéis em que a taxa de varredura é 1/2 da altura em pixels - ou seja, eles controlam duas fileiras de LEDs ao mesmo tempo.

Painéis externos (e alguns painéis internos - certifique-se de verificar as especificações antes de fazer o pedido) têm taxas de varredura que são 1/4 da altura em pixels, o que significa que eles esperam que quatro linhas sejam direcionadas ao mesmo tempo. Isso os torna mais brilhantes (o que é bom), mas faz com que muitos códigos padrão não funcionem com eles (o que é ruim). Além disso, eles tendem a ter os pixels fora de ordem internamente, o que requer a transformação dos valores xey no software para endereçar os pixels corretos. Por que são feitos dessa maneira? Eu não faço ideia. Você sabe? Se assim for, por favor me diga. Caso contrário, terá que permanecer um mistério.

Então, se você tem um desses painéis externos esquisitos, você (provavelmente) está com sorte! hzeller recentemente adicionou suporte para configurações comuns desses tipos de painéis à sua biblioteca. Você pode ler mais sobre isso na página do github do projeto, mas pode passar --led-multiplexing = {0, 1, 2, 3} para o código de amostra (você também pode precisar fingir que tem um cadeia de comprimento duplo de painéis de meio comprimento) e deve funcionar.

No entanto, existem alguns padrões de transformação de pixel que não são suportados - e (adivinhe) meus painéis têm um deles! Então, eu tive que escrever meu próprio código de transformação (eu também - por qualquer motivo - tenho que dizer à biblioteca para agir como se eu tivesse oito painéis 16x32 encadeados). que é o seguinte:

def transformPixels (j, k): effJ = j% 32

effK = k% 32

modY = k

modX = j

#modX e modY são os X e Y modificados;

#effJ e effK certifique-se de transformar dentro de uma matriz 32x32 antes de empurrar

if ((effJ)> 15):

modX = modX + 16

if ((effK)> 7):

modY = modY - 8

modX = modX + 16

if ((effK)> 15):

modX = modX - 16

if ((effK)> 23):

modY = modY - 8

modX = modX + 16

#Então, nós os colocamos no local correto (cada x + 32 move um painel)

if (j> 31):

modX + = 32

if (j> 63):

modX + = 32

if (j> 95):

modX + = 32

retorno (modX, modY)

Se você tiver um painel como o meu, isso pode funcionar para ele. Se não, você terá que escrever o seu próprio - então, você sabe, boa sorte e boa velocidade.

Etapa 6: o programa de estibordo (ou: de volta aos trilhos e pronto para o pixel)

Agora que você tem suas matrizes operacionais e prontas para funcionar, tudo que você precisa fazer é colocar o programa de estibordo em seu Pi e deixá-lo pronto para funcionar. Certifique-se de estar no diretório inicial do usuário pi (cd / home / pi) e execute o seguinte comando:

git clone

você deve ter uma nova pasta, starboard, que contém três arquivos: LICENSE.md, README.md e starboard_s16.py. Experimente o programa de estibordo executando-o por meio de python:

sudo python./starboard_s16.py

e você deve ter um monte de partículas movendo-se em velocidades diferentes e decaindo em taxas diferentes. A cada 10.000 ticks ou mais (você pode acessar o script python para editar / alterar isso), ele mudará os modos (há quatro: RGB, HSV, Rainbow e Greyscale).

Então, agora a única coisa que resta a fazer é fazer o código de estibordo rodar na inicialização. Faremos isso editando (com sudo) /etc/rc.local. O que você deseja fazer é adicionar a seguinte linha antes da "saída 0" no script:

python /home/pi/starboard/starboard_s16.py &

Depois de fazer isso, reinicie o pi - uma vez que ele execute a sequência de inicialização, o script starboard_s16.py deve iniciar imediatamente!

Se você quiser fuçar no script, sinta-se à vontade para fazê-lo - ele está licenciado sob a GNU GPL 3.0. Se o script não funcionar para você ou se você tiver problemas com ele, sinta-se à vontade para me avisar ou enviar um bug no github e verei o que posso fazer para corrigi-lo!

A (muito) última coisa que você pode querer fazer é configurar o SSH no pi, de modo que possa conectá-lo remotamente e desligá-lo com segurança. Você / definitivamente / desejará mudar sua senha (através do comando passwd), e você pode encontrar instruções para habilitar o ssh (também na linha de comando) aqui.