Como construir um Ukulele Light-up !: 21 etapas

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

Eu toco o Ukulele. Meio medíocre (se essa é uma palavra), então pensei, "se você realmente quer impressionar as garotas, você precisa de um meio para distraí-las do desastre que está acontecendo no palco." Daí nasceu o "Ukulele Light-up".

Este projeto pega um kit Concert Ukulele e adiciona um LED controlado por Arduino em cada posição de corda e traste. Ele também adiciona um display OLED sofisticado e uma interface de usuário baseada em codificador rotativo para selecionar o modo e a intensidade da string de LED.

O hardware uke completo apresenta:

1. Arduino MICRO para fazer interface com a string de LED, display e dispositivo de entrada.
2. 48 LEDs coloridos individualmente programáveis
3. Um display OLED
4. Um codificador rotativo para entrada do usuário
5. Interface USB para alimentação externa e programação Arduino

O software uke tem:

1. Modos básicos de controle de luz que executam os LEDs em seus ritmos
2. Um modo de letreiro de teatro bacana (muito útil para apresentações!)
3. Controle de intensidade de LED
4. Uma biblioteca de acordes completa de todos os acordes de Ukulele de primeira posição (valor e caractere do acorde)
5. Capacidade de exibir texto corrido (verticalmente) usando um conjunto de caracteres exclusivo de 4 x 6 pixels

Este instrutível descreve o protótipo concluído. A saga de desenvolvimento completa está disponível AQUI, incluindo alguns erros educacionais (dolorosos) e uma lição valiosa sobre por que você DEVE terminar seu primeiro design até a conclusão (não importa o quão feio as coisas fiquem). Você nunca sabe todas as coisas que realmente não sabe até chegar ao fim (e ainda não sabe!), Mas você está muito melhor e muito mais inteligente para o próximo projeto.

Eu construí o protótipo em torno de um kit Grizzly Concert Ukulele. Começar com um kit alivia a preocupação com o corpo do uke (bem, principalmente) e elimina a maior parte do trabalho real do tipo luthier. Esses kits são bem completos e não tão caros no grande esquema das coisas (e menos dolorosos, pois você cometerá erros).

Etapa 1: Faça um Plano

A escala (ou escala) incluída em alguns kits já tem os trastes anexados. Isso é bom / ruim. É bom para economizar tempo, mas em termos de esquematizar um padrão de broca e mantê-lo no lugar durante o fresamento, é um pouco chato. Depois de destruir o fornecido no kit, optei (bem, não tive escolha a não ser comprar outro kit) para comprar um novo braço.

Ao projetar o braço da guitarra, precisamos calcular o aumento na espessura necessária para incorporar o PCB e os LEDs (e não se esqueça dos componentes passivos), mas não tanto que os LEDs estejam muito longe da superfície do braço da guitarra.

A placa de circuito impresso de LED (PCB) é projetada como uma placa simples de 2 camadas. Isso ajuda muito na montagem manual do fio de LED e fornece alguma resistência mecânica (é fibra de vidro e epóxi) ao pescoço do Ukulele. Iniciei o layout no Eagle, mas acabei usando o Altium Designer devido às limitações de tamanho da placa. O esquema Altium e os arquivos PCB estão aqui.

A escala do kit tinha apenas 0,125 polegadas de espessura. Portanto, assumindo uma PCB de 0,062 polegadas de espessura e permitindo 0,062 polegadas adicionais para os LEDs, significa que teríamos que cortar muito (como em todos) o braço da guitarra. Para compensar, podemos cortar parcialmente os bolsos para os LEDs no braço da guitarra com um bolso correspondente no braço para o PCB, ou podemos substituir todo o braço da guitarra (a opção que escolhi) por uma versão mais espessa da Luther Mercantile International (LMII), que tem 0,25 polegada para começar.

MAS, lembre-se de que você ainda terá que usinar o braço para compensar o aumento de espessura no braço da guitarra. A outra vantagem que você obtém é estética, já que o PCB agora está completamente embutido dentro do braço da guitarra, o que torna as bordas muito mais fáceis de terminar (e parecem muito mais agradáveis!) E simplifica o fresamento do braço.

Coisas de engenharia (ignore se quiser):

