Pipboy feito de sucata: 26 etapas (com fotos)

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

Este é meu Pipboy de trabalho, construído com lixo aleatório da garagem e uma invasão do meu estoque de componentes eletrônicos. Achei esta construção desafiadora e me levou vários meses de trabalho, então eu não classificaria isso como um projeto completo para iniciantes. As habilidades necessárias incluem trabalho em plástico e madeira, eletrônica e codificação. O corpo é construído com vários pedaços de sucata de plástico cortada e soldada. Usei um Raspberry Pi 0 como microcontrolador, com um cabeçalho de tela montado em parte dos pinos GPIO. Os pinos restantes são usados para acionar LEDs e conectar botões / controles. Eu escrevi uma interface de usuário no estilo "Pipboy" com algumas telas de demonstração em Python para completar o projeto.

Meus objetivos para o projeto eram:

• Tinha que estar funcionando - ou seja, precisava realmente ter um display que fizesse as coisas
• Eu queria que ele tivesse um "dial" para selecionar as diferentes telas, pois isso sempre se destacou para mim como uma parte icônica da interface do usuário no Fallout
• Toda a construção teve que ser concluída usando coisas que eu já tinha na garagem ou no meu escritório (isso não foi totalmente alcançado, mas cheguei perto - mais de 90% disso foram encontrados itens ou coisas que eu já tinha por aí)
• Precisa ser vestível

Um objetivo que eu não tinha era torná-lo uma réplica exata de um dos modelos do jogo - eu prefiro construir coisas "no estilo" de uma coisa, pois me dá espaço para adaptar lixo aleatório que encontro, e permite-me ser um pouco mais criativo. Finalmente, sim, eu sei que você pode comprar estes, mas esse também não era o ponto;)

Suprimentos

Suprimentos

• Tubo de furo largo (como um pedaço de tubo de drenagem)
• Sucata de plástico (tanto para criar o corpo quanto para fins decorativos)
• Recipiente pequeno
• Tapete de espuma
• Raspberry Pi
• Display de 3,5"
• Codificador Rotativo KY040
• 3x LEDs
• 2x botões de pressão
• Banco de poder
• Fiação
• Parafusos, colas, tintas, enchimento, etc.

Ferramentas

• Dremmel
• Multi-ferramenta com cortador e acessórios de lixa
• Furar
• arquivos
• Ferro de solda
• Pistola de cola quente
• Chave (s) de fenda
• Faca afiada
• Serra

Etapa 1: Construindo o Coração do Pipboy

A primeira coisa que eu precisava fazer era garantir que conseguiria um monitor e um microcontrolador em um formato com o qual pudesse trabalhar. Acontece que eu tinha um display de 3,5 aparecendo como um HAT nos pinos GPIO de um Raspberry PI, então decidi usar isso. Emparelhei com um Raspberry Pi 0 e verifiquei se funcionava bem, há um alguns passos para fazer o Linux reconhecer a tela que você precisa percorrer.

Como você pode ver na segunda foto, adicionei uma pequena plataforma de papelão / espuma que colei no case para ajudar a apoiar a tela. Fiz isso porque sabia que lidaria muito com essa parte e não queria quebrar pinos ou a tela por falta de suporte. Eventualmente, ele foi substituído, mas era uma boa proteção adicional durante o processo de construção.

Também vale a pena notar neste ponto, que mais tarde na construção eu tive problemas de desempenho com esta configuração - predominantemente a taxa de atualização sobre a interface entre o Pi e a tela, falarei mais sobre isso mais tarde na construção, mas se eu fiz isso de novo, posso considerar um hardware diferente aqui.

Aqui estão alguns links úteis para isso:

www.raspberrypi.org/forums/viewtopic.php?t…

www.raspberrypi.org/forums/viewtopic.php?t…

www.raspberrypi.org/forums/viewtopic.php?f…

learn.sparkfun.com/tutorials/serial-periph…

Também irei incluir no github associado a este algumas notas sobre o que eu realmente fiz para fazer isso funcionar (embora a partir da minha leitura do tópico haja muita variabilidade em como isso funciona para instâncias / drivers específicos, então sua quantidade pode variar)

Etapa 2: protótipo de papelão

