splitflap
v1.1
Este é um display DIY de aba dividida baseado em ESP32, otimizado para fácil montagem em casa em pequenas quantidades, mas capaz de ser ampliado para grandes displays acessíveis.
Artefatos mais recentes gerados automaticamente (não testados!)
Instruções: guia de montagem v2
Dimensões do módulo:
Artefatos mais recentes gerados automaticamente (não testados!)
Observação
Para monitores pequenos (até 3 módulos), você pode ignorar as placas controladoras personalizadas e usar módulos de driver ULN2003A prontos para uso conectados a um Arduino Uno. Isso está parcialmente documentado no wiki, mas pode exigir alguns ajustes adicionais para que funcione. Procura-se ajuda: se você quiser ajudar a melhorar estas instruções, entre em contato no servidor Discord, obrigado!
O sistema eletrônico "Chainlink" foi projetado para suportar longas cadeias de placas de driver para controlar monitores médios/grandes (até mais de 100 módulos de aba dividida). Ele também foi projetado para ser fácil e barato de encomendar pré-montado ou de construir você mesmo, especialmente em quantidades maiores, devido à sua lista técnica simples e aos componentes de montagem em superfície.
Para construir um display, você precisará de 3 componentes eletrônicos diferentes:
Cada módulo precisa de um sensor de efeito Hall para calibração inicial e monitoramento de falhas.
Sensores mais antigos para a versão 0.7 e hardware de corte a laser mais antigo podem ser encontrados na versão do sensor etiquetada.
Esses sensores mais antigos não são compatíveis com hardware de corte a laser v2.
Novos sensores para o hardware cortado a laser v2 - usam componentes de montagem em superfície e são otimizados para montagem de PCB no JLCPCB. Esses novos sensores não são compatíveis com a versão 0.7 e hardware de corte a laser mais antigo.
Pacotes de 6 sensores estão disponíveis em sua maioria montados na loja Bezek Labs e vêm com os cabeçalhos de pinos em ângulo reto e os ímãs de que você precisa. As compras apoiam o desenvolvimento contínuo deste projeto.
Artefatos mais recentes gerados automaticamente (não testados!)
Principais recursos:
As placas Chainlink Driver estão disponíveis principalmente montadas na loja Bezek Labs e vêm com os conectores adicionais e cabos de fita de que você precisa. As compras apoiam o desenvolvimento contínuo deste projeto.
Mais informações sobre como construir e usar drivers Chainlink estão disponíveis no Guia do usuário do driver Chainlink.
Ou se você quiser encomendá-los diretamente de uma fábrica, esse design é otimizado para montagem no JLCPCB e os arquivos são gerados automaticamente para solicitar PCBs montados lá. Ou se você deseja montar esta placa sozinho em vez de pagar pela montagem, você pode visualizar a ferramenta interativa de BOM/posicionamento
Dependendo do estoque disponível no JLCPCB, pode ser necessário modificar manualmente o arquivo BOM para usar componentes alternativos ou gerar novamente os arquivos usando export_jlcpcb.py e especificando um ou mais nomes de campo LCSC_ALT_* para usar um número de peça alternativo pré-selecionado. Consulte o esquema para alternativas pré-selecionadas disponíveis (verifique as propriedades/campos do símbolo).
Artefatos mais recentes gerados automaticamente (não testados!)
O Chainlink Buddy [T-Display] é uma maneira conveniente de conectar uma placa T-Display ESP32 (microcontrolador recomendado) a uma cadeia de drivers Chainlink.
Principais recursos:
As placas Chainlink Buddy [T-Display] estão disponíveis na loja Bezek Labs e vêm com os conectores adicionais necessários. As compras apoiam o desenvolvimento contínuo deste projeto.
Artefatos mais recentes gerados automaticamente (não testados!)
O Chainlink Buddy [breadboard] facilita a conexão de um driver Chainlink a uma protoboard para prototipagem. Você poderia usar 5 fios dupont e ter um ninho de ratos bagunçado, ou você poderia usar um único cabo de fita e esta placa de fuga elegante.
As placas Chainlink Buddy [Breadboard] estão disponíveis na loja Bezek Labs e vêm com os conectores adicionais necessários. As compras apoiam o desenvolvimento contínuo deste projeto.
Artefatos mais recentes gerados automaticamente (não testados!)
Para monitores maiores, você deve tomar cuidado adicional para tornar o hardware mais robusto contra possíveis falhas. O Chainlink Base é um design de controlador experimental (mas sem suporte) que adiciona algumas funcionalidades adicionais. Isto foi testado e parece funcionar, mas não é recomendado para uso geral.
O Chainlink Base PCB é uma alternativa opcional ao Chainlink Buddy, projetado para monitores particularmente grandes. Ele hospeda o ESP32 e adiciona opções adicionais de conectividade (terminais para UART e serial RS485) e distribuição de energia (canais de energia monitorados de forma independente para múltiplas "zonas" de placas Driver).
Principais recursos:
Artefatos mais recentes gerados automaticamente (não testados!)
A placa de driver Classic está obsoleta e não é suportada.
A placa controladora Classic foi projetada para ser conectada a um Arduino como um escudo e pode controlar 4 motores de passo. Até 3 placas de driver podem ser encadeadas, para até 12 módulos controlados por um único Arduino.
O driver usa 2 drivers de registro de deslocamento do lado inferior MIC5842, com diodos de supressão de transientes integrados, para controlar os motores, e um registro de deslocamento 74HC165 para ler 4 sensores magnéticos de posição inicial de efeito Hall. Existem LEDs RGB WS2812B opcionais que podem ser usados para indicar o status de cada um dos 4 canais.
Se você deseja imprimir suas próprias abas ou recortar adesivos de letras em vinil personalizados, o projeto inclui um script para gerar arquivos de desenho vetorial extremamente configuráveis:
TODO: termine de documentar isso e renderize algumas imagens de exemplo...
Se você quiser compartilhar uma única face frontal em vários módulos (em vez de cada módulo ter sua própria face frontal), o repositório inclui um script para gerar um painel frontal combinado para corte a laser ou fresamento/roteamento CNC.
Você pode modificar:
Para corte CNC, o script suporta a renderização de um arquivo vetorial otimizado para materiais mais espessos (por exemplo, MDF de 6 mm), onde apenas os furos dos parafusos serão cortados. Neste modo, os slots para as peças superior/inferior do gabinete podem ser cortados como bolsos de aproximadamente 4 mm para que não fiquem visíveis na face frontal. O script gera automaticamente formas de osso de cachorro para esses cortes de bolso.
TODO: termine de documentar isso e renderize algumas imagens de exemplo...
O projeto também inclui vários designs opcionais impressos em 3D para facilitar a montagem. Estes incluem:
Todos esses designs são paramétricos e personalizáveis no OpenSCAD. Para imprimi-los, abra o arquivo relevante no OpenSCAD e use File -> Export -> Export as STL para renderizar o design como um arquivo STL para seu fatiador.
Provavelmente, isso não será útil, a menos que você esteja planejando fabricar dezenas a centenas de placas Chainlink Driver, mas o Chainlink Driver Tester é um ambiente de teste completo para placas Chainlink Driver conforme elas são montadas pelo fabricante do PCBA.
Isto está atualmente em desenvolvimento muito ativo.
Principais recursos:
Artefatos mais recentes gerados automaticamente (não testados!)
O firmware do driver é escrito usando PlatformIO com a estrutura Arduino e está disponível em firmware/ .
O firmware implementa um controlador de malha fechada que aceita letras como entrada via serial USB e aciona os motores de passo usando uma rampa de aceleração pré-computada para controle suave. O firmware calibra automaticamente a posição do carretel na inicialização, usando o sensor magnético de efeito Hall, e se recalibrará automaticamente se detectar que a posição do carretel ficou fora de sincronia. Se for esperado que uma rotação comandada leve o carretel além da posição "inicial", isso confirmará que o sensor não foi acionado nem muito cedo nem muito tarde; caso contrário, ele procurará a posição "inicial" para sincronizar antes de continuar para a letra desejada.
Para que um computador se comunique com o splitflap, ele aparece como um dispositivo serial USB.
No entanto, o uso do Serial do Arduino é estritamente proibido e, em vez disso, é fornecida uma abstração logger para enviar logs de depuração de texto básico. Outros dados são transferidos de forma estruturada, descrita abaixo.
Isso permite flexibilidade no formato dos dados transferidos via serial e, de fato, o splitflap fornece 2 modos seriais diferentes que atendem a finalidades diferentes.
Por padrão, ele inicia no modo “texto simples”, que é amigável ao desenvolvedor e com o qual você provavelmente está familiarizado se abriu um monitor serial com o splitflap conectado:
{"type":"init", "num_modules":6}
No entanto, isso não é ótimo para configurar ou receber atualizações programaticamente do splitflap; portanto, o firmware oferece uma interface programática usando um protocolo binário baseado no padrão Protobuf do Google.
O modo serial binário baseado em protobuf é uma maneira compacta e flexível de transferir dados estruturados do computador host para o splitflap e vice-versa.
protobuf oferece vários benefícios em relação a outros mecanismos de codificação como JSON:
É por isso que o padrão splitflap é o modo de texto simples para facilitar a validação/depuração básica.
As mensagens Protobuf são codificadas em seu formato de ligação binária e uma soma de verificação CRC32 anexada. Em seguida, toda essa sequência binária é codificada COBS em um pacote e delimitada/enquadrada por 0 (NULL) bytes quando enviada pela serial. Isso fornece uma interface básica baseada em pacotes com verificações de integridade (em vez da interface bruta baseada em fluxo de uma conexão serial).
O splitflap muda automaticamente para o modo protobuf binário quando recebe um byte 0.
O display pode ser controlado por um computador conectado ao ESP32 via USB serial. Se você construiu um monitor e deseja testá-lo, confira a demonstração baseada na web aqui, que se conectará ao seu monitor usando USB - sem necessidade de aplicativos/instalação!
O firmware suporta um modo serial de texto simples (habilitado por padrão) para facilitar o teste e um modo binário baseado em protobuf usado pelas bibliotecas de software para controle programático aprimorado e feedback.
Você pode encontrar exemplos de bibliotecas Typescript e Python na pasta software/chainlink .
Quer fazer algumas modificações ou brincar com o design em sua máquina local? Entre direto! Observe que todos os scripts e automação são desenvolvidos para Ubuntu. O suporte ao Mac OS está planejado, mas não implementado no momento (mas sinta-se à vontade para abrir um PR se quiser ajudar!).
O arquivo de design principal é 3d/splitflap.scad
Você precisará de uma versão recente do OpenSCAD (por exemplo, 2015-03), que pode precisar ser instalada através do PPA: sudo add-apt-repository ppa:openscad/releases
Em geral, objetos sólidos, como as laterais do gabinete ou componentes do carretel, são construídos a partir de primitivos 2D e, em seguida, extrudados na espessura apropriada para renderização 3D, em vez de usar primitivos 3D. Isso simplifica o design sem perder a expressividade; o feixe de corte a laser perpendicular não permite cortes que variam na dimensão Z.
Observe que embora o projeto seja parametrizado e muitos valores possam ser ajustados, atualmente não há verificação de erros para parâmetros inválidos ou combinações de parâmetros. Tenha o cuidado de validar o design se você alterar algum parâmetro. Por exemplo, embora a maior parte do design se ajuste a um valor num_modules alterado, certos valores podem fazer com que alguns elementos se cruzem com outros elementos ou se projetem além das dimensões esperadas.
O design pode ser renderizado em 2d para corte a laser executando 3d/scripts/generate_2d.py [--panelize <number>] , que gera 3d/build/laser_parts/combined.svg . O argumento opcional --panelize permite renderizar um painel de módulos em um único SVG, para corte a laser em massa.
Internamente, o design usa um módulo projection_renderer ( 3d/projection_renderer.scad ), que leva uma lista de elementos filhos para renderizar e, dependendo do render_index renderiza um único filho por vez. Ele também adiciona material a cada formato para compensar o corte que será cortado pelo laser.
O script generate_2d.py interage com o módulo projection_renderer usando-o primeiro para determinar o número de subcomponentes a serem renderizados e, em seguida, executa o OpenSCAD para exportar cada componente para um arquivo SVG. Ele faz algum pós-processamento na saída SVG (adiciona notavelmente "mm" às dimensões do documento) e, em seguida, combina todos os componentes em uma única saída combined.svg .
Depois que o arquivo combined.svg for gerado, você deverá verificar novamente se não há linhas de corte redundantes compartilhadas por várias peças adjacentes, para economizar tempo/custo ao cortar. Eles devem ser detectados automaticamente (e destacados em vermelho na renderização acima), mas não custa nada verificar novamente. No Inkscape, selecione a ferramenta "Editar caminhos por nós" e selecione uma aresta para excluir - os pontos finais devem ficar azuis. Em seguida, clique em "Excluir segmento entre dois nós não terminais" e repita isso para todas as outras linhas de corte redundantes.
O design pode ser renderizado em um gif animado 3D giratório (visto acima) executando 3d/scripts/generate_gif.py , que gera 3d/build/animation/animation.gif
O script generate_gif.py executa várias instâncias do OpenSCAD em paralelo para renderizar o design de 360 graus em quadros png individuais, que são então combinados na animação gif final. Como parte da construção da animação, generate_gif.py renderiza o design com múltiplas configurações (invólucro opaco, invólucro transparente, sem invólucro e sem abas) definindo as variáveis render_enclosure e render_flaps .
O design pode ser renderizado em uma série de arquivos STL (um por cor usada no modelo) para ser exibido em um visualizador 3D interativo baseado na web. Semelhante ao projection_renderer usado para renderizar componentes individuais para corte a laser, o ColoredStlExporter detecta todas as cores usadas no modelo e as renderiza uma por uma para separar arquivos STL, junto com um manifesto que mapeia cada arquivo STL para sua cor RGB. . Os arquivos STL e o manifesto são carregados usando three.js para exibir um modelo interativo em um site usando WebGL. Consulte esta postagem do blog para obter mais detalhes sobre como o export e o renderizador three.js funcionam: Truques de renderização do OpenSCAD, Parte 3: Visualizador da Web.
Todos os componentes eletrônicos são desenvolvidos usando KiCad 5. A panelização é fornecida pelo KiKit e a geração gerber/BOM é fornecida pelo KiBot.
As renderizações e links de projetos mecânicos e elétricos acima são atualizados automaticamente em cada commit com a renderização mais recente. Veja esta postagem do blog para obter mais detalhes sobre como isso funciona: KiCad automatizado, renderização OpenSCAD usando Travis CI.
O layout do PCB pode ser renderizado em um SVG ou PNG (visto acima) executando electronics/scripts/generate_svg.py file.kicad_pcb . Isso usa a API de script Python do KiCad para renderizar várias camadas em arquivos SVG individuais, manipula-os para aplicar configurações de cor e opacidade e, em seguida, mescla-os em um único SVG. Para obter detalhes adicionais, consulte esta postagem do blog: Scripting de exportações KiCad Pcbnew.
Para revisar o projeto, um pacote PDF com informações sobre cobre, serigrafia e perfuração pode ser produzido executando electronics/scripts/generate_pdf.py file.kicad_pcb .
Arquivos Gerber para fabricação podem ser exportados executando electronics/scripts/generate_gerber.py file.kicad_pcb . Isso gera arquivos gerber e um arquivo de perfuração Excellon com as convenções de nomenclatura do Seeed Studio e produz um .zip que pode ser enviado para fabricação.
EESchema não é facilmente programável, portanto, para exportar o esquemático electronics/scripts/export_schematic.py inicia um X Virtual Frame Buffer (Xvfb) e abre a GUI eeschema dentro desse display virtual e, em seguida, envia uma série de pressionamentos de teclas codificados via xdotool para interagir com a GUI e clicar nas caixas de diálogo. Isso é muito frágil, mas parece funcionar bem por enquanto. Para obter detalhes adicionais, consulte esta postagem do blog: Usando automação de UI para exportar esquemas KiCad.
Eu adoraria ouvir sua opinião e perguntas sobre este projeto e ficarei feliz em incorporar qualquer feedback que você possa ter nesses designs! Sinta-se à vontade (e encorajado) para abrir problemas no GitHub, enviar-me um e-mail diretamente, entrar em contato no Twitter e envolver-se no desenvolvimento de código aberto e vamos continuar conversando e construindo juntos!
Este projeto está licenciado sob Apache v2 (consulte LICENSE.txt).
Copyright 2015-2024 Scott Bezek and the splitflap contributors
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