A propósito, isso realmente não compromete tanto a rigidez do pescoço. O material do PCB é muito mais rígido do que a madeira da escala original (módulo de mogno: 10,6 GPa versus módulo FR4: 24 GPa), além disso, como estamos construindo um Ukulele, não há uma grande quantidade de tensão nas cordas que poderia distorcer (torção ou urdidura) no pescoço.

Uma consideração muito interessante (que provavelmente ainda devo calcular) é o que acontece com a temperatura. Genericamente para madeira, paralelo ao grão, o coeficiente térmico de expansão é aproximadamente 3 x 10 ^ -6 / K, e para FR4 é 14 × 10 ^ −6 / K. Portanto, há uma diferença bastante significativa. A preocupação é que a tensão seja criada no braço conforme a temperatura varia, o que por sua vez desafina as cordas. Isso é algo que poderia ser compensado aplicando-se uma camada semelhante no lado oposto do eixo neutro ou colocando o FR4 o mais próximo possível do eixo neutro. Mas isso vai sobrar para 2.0… Algo para modelar e avaliar.

Os componentes eletrônicos estão alojados no corpo do uke. Furos são feitos na parede lateral (não na placa de som!) Do UKE para dar espaço para o display e o codificador rotativo, além de uma placa de acesso para segurar o Arduino Micro e fornecer acesso à interface USB. O design e a localização da placa de acesso / montagem provavelmente poderiam ser melhorados para fazer a conexão USB sair em um local mais conveniente, mas do jeito que está, não é tão ruim, já que não atrapalha quando você está jogando.

O esboço das etapas é o seguinte:

1. Reúna materiais
2. Obtenha as ferramentas de que precisa
3. Frese o pescoço para acomodar a escala mais espessa
4. Faça a fretboard para fazer orifícios nos locais necessários e para criar bolsos para a placa e LEDs
5. Obtenha e construa o PCB que contém os LEDs
6. Faça orifícios de acesso no corpo do Ukulele para o display OLED, codificador rotativo e painel de acesso
7. Faça placas de cobertura
8. Conecte os fios ao PCB; conecte e teste os eletrônicos
9. Prenda o pescoço ao corpo do Ukulele
10. Perfure uma retenção de acesso para passar os fios do PCB no corpo
11. Alinhe e cole o PCB e a escala no braço
12. Nivele as bordas da escala até o pescoço (remova o excesso de material)
13. Instale os fios da fricção
14. Aplique a máscara e aplique o acabamento ao Ukulele
15. Alinhe e prenda a ponte
16. Instale a eletrônica e teste.
17. Instale sintonizadores e encadeie o instrumento
18. Programe o controlador Uke
19. Surpreenda o mundo com o seu Ukulele incrível!

Etapa 2: Reúna os materiais

Nossa lista de materiais é parecida com esta:

1. Kit Ukulele - usei um kit Ukulele Grizzly Concert (Kit Uke Grizzly na Amazon), mas parece que ele foi descontinuado. Zimo faz um modelo semelhante (Zimo Uke Kit @ Amazon) que parece que vai dar conta do recado
2. Escala de Ukulele, pré-entalhada (LMII Uke Fingerboards). Eles vão encaixar o braço da guitarra em sua escala, o que evita muitos problemas
3. Epóxi - para colar o braço da guitarra. Eu escolhi o epóxi por ser compatível com o material do PCB. Procure algo com pelo menos 60 minutos de vida profissional. NÃO use tipos de 5 minutos, você precisa de tempo para fazer ajustes
4. Fios de traste - também disponíveis na LMII
5. PCB personalizado - arquivos Altium estão aqui. Optei por material tipo FR4 normal. Placas Flex (poliimida) seriam uma alternativa interessante (embora mais cara), pois podem ser muito mais finas
6. LEDs de Neopixel 48x (SK6812). Disponível na Adafruit e Digikey
7. 48x 0,1uF 0402 tampas - maior é aceitável, mas você deve observar o posicionamento
8. Fio de conexão - pelo menos 4 a 6 cores para evitar confusão, usei principalmente fio de calibre 28. Observe a queda de CC nas conexões de alimentação do LED (VCC e TERRA … essa corrente tem que retornar à fonte!)
9. Codificador giratório - PEC16-4220F-S0024
10. Botão de madeira extravagante - para o codificador rotativo (comprei o meu no LMII)
11. Tela OLED - a partir de telas OLED de sistemas 4D
12. Bateria externa USB - mais barata o tempo todo, além disso, você pode carregar peças sobressalentes!
13. Arduino MICRO
14. Folha de latão - para fazer a placa para segurar o arduino e a moldura para a tela
15. Consumíveis diversos, incluindo: lixa, acabamento de uretano, palitos de picolé, elásticos, solda, fluxo, escovas, fita dupla-face (gosto da fita UHC da 3M) e pequenos parafusos de madeira de latão (para a placa)
16. Aprimoramentos opcionais de Ukulele - melhores afinadores, melhores cordas, melhor porca e sela, incrustação se você quiser mostrar suas proezas de luthier)