Eu encontrei algumas calhas / canos antigos que eu poderia usar para o corpo, mas eu precisava criar um design para a área real da tela e painel de controle. Para isso, fiz apenas maquetes de papelão e usei fita adesiva para fixá-las ao cano. A primeira era uma "caixa" simples, mas parecia muito simples, então eu a modifiquei para tornar a área da tela mais interessante e adicionei uma área separada do painel de controle. Este se tornou mais ou menos o design final (houve alguns ajustes, como você verá, mas está perto).

Etapa 3: do protótipo ao modelo

Agora que eu tinha um protótipo com o qual estava feliz, eu poderia achatar o papelão e transformá-lo em um modelo que eu transpus para parte de um gabinete de PC antigo que eu estava chutando por aí. Qualquer plástico resistente semelhante funcionaria, eu estava apenas usando o lixo que tinha à mão. Uma vez marcado, pude cortar as peças para começar a montar o corpo principal. Uma dica útil aqui, para facilitar a marcação e, posteriormente, o corte do plástico, cobri as áreas que precisaria cortar primeiro com fita adesiva, o que me deu uma maneira mais fácil de desenhar o modelo no plástico, e algo para ajudar a impedir que o disco de corte escorregue quando fiz os primeiros cortes.

Etapa 4: adicionar caso para tela e Pi

Eu queria que os cantos da área da tela fossem curvos e precisava de algo que realmente segurasse o Pi e exibisse - minha solução foi usar um pequeno recipiente de plástico que eu tinha. Cortei um buraco na parte superior do corpo e colei o recipiente através dele. Então eu colei todos os lados juntos. Usei supercola aqui com bicarbonato de sódio em abundância para ajudar a fortalecer as soldas. Mais tarde, enchi e lixei / lixei tudo para arrumar tudo e dar uma sensação mais "moldada".

Etapa 5: Repita para o Painel de Controle

Em seguida, fiz exatamente o mesmo molde transpondo, recortando e colando para construir a caixa do painel de controle.

Etapa 6: corte o tubo

Como você pode ver, o contêiner que estou planejando usar para abrigar os principais componentes eletrônicos agora fica orgulhoso dentro da moldura de plástico preto, isso significa que preciso fazer uma abertura no tubo para que ele se encaixe. Usei fita adesiva novamente para alinhar onde eu queria cortar e recortei um quadrado do tubo para que as partes se encaixassem.

Etapa 7: moldura

Um desafio que eu acidentalmente forcei em mim mesmo foi tentar criar uma moldura que preenchesse a área ao redor da tela até as bordas do contêiner. Infelizmente, a forma como a tela é feita também não tem nada de útil em seu design (como orifícios ou qualquer coisa) para ajudar a montá-la, então a moldura também teve que segurar a tela no lugar. Minha primeira tentativa (vista aqui) foi uma mistura de plástico e espuma. Acabei repetindo isso várias vezes e acabou sendo uma das partes mais desafiadoras da construção. Piorado pelas pequenas tolerâncias e natureza delicada da moldura e da tela.

Etapa 8: Teste de bateria

Neste ponto, voltei minha mente para como fazer isso funcionar independentemente de um USB fornecido pela rede elétrica. Testei várias baterias e descobri que o monitor Raspberry Pi + não consumia muita energia e ficava perfeitamente satisfeito ao funcionar com até mesmo uma das minhas baterias menores (um brinde de uma feira). Isso foi realmente uma sorte, pois o pacote se encaixou perfeitamente em uma lacuna dentro da construção (fotos depois). Agora podemos colar temporariamente os principais componentes do corpo e fazer nosso primeiro teste funcionar no meu braço!

Etapa 9: Teste de ajuste

Aqui você pode ver onde modifiquei ainda mais o tubo central para permitir o acesso à parte inferior dos componentes. Você também pode ver como tive sorte com a bateria se encaixando bem em uma cavidade de um lado do recipiente de Pi. Finalmente comecei o processo de limpeza das ligações, preenchimento, lixamento e fiz uma camada de teste de primer para ter uma noção da aparência final (eu sabia que nesta fase eu estaria lixando isso muito mais vezes e quase todo o primer iria, mas queria ter uma ideia de como seria).