Etapa 3: Obtenha as ferramentas de que você precisa

Mais cedo ou mais tarde, você precisará obter ou obter acesso a estes:

Nossa lista de ferramentas inclui:

1. Fresadora - CNC preferível, mas você pode até sobreviver com uma fresadora e muita sorte. Eu usei um combo CNC fresadora / roteadora
2. Brocas de roteador - de preferência de carboneto. Brocas de roteador escolhidas em vez de fresas de topo, uma vez que estamos usinando madeira, não metal
3. Grampos - muitos deles. Principalmente necessário para segurar as peças durante a colagem
4. Ferro de soldar - ponta pequena para solda de montagem em superfície
5. Microscópio ou lupa - você pode tentar soldar apenas com seus olhos, mas eu não recomendaria, no mínimo 10x
6. Pinças (para colocar as peças no lugar)
7. Ferramentas de desgaste (veja as ferramentas adequadas em LMII aqui, mas usei o que tinha em casa e fiz; martelos, limas e cortadores)
8. Ferramentas manuais variadas, como cinzéis de madeira, chaves de fenda, golpe suave ou martelo de couro cru (para desgaste), etc.
9. Abrasivos - vários grãos de lixa

Nossas ferramentas de software incluem (algumas são opcionais, dependendo do seu orçamento / engenhosidade):