Etapa 10: Adicionar controles e detalhamento

Eu queria uma série de LEDs vermelho / amarelo / verde para formar um medidor, bem como um botão giratório e pelo menos 2 botões. Todos eles foram encaixados na seção do painel de controle - bastou fazer todos os orifícios corretos. Eu também comecei a adicionar pequenos pedaços de componentes plásticos de sucata (basicamente kit de bashing) para adicionar detalhes e mais interesse ao corpo e painel de controle.

Etapa 11: reconstrução do painel no. 3

Como mencionei anteriormente, lutei com a moldura para esta construção e reconstruí-a várias vezes. Esta é a terceira iteração na qual me mantive. Minha abordagem aqui é usar painéis de fibra e cortar 2 formatos diferentes, um pensador do que o outro e, em seguida, colá-los (e fixá-los) para formar a imagem do meio. Essas formas permitiam que o display quadrado ficasse dentro dele e, em seguida, segurasse o display no lugar dentro do contêiner (como na figura 3). Isso me deu material suficiente para usar 4 parafusos muito pequenos como acessórios - que usei para fixá-los firmemente no lugar dentro do gabinete, e isso por sua vez manteria a tela estável e segura. Em retrospecto, eu encontraria um monitor que veio com algumas opções de montagem decentes (ou usaria uma impressora 3D - que eu não tinha na época).

Etapa 12: Prototipar os eletrônicos

Eu uso uma placa de ensaio para fazer o layout de meus circuitos simples como este e, como geralmente faço essa parte do projeto em um espaço diferente da construção do corpo principal, também o emparelhei com um Raspberry PI diferente. Aqui, usei um modelo 3, que me deu um pouco mais de potência para me conectar diretamente a ele e executar um IDE integrado. Isso apenas tornou a prototipagem rápida de código um pouco mais fácil para mim. Existem muitas outras maneiras de conectar / codificar / depurar remotamente, é apenas o que eu prefiro fazer aqui.

O design aqui é bastante simples, nós temos;

1. Codificador rotativo - usa um aterramento e um monte de pinos GPIO para lidar com a direção do clique e o botão de pressão.
2. Par de botões de pressão, estes simplesmente usam um único pino GPIO cada e um aterramento comum
3. 3 LEDs, cada um com um resistor em linha para impedi-los de estourar, todos indo para um terreno comum, mas com um pino GPIO individual cada, para que cada um possa ser endereçado individualmente.

Isso me deu 3 LEDs para o meu medidor, um codificador rotativo para girar pelas telas no pipboy e 3 botões para direcionar as ações (um no codificador rotativo e 2 com fiação separada). Isso foi tudo que eu consegui encaixar, e com a tela ocupando um monte de pinos, praticamente consome o que você tem em um layout Pi GPIO padrão. No entanto, foi bom para os meus propósitos.

A segunda foto mostra praticamente o layout interno final que escolhi. Passei algum tempo aqui testando maneiras de conduzir os componentes e verificando se tudo funcionou antes de transpor isso para o corpo da construção. Todo o código está no github.

Uma nota sobre codificadores rotativos. Passei muito tempo escrevendo minha própria máquina de estado do Codificador Rotativo para rastrear as alterações de alta / baixa do GPIO e mapeá-las para as posições rotativas. Tive sucesso misto aqui, fiz funcionar para "a maioria" dos casos, mas sempre há casos extremos e (des) saltos etc. para lidar. É muito mais fácil usar uma biblioteca pronta e há uma ótima disponível para instalar para Python. Eu usei isso no final, pois me permitiu focar na parte divertida da construção, ao invés de gastar muito tempo depurando problemas. Todos os detalhes estão incluídos no código-fonte.

Se você é novo no Raspberry Pi, GPIO e eletrônica, eu recomendo fortemente os seguintes tutoriais que o orientam por tudo que você precisa para fazer o layout acima;

projects.raspberrypi.org/en/projects/physi…

thepihut.com/blogs/raspberry-pi-tutorials/…

Etapa 13: Transpondo os componentes eletrônicos para o corpo

Depois de concluir o layout usando uma placa de ensaio, era hora de começar a pensar em como montá-los no corpo do pipboy. Decidi que queria fazer isso de forma que pudesse desmontar e remover todos os componentes eletrônicos no caso de precisar consertar ou mudar alguma coisa no futuro. Para conseguir isso, decidi tornar todas as sub-partes plugáveis usando conectores dupont.

Para os botões que soldei em alguns fios de extensão e usei wire wrap para isolar as extremidades, isso me permitiu montá-los e desmontá-los do corpo (por exemplo, para teste, pintura, etc.). O Rotary Encoder já tinha pinos que podiam aceitar conectores duplos, então eu só precisava fazer alguns fios do comprimento certo.

Os LEDs deram um pouco mais de trabalho - para isso, decidi usar um pedaço de plástico que tinha (cortado para caber) para fazer um painel removível para montar os LEDs. Em seguida, colei-os a quente no lugar e soldei os resistentes e os fios. Isso fez com que uma unidade de remoção que eu pudesse colocar e remover e tornasse a pintura e o acabamento mais fáceis.

Observe que minha solda é terrível, então mantive isso simples e evitei qualquer coisa muito detalhada / fina. Na foto final você pode ver que eu também tinha alguns broadboards bem pequenos (5x5), usei um deles montado dentro para fornecer um painel para conectar tudo de / para o GPIO. Em particular, isso foi útil para criar um trilho de aterramento comum que eu pudesse usar e evitar muitos fios de aterramento serpenteando de volta para o Pi.

Em seguida, cortei vários orifícios no contêiner para alimentar os fios até o Pi e conectar ao GPIO. Esse design me permitiu remover tudo se eu precisasse (algo que fiz várias vezes enquanto estava finalizando a construção).

Etapa 14: ajuste fino do ajuste

Nesse ponto, encontrei alguns problemas de "ajuste". Em primeiro lugar, o uso de conectores duplos para a fiação significava que era difícil encaixá-los nos pinos com o chapéu de exibição no lugar, pois não havia espaço de altura suficiente. Resolvi isso comprando (esta é uma das poucas coisas que realmente comprei para este projeto) um pequeno extensor de pino GPIO para que eu pudesse colocar o chapéu de exibição mais alto e deixar espaço para acessar os pinos GPIO restantes usando conectores duplos.

Também cortei alguns pedaços pequenos do tapete de espuma para fazer um acolchoamento lateral dentro do contêiner, o que ajudou a encaixar o Pi + Display no lugar certo e impedi-lo de se mover.

Etapa 15: Retroceda o Codificador Rotativo

Os codificadores rotativos geralmente vêm (como o meu) com um botão estilo "hi fi" moderno e brilhante. Isso estava totalmente fora do personagem para a construção, então eu tive que pensar em outra coisa. Em minha caixa aleatória de peças, encontrei uma velha roda dentada de uma furadeira que quebrei há muito tempo. Parecia bom, mas não encaixava no codificador rotativo. Minha solução aqui foi experimentar vários plugues de parede até encontrar um que se encaixasse no botão giratório e, em seguida, cortá-lo no formato para que pudesse usá-lo como um "colar interno" para assentar a engrenagem da broca no codificador giratório como um tema mais apropriado ao controle.

Etapa 16: Forro interno

Mais ladrilhos de espuma! Desta vez, usei-os para construir um forro macio para torná-lo um ajuste mais confortável (sem ficar muito frouxo). Cortando um buraco na espuma, também consegui absorver um pouco do "caroço" que o recipiente para o Pi cria. No geral, isso o tornou muito mais fácil de usar. Não mostrado nessas fotos, mas deixei-o um pouco maior que o corpo principal para que ficasse visível nas pontas, que depois pintei e tudo ajudou a adicionar um pouco de contraste e interesse ao item acabado.

Etapa 17: adicionar detalhes

É hora de começar a adicionar algumas decorações e torná-las mais interessantes. Em primeiro lugar, acrescentei algumas tiras de plástico ao longo de uma das faces para dar um pouco de interesse visual. Em seguida, acrescentei alguns fios falsos a alguns terminais e apenas os empurrei em um orifício que fiz no corpo. Posteriormente, tudo isso foi pintado em cores diferentes.

Etapa 18: Pintura e acabamento da construção do corpo