1. Software Arduino
2. O código-fonte Ukulele (https://github.com/conrad26/Ukulele)
3. Pacote de layout PCB - usei Altium porque a versão gratuita do Eagle não suportava o tamanho de placa que eu queria. Altium é um pacote de layout completo e não está realmente em uma faixa de preço para amadores. Incluí os arquivos Gerber no meu site para o protótipo, mas eles definitivamente precisam de uma atualização
4. Software de modelagem 3D - usei o SolidWorks, mas uma alternativa gratuita é o FreeCAD (https://www.freecadweb.org/)
5. Software CAM - como o FeatureCAM da Autodesk para criar o arquivo de fresagem NC.

A combinação da exportação de arquivo de etapas 3D da Altium junto com um modelo 3D do braço da guitarra elimina grande parte da dificuldade em garantir que tudo esteja alinhado, mas não é um requisito. Um layout cuidadoso obterá o mesmo resultado.

Agora que sabemos o que queremos e o que precisamos fazer, vamos construir um Ukulele.

Etapa 4: fresar o pescoço para acomodar a escala mais espessa

Antes de fresar, observe que o nivelamento da superfície de montagem da escala original DEVE ser mantida, ou você terá uma escala torcida, o que leva a todos os tipos de problemas com o nivelamento do braço.

Só não vá lá, não se apresse e prenda com cuidado e rigidez o pescoço e verifique o alinhamento com a fresa da tupia em todo o pescoço antes de cortar. O tempo gasto aqui o poupará muito sofrimento mais tarde.

Um dos motivos pelos quais optei por uma escala mais espessa em vez de uma incrustação no braço foi a área de superfície de montagem (colagem) aumentada. Outra razão é que simplifica o fresamento do pescoço. Você simplesmente corta toda a superfície com a altura necessária.

Etapa 5: Obter e construir a PCB segurando os LEDs

Soldei à mão todo o conjunto. Os pacotes de LEDs são especialmente fáceis de derreter, portanto, tome cuidado para não danificá-los. Eu sugiro usar uma pulseira estática, já que a corda depende de cada LED funcionando.

O design do Fretboard é baseado em LEDs WS2812B. Decidi fazer apenas a primeira oitava do braço da guitarra (48 LEDs !!). Cada LED pode ser considerado um bit em um registro de deslocamento. O registro de deslocamento tem clock de 800 kHz. Usei a biblioteca Adafruit (consulte a seção de programação) para colocar as coisas em funcionamento rapidamente.

Comecei o design no Eagle, mas o tamanho da placa é limitado a 4 x 5 polegadas, então tive que (ou mais corretamente, optei por) mudar para Altium. Eu uso Altium no trabalho, então, na realidade, ele tornou as coisas mais rápidas para mim. O projeto Altium, esquemático e arquivos pcb (e partes da biblioteca) estão no meu site. A prancha tem formato trapezoidal e tem cerca de 25 centímetros de comprimento. Eu acho que deveria ter tentado comprimir o contorno um pouco mais (próximo giro!) A montagem não foi ruim, mas se você puder pagar, eu realmente recomendo um ferro de solda decente (ferros de solda JBC) e um bom microscópio. Sim, sou mimado e não, não tenho esse tipo de coisa no meu laboratório doméstico. Sou barato.

Mandei fazer as pranchas em Sunstone. $ 129 para duas placas. Turno garantido de uma semana. Porém, não economize no transporte. Não percebi que usei o aterramento da UPS e acabei esperando mais uma semana pela chegada das minhas pranchas. O tempo total de montagem foi de cerca de 2 horas (98 peças).

Etapa 6: fresar a escala

Precisamos fresar a escala para fazer orifícios nos locais necessários e criar bolsos para a placa e LEDs.

Eu criei um modelo 3D do braço da guitarra concluído no Solidworks e criei a rotina de fresamento CNC usando o FeatureCAM.

A parte inferior do braço da guitarra (mais próxima da boca de ressonância) precisará ser mais fina para compensar a mudança de degrau na altura entre o braço e o corpo. Definitivamente, vale a pena testar a adaptação várias vezes para ter certeza de que é um ajuste razoavelmente confortável.

Em retrospecto, eu deveria ter cortado as partes não utilizadas do braço da guitarra para fazê-lo caber melhor na fresa (minha fresa barata só tinha um curso no eixo X de 12 ). A ordem das operações deve ser configurada para os primeiros ajustes de espessura da fresa antes bolsos de fresagem, o que deve levar a menos rupturas entre os bolsos.

Faça ajustes manuais conforme necessário para adicionar espaço para a fiação. Uma coisa importante a notar é que em alguns dos bolsos, eu quebrei a fenda onde o fio do traste irá. Dado que é um condutor, certifique-se de que ele não acabe causando um curto-circuito em nada importante. Também diminui a resistência do material que mantém o traste no lugar. O design deve ser modificado para nunca cruzar com uma ranhura do traste.

Etapa 7: Orifícios de acesso do moinho no corpo do Ukulele

Fiz manualmente os orifícios de acesso no corpo. A parte mais difícil é encontrar a região "mais plana" do que é uma superfície muito curva. Marque o contorno a lápis e afaste gradualmente o material até obter um ajuste perfeito para o display OLED. Eu obtive uma moldura de latão usinada e fixei-a usando fita adesiva VHB 3M.

Como nenhum dos dois requer grande precisão, os orifícios do codificador rotativo e do painel de acesso são muito mais fáceis de criar.

Etapa 8: Faça as placas de cobertura

Você também precisa fabricar as placas de cobertura da moldura da tela e do painel de acesso. O painel de acesso precisa de um orifício (retangular) para o conector USB (micro). Basta usar o conector existente no Arduino, já que não há muitas opções de montagem em painel para micro USB. (embora se eu estivesse projetando do zero, então daria uma olhada em um desses)

Para segurar a placa no lugar, faça os suportes em L de latão e solde-os na parte de trás da placa de acesso. Isso permite alguma latitude no posicionamento. Para obter o posicionamento correto, primeiro crie uma placa de montagem perfboard (com orifícios de montagem) para o Arduino MICRO e prenda os suportes L a ela usando parafusos de máquina 2-56. Você pode então ajustar o local para alinhar a porta USB e marcar com precisão os locais para os suportes na placa. Remova os suportes do perfboard e solde-os no lugar. Finalmente monte o conjunto perfboard.

Usei quatro pequenos parafusos de madeira de latão para segurar o painel de acesso de latão no lugar.

Neste ponto, recomendo um ajuste de teste antes do início da montagem final. Esta etapa é opcional, mas recomendada. É muito mais fácil fazer ajustes antes de colar.

Etapa 9: Conecte os fios ao PCB; Conecte e teste os eletrônicos

Não conecte permanentemente os componentes eletrônicos ainda. Conecte os fios ao PCB, certificando-se de deixar folga suficiente para rotear para fora do orifício de acesso. Eventualmente, eles precisam ser permanentemente conectados à placa Arduino MICRO (as fotos mostram um Arduino UNO, que usei para desenvolvimento de código)

Etapa 10: prenda o pescoço ao corpo do Ukulele

Prenda o pescoço ao corpo do Ukulele seguindo as instruções incluídas no kit Ukulele. Particularmente, observe o alinhamento da superfície da escala com o corpo do uke.

Etapa 11: Faça um orifício de acesso para passar os fios da PCB para o corpo

Assim que a cola estiver seca, faça um orifício de aproximadamente 1/4 (10 mm) em um ângulo para permitir que os fios do PCB passem pelo corpo do Ukulele. Certifique-se de não danificar a placa de ressonância.

Pode ser necessário criar um pequeno bolso também para permitir a espessura dos fios sob a placa (ou, opcionalmente, colocar as conexões na parte superior e incluir um relevo no braço da guitarra).

Outro ajuste de teste não faria mal neste ponto.

Etapa 12: alinhe e cole a PCB e a escala no pescoço

Eu sugiro pensar sobre a fixação (e experimentar!) Antes de colar. Você pode querer moldar um bloco na parte inferior do pescoço para obter uma superfície de fixação plana. A escala é maior do que o pescoço neste ponto, então você precisa permitir isso.

Tenha muito cuidado para não deixar o epóxi em qualquer superfície que você deseja terminar mais tarde. Melhor ainda, aplique o mascaramento a todas as superfícies não coladas antes de colar para ter certeza de que vai apenas onde você deseja.

Use epóxi com no mínimo 60 minutos de vida útil … você vai precisar de tudo isso.

Cole o PCB no lugar primeiro, certificando-se de que o excesso de cola não extrude para a superfície de colagem da escala. Isso fornece um método para alinhar o braço da guitarra ao pescoço. O PCB tem um acabamento de máscara de solda liso, então eu o desbastei com um pouco de lixa para dar ao epóxi um acabamento superficial ligeiramente melhor.

Alinhe e cole o braço da guitarra ao pescoço. Tenha cuidado para não deixar bolsos que possam mais tarde se tornar ressonantes (zumbido!). Também tome cuidado para não deixar cola nas superfícies dos LEDs.

Depois que a cola secar, você pode querer conectar e testar os componentes eletrônicos mais uma vez. Um LED ruim vai fazer você odiar a vida. Eu tinha um LED ruim (o primeiro!) No protótipo e tive que fazer alguns trabalhos criativos em madeira para acessar o LED com defeito e remendá-lo de forma limpa.

Etapa 13: Nivele as bordas da escala até o pescoço e adicione fios de traste

Assim que a cola secar, você pode começar a fazer o acabamento das bordas. Cortei cuidadosamente o excesso de material da escala (usando um moinho) e acabei o último milímetro com lixa manual.

A adição dos fios do traste pode ser feita simplesmente com um martelo (com uma face de plástico para evitar estragar). Só não martele com muita força. Se você combinou o fio do traste com os slots, eles devem entrar sem muita dificuldade.

O que você precisa observar é quebrar a fina superfície do bolso do LED. No protótipo, permiti que alguns bolsos de LED (perto do 12º traste, onde o espaço fica apertado) se estendessem para o slot do traste. É uma má ideia, uma vez que cria um ponto fraco que pode (e quebrou) assim que o fio do traste é inserido.

Etapa 14: aplique a máscara e aplique o acabamento ao Ukulele

Mascare o braço da guitarra (não consegue acabamento) e a área de colagem da ponte e comece a aplicar o acabamento.

Ao mascarar a área da ponte, leia as instruções do seu kit e verifique novamente o comprimento da escala para ter certeza. O kit que usei para o protótipo usava o comprimento de escala errado e, portanto, fornecia as dimensões erradas para localizar a ponte (mas tinha uma nota para verificar o site para obter as instruções mais recentes!). Meu instinto me disse que era errado, mas aceitei cegamente a autoridade.

É sempre melhor entender POR QUE você está fazendo algo, em vez de seguir as instruções cegamente.

Para finalizar, existem muitos tutoriais de Luthiers que sabem o que estão fazendo na web, então eu recomendo consultá-los antes de pular para o processo de finalização.

Eu, claro, não fiz isso, então acabei usando o selante errado, resultando em uma superfície muito granulada. Não faça isso.

Faça sua lição de casa.

Etapa 15: alinhar e anexar a ponte

Esta etapa é bastante direta, mas, novamente, planeje seu método de fixação e experimente-o com antecedência antes de colar. Usei uma cola de madeira padrão para prender a ponte.

Etapa 16: Instale os eletrônicos e teste

Agora é a hora de deixar sua fiação bonita. Além disso, você não quer que ele se sacuda dentro do corpo e faça ruídos de zumbido ou pior ainda quebrando no palco.

O código do Arduino pode ser atualizado por meio da porta USB, portanto, não há realmente necessidade de desmontá-lo, a menos que você queira fazer alguns ajustes.

Etapa 17: instalar sintonizadores e amarrar o instrumento

Você provavelmente também precisará nivelar os trastes e brincar um pouco com a configuração, mas por que se preocupar agora, quando você está tão perto do fim?

Eu atualizei os afinadores e usei cordas Aquila legais, o que não ajudou em nada o som. Portanto, mantenha isso em mente enquanto você está gastando dinheiro em um projeto ukulele …

Passo 18: Programando o Uke

O código final do Arduino está no Github. Existem algumas linhas no código para oferecer suporte a melhorias futuras (como uma função de metrônomo e "controles deslizantes" para a tela (um elemento de IU que se parece com um controle deslizante)

Este código usa uma Biblioteca do Codificador Rotativo (Biblioteca do Arduino do Codificador Rotativo) para lidar com a entrada do usuário do Codificador Rotativo.

Ele também usa a biblioteca Adafruit Neopixel e o código de exemplo localizado aqui. Os modos teatro e arco-íris são derivados de exemplos fornecidos com a biblioteca. (veja strandtest.ino).

O driver de exibição é fornecido por sistemas 4D e pode ser encontrado no Github aqui.

Existem duas funções exclusivas implementadas para o projeto Ukulele. O primeiro implementa a biblioteca de acordes e o segundo exibe uma mensagem de texto de rolagem usando um conjunto de caracteres personalizado.

O diagrama em anexo mostra as localizações dos LEDs do braço da guitarra e como eles estão conectados. O LED 0 está localizado no canto superior direito.

Etapa 19: como exibir um acorde

A função displayChord exibe as posições dos dedos (primeira posição apenas por enquanto) para cada acorde. Os acordes selecionados pelo usuário (nota raiz e qualidade) são armazenados como um par de índices. Estes, por sua vez, são usados para pesquisar os dedilhados de cada acorde.

Usei a notação "GCEA" para armazenar acordes (por exemplo, "A" é "2100"). Os acordes são pré-calculados para cada nota fundamental e armazenados em uma variável correspondente à qualidade do acorde. (portanto, A maior é armazenado na primeira localização da matriz "majorChords", correspondendo a "2100").

char * majorChords = {"2100 / n", "3211 / n", "4322 / n", "0003 / n", "1114 / n", "2220 / n", "3331 / n", " 4442 / n "," 2010 / n "," 3121 / n "," 0232 / n "," 5343 / n "};

Observe que, como esta é uma string de texto, cada dígito também pode representar um valor hexadecimal para contabilizar as posições dos trastes maiores que 9. Ou seja, A e B representariam os LEDs 10 e 11. Para acordes de primeira posição, isso não foi um problema).

A corda do LED é ligada longitudinalmente em linhas de 12 (uma oitava) ao longo de cada corda (começando com a corda A), a sequência subsequente de 12 começa na primeira casa da próxima corda (veja o diagrama na etapa 18). Isso é importante para o algoritmo determinar quais luzes acender para um determinado acorde. Isso significa que os pixels de 0 a 11 são os LEDs da string A, de 12 a 23 são os LEDs da string E e assim por diante. Ao analisar um A = "2100" (armazenado como uma string, há também um terminador nulo "\ n" no código), nós o interpretamos como: nenhum pixel na string A está aceso, nem na string E, pixel 0 (traste 1) na corda C está aceso e o pixel 1 (traste 2) na corda G. Observe que um "0" está desligado, não o primeiro LED. Com base na fiação, queremos acender os LEDs 24 e 37. O código para exibir um acorde é mostrado abaixo.

for (int i = 0; i <4; i ++) {if (int (chord - '0')) {// algoritmo para analisar a string do acorde int ledNumber = int (chord - '0') + (3 - i) * 12 - 1; // veja a discussão acima, o (3-i) é para reverter o índice strip.setPixelColor (ledNumber, 0, 125, 125); // setPixelColor (ledNumber, valor vermelho, valor verde, valor azul)}}

A instrução if verifica se o led está desligado. Se não for, ele pega o valor ascii do caractere, acorde , e subtrai o valor ascii para '0' para fazer o ledNumber acender.

strip é uma instância da classe Adafruit_NeoPixel. A função setPixelColor define a cor do pixel calculado (fixo em (0, 125, 125) neste caso.

Etapa 20: como exibir uma mensagem de rolagem

Portanto, temos um conjunto de LEDs de 12 x 4 … por que não fazê-lo exibir algo diferente de padrões de luz bastante aleatórios!

O primeiro problema é que a altura da tela (4) é bastante limitada devido ao número de cordas em um Uke. A rolagem horizontal seria praticamente ilegível, mas em orientações verticais, podemos suportar 4 x 5 caracteres em execução vertical.

Organizar os caracteres em cinco linhas "verticais" significa que dois caracteres podem ser exibidos simultaneamente, permitindo um espaço de uma linha entre cada caractere.

A dificuldade era que não havia um conjunto de caracteres 4 x 5 padrão. Eu fiz o meu usando a planilha anexa. Atribuí cada linha a um único valor hexadecimal (4 bits que representam qual pixel está ativado ou desativado). A combinação dos cinco valores hexadecimais constitui um caractere (por exemplo, "0" é 0x69996).

Os valores de cada caractere são armazenados em uma matriz na ordem ASCII. O conjunto de caracteres faz alguns compromissos com certas letras, mas a maioria é razoavelmente clara. (os rabiscos na parte inferior da planilha são ideias com as quais eu estava brincando, já que temos a cor como uma opção, podemos adicionar "profundidade" ao personagem e possivelmente obter alguma resolução adicional.

A string a ser exibida está contida na variável de string, mensagem.

Um buffer é criado para representar a exibição de caracteres. Acho que poderia simplesmente ter criado um grande buffer com toda a sequência de mensagens traduzida, especialmente porque a maioria das mensagens terá menos de 20 caracteres ou mais. No entanto, optei por criar um buffer fixo de três caracteres (18 bytes). Apenas dois dos personagens estão sendo exibidos ativamente, e o terceiro é um olhar para a frente, onde o próximo personagem é carregado. A string de LED (pense nisso como um grande registrador de deslocamento) é carregada com os 48 bits da string. Perdi algum espaço de memória para tornar isso mais fácil de conceituar. Cada nibble obtém seu próprio local de memória, dobrando o requisito de memória, mas não é muito devido ao tamanho do buffer.

O buffer é carregado com o próximo caractere quando o índice de saída (ponteiro) chega a um limite de caractere (outputPointer em 5, 11 ou 17).

Para carregar o buffer, pegamos o primeiro caractere em "mensagem" como um valor ASCII e subtraímos 48 para obter o índice no array asciiFont. O valor nesse índice é armazenado em codedChar.

A primeira parte da mensagem deslocada corresponde aos LEDs 47, 35, 23 e 11 (a parte inferior do visor). Portanto, para o número zero 0x0F999F, o F (à esquerda) é deslocado primeiro, 9 segundos e assim por diante.

O próximo personagem é carregado mascarando cada mordida e deslocando-o para a direita. Para o exemplo acima, o algoritmo fornece (0x0F999F & 0xF00000) >> 20, então (0x0F999F & 0x0F0000) >> 16, etc.

índice interno; if (outputPointer == 17 || outputPointer == 5 || outputPointer == 11) {char displayChar = message.charAt (messagePointer); // pega o primeiro caractere da mensagem long codedChar = asciiFont [displayChar - 48]; if (displayChar == 32) codedChar = 0x000000; messageBuffer [bytePointer + 5] = byte ((codedChar & 0xF00000) >> 20); // mascara tudo menos o último nibble e o desloca em 20 (e assim por diante) messageBuffer [bytePointer + 4] = byte ((codedChar & 0x0F0000) >> 16); // isso deve colocar um nibble por localização de memória messageBuffer [bytePointer + 3] = byte ((codedChar & 0x00F000) >> 12); // todos os seis representam no caractere messageBuffer [bytePointer + 2] = byte ((codedChar & 0x000F00) >> 8); messageBuffer [bytePointer + 1] = byte ((codedChar & 0x0000F0) >> 4); messageBuffer [bytePointer] = byte ((codedChar & 0x00000F)); if (bytePointer == 0) {// manipula o loop no bytePointer bytePointer = 12; } else {bytePointer - = 6; // estamos enchendo de baixo para cima; NOTA: é necessário reverter isso para ver se torna mais fácil} if (messagePointer == message.length () - 1) {// manipular o loop na mensagem messagePointer = 0; } else {messagePointer + = 1; // mover para o próximo caractere}}

Uma vez que o buffer é carregado, torna-se uma questão de rastrear onde o ponteiro de saída está e carregar a string de LED com os 48 bits corretos (os 4 atuais e os 44 anteriores). Conforme mencionado anteriormente, strip é uma instância da classe NeoPixel e setPixelColor define a cor (RGB) de cada pixel. A função show () muda os valores de exibição para string de LED.

// loop para deslocar continuamente o buffer

// deseja escrever toda a faixa em cada passagem pelo loop, apenas a localização inicial muda para (int row = 12; row> 0; row--) {index = outputPointer + (12-row); if (índice> 17) índice = outputPointer + (12 linhas) -18; // loop se for maior que 17 para (int coluna = 4; coluna> 0; coluna--) {strip.setPixelColor (uint16_t (12 * (coluna-1) + (linha-1)), uint8_t (RedLED * (bitRead (messageBuffer [índice], coluna-1))), uint8_t (GreenLED * (bitRead (mensagemBuffer [índice], coluna-1))), uint8_t (BlueLED * (bitRead (mensagemBuffer [índice], coluna-1)))); // em cada local, acenda o LED se o bit for um}} // outputPointer aponta para o byte mais baixo atual na string de exibição if (outputPointer == 0) outputPointer = 17; else outputPointer - = 1; strip.show (); }

Etapa 21: Surpreenda o mundo com seu ukulele incrível

O protótipo final do Ukulele levou cerca de 6 meses de partidas e paradas para funcionar.

Muita tecnologia nova para aprender e talvez alguma teoria musical e marcenaria para arrancar!

O que fazer para a próxima versão?

1. Livre-se do display e do codificador rotativo. Substitua-os por um módulo Bluetooth conectado ao arduino. Controle-o remotamente usando um telefone ou tablet. Tudo fica melhor com Bluetooth.
2. Atualizar padrões de acordes remotamente em tempo real. É melhor deixar algo para o aplicativo.
3. Tampas de LED. A versão atual não faz nada para evitar que a sujeira entre nos orifícios do LED. Um amigo fez um monte de lentes pequenas, mas nunca consegui descobrir como fazê-las ficar no lugar corretamente.
4. Materiais alternativos da escala, talvez algo claro, desde que os trastes se mantenham.
5. Mais luzes! Elimine a restrição do texto adicionando mais "linhas". Esta é realmente uma limitação causada pelo tamanho da escala e dos corpos de LED.

Novamente, veja o companheiro Instructable que descreve o conjunto de caracteres que tive que criar para permitir a rolagem do texto.

Muito obrigado por chegar até aqui! Mahalo!