Eu não estava muito preocupado com um acabamento imaculado - como deveria ser velho e bem usado de qualquer maneira (na verdade, eu posso voltar e fazer ainda mais desgaste nele em algum momento). Mas eu queria que parecesse um objeto consistente e completo que não fosse preso junto a um lixo aleatório (embora fosse exatamente o que era). Passei por várias iterações de lixamento, enchimento (milliput é meu enchimento de escolha para plástico) e repita. Em seguida, várias camadas de primer e tinta para ajudar ainda mais a suavizar todas as junções. Depois, mais lixamento, mais enchimento e mais pintura.

Depois de dar uma olhada e sentir o corpo com o qual estava feliz, comecei a adicionar alguns detalhes. Usei esfregar e lustrar as grades dos controles para dar a eles uma sensação mais de malha de arame. Também adicionei pequenos detalhes de tinta aqui e ali usando acrílicos.

Eu cavei em minha coleção de adesivos aleatórios e adicionei alguns para finalizar o efeito. Em seguida, fiz uma lavagem para intemperismo com algumas tintas mistas para adicionar um pouco de fuligem e sujeira nas áreas de difícil acesso que seriam difíceis de limpar. Isso talvez seja um pouco sutil demais no momento, e posso voltar e acrescentar mais algumas coisas mais tarde.

Etapa 19: Codificação

Parte da minha ambição para este projeto era fazê-lo reagir como um pipboy de verdade - e para mim a parte mais icônica do jogo é girar o dial para alternar entre telas diferentes. Para conseguir isso, decidi escrever uma interface de usuário pipboy que seria capaz de exibir uma série de telas e permitir a você rolar entre elas. Eu queria fazer do conteúdo das telas algo que eu pudesse mudar facilmente e, de fato, ser capaz de adicionar / remover telas.

Eu escolhi escrever isso em Python devido ao excelente suporte para Raspberry Pi, GPIO etc. Python está muito baixo na minha lista de linguagens com as quais estou familiarizado, então esta foi uma grande curva de aprendizado para mim, e muito do código é confuso como resultado. Estarei atualizando isso com o tempo, pois não terminei completamente tudo o que queria fazer aqui - mas está perto o suficiente para compartilhar agora, pois todos os conceitos principais estão lá.

Meu design para o código da IU é razoavelmente simples, há um script Python principal que configura a exibição, configura o GPIO, carrega as telas e entra em um loop de atualização infinito, esperando por eventos do usuário e atualizando a exibição conforme necessário. Além disso, existem vários scripts de suporte que ajudam a gerar as telas da IU antecipadamente.

Bibliotecas principais utilizadas:

• pygame: eu uso isso como o mecanismo para executar a IU, pois me permitiu desenhar gráficos arbitrários, manipular imagens, fontes, ir para tela inteira etc.
• pyky040: Isso fornece o manuseio para o botão giratório e me economiza muito tempo (muito obrigado a Raphael Yancey por liberá-lo.
• RPi. GPIO: Para uma boa direção GPIO, brinquei com algumas opções aqui, mas isso me deu o nível certo de flexibilidade que eu queria, particularmente com coisas como usar um GPIO sobressalente como outro 3.3v para acionar o codificador rotativo etc.
• ruído: Para gerar ruído perlin, para me permitir criar uma forma de onda aleatória para a tela do rádio que pareça mais natural
• fila: Encontrei um bug frustrante com o tempo de eventos do codificador giratório sendo ativado e a taxa de atualização (muito) lenta do visor LCD. No final, resolvi isso colocando na fila os eventos de entrada do codificador rotativo e retirando-os um de cada vez enquanto a tela era atualizada.
• os, sys, threading, time: todos usados para funções python padrão

Uma nota sobre o design do manuseio da tela. As telas são definidas como uma lista de nomes dentro do código. Cada entrada na lista pode ter um arquivo-p.webp

O conteúdo desses arquivos é gerado em outro lugar (manualmente ou por outros scripts), a saída dos quais são salvos como arquivos-p.webp

Existem raras exceções onde algumas coisas são codificadas - como a forma de onda para a tela de rádio aleatória, uma vez que é calculada em tempo real e animada.

Se uma analogia ajudar, pense no design da IU como um navegador da web extremamente bruto e simples - cada "tela" é como uma página da web realmente simples que pode consistir em apenas um png, um arquivo txt ou uma combinação dos dois. O conteúdo deles é independente e apenas desenhado pela IU como um navegador desenharia uma página da web.

Aqui estão os links para as principais bibliotecas que usei aqui:

www.pygame.org/news

pypi.org/project/pyky040/

pypi.org/project/noise/

Etapa 20: tela de estatísticas

Nenhum pipboy estaria completo sem a clássica tela de estatísticas da silhueta do pipboy. Para isso, um amigo meu criou um-p.webp

Etapa 21: tela de inventário

Algo que é sempre útil com projetos Pi é ter uma maneira de exibir informações básicas como o endereço IP de seu DHCP etc. Decidi sobrecarregar a tela de Inventário como uma exibição do "inventário" Pi - qual CPU, memória, endereço IP etc.. Eu escrevi um pequeno script Linux para coletar essas informações e apenas redirecioná-lo para um arquivo de texto (.txt) nomeado apropriadamente que o sistema de IU então pega e exibe. Dessa forma, se eu estiver em um local diferente, posso disparar o script e pegar um arquivo.txt novo com o endereço IP atualizado, etc.

Etapa 22: tela do mapa

Essa tela era uma das mais complexas de se trabalhar. O Raspberry Pi 0 não vem com módulo GPS, mas eu queria que o Mapa tivesse alguma validade para onde o Pi estava. Minha solução para isso é um script separado que extrai o endereço IP do Pi e usa https://ipinfo.io para procurar uma localização aproximada. A resposta JSON é capturada e, em seguida, eu converto as coordenadas para que possa puxar para baixo um bloco do openstreetmap.org para o local aproximado.

Os ladrilhos caem em várias cores, mas eu queria uma imagem em escala verde para combinar com a aparência do Pipboy e não consegui encontrar uma exatamente assim, então escrevi um filtro em escala verde em Python para remapear as cores do bloco do openstreetmap e, em seguida, armazene em cache a nova imagem em um arquivo png.

Durante o processo acima, um arquivo de texto é gerado com a localização e coordenadas aproximadas, e o bloco do mapa é criado como um PNG. A IU do pipboy puxa esses arquivos e sobrepõe o conteúdo para criar uma tela de mapa que funciona (dentro da precisão da resolução do endereço IP para um local).

Etapa 23: Tela de dados

Este é apenas um cartão de teste (gerado por outro script python e saída para um arquivo png) que é exibido para ajudar a testar o tamanho / layout. Eu o deixei porque ainda é meio útil para verificar quanto espaço tenho para brincar ao fazer a simulação de telas.

Etapa 24: tela do rádio

Junto com a tela do mapa, esta é a outra tela que realmente me deu muito trabalho. Esta é a única tela em que brinquei com animação - e geralmente funciona como planejado, mas o desempenho ainda é um problema com as taxas de atualização da tela LCD. A estrutura da tela é um arquivo de texto contendo alguns nomes de rádio escolhidos aleatoriamente (estes são apenas strings arbitrárias e não fazem nada além de apresentar uma lista na tela), um arquivo-p.webp

Esta é a única tela onde o loop do pygame faz algum trabalho real a cada ciclo, ele tem que calcular a nova forma de onda, apagar a parte da tela neste vive e redesenha.

Etapa 25: Reflexões Finais

Esta é possivelmente a construção mais desafiadora que fiz, com muitos conceitos e habilidades diferentes exigidos, mas também é uma das mais agradáveis com uma coisa real que funciona como resultado. Ainda estou limpando algumas das minhas notas mais técnicas, bem como o repositório do github para o código. Tudo isso disponibilizarei em breve, então volte em breve para obter mais detalhes e informações conforme eu tiver tempo de adicioná-los ao artigo.

Se você começar a fazer algo assim, adoraria ver os resultados e se você tiver alguma dúvida, sinta-se à vontade para entrar em contato e eu tentarei adicionar mais informações em quaisquer etapas em que você queira ajudar.

Etapa 26: Código aberto no Github

Finalmente consegui abrir o código no Github. Está disponível neste link: