Chapéu extravagante de LED: 5 etapas (com fotos)

2025 Autor: John Day | [email protected]. Última modificação: 2025-01-13 06:58

Sempre quis fazer um projeto com o Arduino, mas nunca tive grandes ideias para um até que minha família foi convidada para uma festa de chapéus chique. Com duas semanas de prazo de entrega, eu estava curioso para saber se poderia planejar e executar um chapéu de animação LED sensível ao movimento. Acontece que eu poderia! Provavelmente exagerei um pouco, mas o projeto total custou cerca de US $ 80. Com experimentação e alguma codificação, você poderia fazer isso por menos.

O objetivo com o chapéu era o seguinte:

1. Faça com que um conjunto de luzes se mova do centro da frente do chapéu para trás, uma luz de cada lado
2. Altere a velocidade de viagem da luz ditada pela inclinação do chapéu da frente para trás
3. Permita que as luzes invertam quando a faixa do chapéu foi inclinada para baixo (ou seja, emule o efeito da gravidade nas luzes)
4. Alterar a cor com base na inclinação do chapéu da esquerda para a direita
5. Sentir choques e exibir um efeito especial
6. Sinta o usuário girando e exiba um efeito especial
7. Ter tudo contido no chapéu

Etapa 1: peças necessárias

Usei os seguintes componentes principais (links não afiliados da Amazon incluídos):

• Microcontrolador Teensy LC - escolhi este em vez de um Arduino normal devido ao seu tamanho pequeno e por ter uma conexão especial para controlar meus LEDs, bem como um forte suporte de biblioteca e comunidade.
• Sensor posicional baseado em BNO055 da Bosch - honestamente, um dos primeiros sobre os quais encontrei documentação. Existem opções muito menos caras, no entanto, uma vez que você descubra o Bosch, ele faz muito por você que, de outra forma, você teria que fazer no código
• Faixa de LED endereçável WS2812 - Eu escolhi um comprimento de 1 metro com 144 LEDs por metro. Ter essa densidade ajuda a que a luz pareça mais em movimento do que elementos individuais acendendo em sequência.

E os seguintes componentes secundários:

• Um chapéu - qualquer chapéu com uma fita serve. Este é um boné de $ 6 de uma loja local. Se tiver costura nas costas, será mais fácil passar a fiação. Preste atenção se a faixa do chapéu está colada, pois isso também causará alguma dificuldade extra. Este é costurado na parte superior, mas a parte inferior pode ser puxada para cima facilmente.
• Resistores de 4,7 K ohm
• Caixa de 3 pilhas AAA - usando 3 pilhas AAA, a tensão de saída está exatamente na faixa que a eletrônica deseja, o que simplifica as coisas. AAA cabe em um chapéu mais fácil do que AA e ainda tem um excelente tempo de execução.
• Fio de bitola pequena - usei um fio sólido de um projeto anterior de LED.
• Ferro de solda e solda
• Algum spandex que combine com a cor interna do chapéu e linha

Sugerido, mas opcional:

• Conectores rápidos para os fios da bateria
• Ferramenta Mãos que Ajudam, essas coisas são muito pequenas e difíceis de soldar

Etapa 2: modificar o chapéu

Você vai precisar de um lugar no chapéu para montar os componentes eletrônicos e um lugar para a bateria. Minha esposa trabalha com roupas profissionalmente, então pedi a ela conselhos e ajuda. Acabamos criando dois bolsos com spandex. O primeiro bolso menor para a frente é pontudo como o próprio chapéu, de modo que, quando os componentes eletrônicos são instalados, o sensor de posição é mantido no lugar razoavelmente bem, mas pode ser facilmente removido, se necessário. O segundo bolso na parte de trás serve para segurar a bateria no lugar.

Os bolsos eram costurados com linha que combinava com a cor do chapéu, ao longo da linha da coroa. Dependendo do estilo do chapéu e dos materiais, ele é feito de YMMV com esta técnica.

Também descobrimos que a faixa do chapéu se dobrava de um lado e estava totalmente costurada ao chapéu naquele local. Tivemos que remover a costura original para colocar os LEDs sob a banda. Durante a construção, ele foi mantido no lugar com alfinetes e, em seguida, costurado com linha correspondente quando concluído.

Por fim, abrimos a costura na parte de trás do boné onde ela é coberta pela banda. Colocamos o chicote de fios que veio com os LEDs por meio dessa costura e alinhamos o primeiro LED na faixa para ficar bem na costura. Em seguida, envolvemos os LEDs ao redor do chapéu e cortamos a tira de modo que o último LED ficasse ao lado do primeiro. A faixa de LED pode ser mantida no lugar apenas com a faixa do chapéu, no entanto, dependendo da faixa e do material, pode ser necessário prender os LEDs costurando ou colando.

Etapa 3: conecte-o

A placa Teensy e os LEDs funcionarão com alimentação de 3,3 V a 5 V. É por isso que escolhi usar 3 pilhas AAA, a voltagem de saída de 4,5 V está bem nessa faixa, e elas têm muito tempo de execução para a forma como programei os LEDs para funcionarem. Você deve ser capaz de obter bem mais de 8 horas de tempo de execução.

Conectando a energia

Liguei os fios positivo e negativo da caixa da bateria e LEDs juntos e, em seguida, soldou no Teensy em locais apropriados. O positivo da bateria precisa ser conectado ao pino superior direito do Teensy no diagrama (identificado como Vin na placa), e o negativo pode ser conectado a qualquer pino identificado como GND. Convenientemente, há um diretamente no lado oposto da placa, ou ao lado do pino Vin. O diagrama de pinagem completo da placa pode ser encontrado na parte inferior desta página. E, em alguns casos, uma cópia em papel é incluída quando você faz o pedido da placa.

Se você está planejando executar um código que tem apenas alguns LEDs ligados de uma vez, você pode alimentar os LEDs do próprio Teensy, usando uma saída de 3,3v e GND, no entanto, se você tentar extrair muita energia, poderá danificar a placa. Portanto, para ter o máximo de opções, é melhor conectar os LEDs diretamente à fonte da bateria.

Fiação dos LEDs

Escolhi o Teensy LC para este projeto porque tem um pino que torna muito mais fácil conectar LEDs endereçáveis. Na parte inferior da placa, o pino que fica em segundo lugar a partir do pino esquerdo espelha o pino 17, mas também tem 3,3 V nele. Isso é conhecido como pull-up e, em outras placas, você teria que conectar um resistor para fornecer essa tensão. No caso do Teensy LC, você pode simplesmente conectar esse pino diretamente ao cabo de dados de seus LEDs.

Fiação do sensor de posição

Algumas das placas BNO055 disponíveis são muito mais rígidas quanto à voltagem e desejam apenas 3,3v. Por causa disso, conectei o Vin na placa BNO055 a partir da saída de 3,3 V dedicada no Teensy, que é o terceiro pino à direita. Você pode então conectar o GND no BNO055 a qualquer GND no Teensy.

O sensor de posição BNO055 usa I2c para falar com o Teensy. I2c requer pull-ups, então eu conectei dois resistores de 4,7 K ohm de uma saída de 3,3 V no Teensy aos pinos 18 e 19. Em seguida, conectei o pino 19 ao pino SCL na placa BNO055 e 18 ao pino SDA.

Dicas / truques de fiação

Para fazer este projeto, usei arame sólido em vez de trançado. Uma vantagem do fio sólido é ao soldar em placas de protótipo como essas. Você pode descascar um pouco do fio, dobrá-lo a 90 graus e inseri-lo na parte inferior de um dos terminais, de forma que a extremidade cortada do fio fique saliente acima da placa. Você só precisa de uma pequena quantidade de solda para prendê-lo ao terminal e pode cortar o excesso facilmente.

O arame sólido pode ser mais difícil de trabalhar, pois tende a ficar como está dobrado. No entanto, para este projeto isso foi uma vantagem. Cortei e moldei meus fios de forma que a orientação do sensor de posição fosse consistente enquanto inseria e removia os componentes eletrônicos do chapéu para ajustes e programação.

Etapa 4: Programação

Agora que tudo está montado, você precisará de uma ferramenta de programação compatível com o Arduino. Usei o IDE do Arduino real (funciona com Linux, Mac e PC). Você também precisará do software Teensyduino para fazer a interface com a placa Teensy. Este projeto usa fortemente a biblioteca FastLED para fazer a programação de cor e posição dos LEDs.

Calibrando

A primeira coisa que você vai querer fazer é ir ao excelente repositório GitHub de Kris Winer para o BNO055 e baixar seu esboço BNO_055_Nano_Basic_AHRS_t3.ino. Instale esse código com o Serial Monitor em execução e ele dirá se a placa BNO055 está online corretamente e passa nos autotestes. Ele também orientará você na calibração do BNO055, o que fornecerá resultados mais consistentes posteriormente.

Primeiros passos com o esboço Fancy LED

O código para o chapéu Fancy LED está especificamente anexado e também no meu repositório GitHub. Pretendo fazer mais ajustes no código e eles serão postados no repositório do GitHub. O arquivo aqui reflete o código quando este Instructable foi publicado. Depois de baixar e abrir o esboço, há algumas coisas que você precisa alterar. A maioria dos valores importantes a serem alterados estão no topo como instruções #define:

Linha 24: #define NUM_LEDS 89 - mude para o número real de LEDs em sua faixa de LED

Linha 28: #define SERIAL_DEBUG false - você provavelmente desejará torná-lo verdadeiro, para que possa ver a saída no monitor serial

Código de detecção de posição

A detecção de posição e a maioria dos seus ajustes começam na linha 742 e vão até 802. Obtemos dados de Pitch, Roll e Yaw do sensor de posição e os usamos para definir valores. Dependendo de como seus componentes eletrônicos estão montados, você pode precisar alterá-los. Se você montar o sensor de posição com o chip voltado para o topo do chapéu e a seta ao lado do X impressa na placa apontada para a frente do chapéu, você verá o seguinte:

• Pitch está acenando com a cabeça
• Rolar está inclinando sua cabeça, por exemplo, toque sua orelha em seu ombro
• Yaw é em qual direção. você está voltado para (Norte, Oeste, etc.).

Se sua placa estiver montada em uma orientação diferente, você precisará trocar Pitch / Roll / Yaw para que eles se comportem como você gostaria.

Para ajustar as configurações de rolo, você pode alterar os seguintes #define valores:

• ROLLOFFSET: com o seu chapéu estável e tão centrado quanto possível, se o Roll não for 0, mude pela diferença. Ou seja, se você está vendo Roll em -20 quando seu chapéu está centrado, faça este 20.
• ROLLMAX: o valor máximo a ser usado para medição de rolo. Mais fácil de encontrar usando o chapéu e movendo a orelha direita em direção ao ombro direito. Você precisará de um cabo USB longo para fazer isso ao usar o monitor serial.
• ROLLMIN: o valor mais baixo a ser usado para medição de Roll, para quando inclinar a cabeça para a esquerda

Da mesma forma, para Pitch:

• MAXPITCH - o valor máximo quando você está olhando para cima
• MINPITCH - o valor mínimo quando você está olhando para baixo
• PITCHCENTER - o valor do pitch quando você está olhando para a frente

Se você definir SERIALDEBUG como verdadeiro no início do arquivo, deverá ver os valores atuais para a saída de Roll / Pitch / Yaw para o monitor serial para ajudar a ajustar esses valores.

Outros parâmetros que você pode querer alterar

• MAX_LED_DELAY 35 - o mais lento que a partícula de LED pode se mover. Isso está em milissegundos. É o atraso de passar de um LED para o próximo na string.
• MIN_LED_DELAY 10 - o jejum que a partícula de LED pode se mover. Como acima, é em milissegundos.

Conclusão

Se você chegou até aqui, deve ter um chapéu LED divertido e totalmente funcional! Se você quiser fazer mais com ele, a próxima página contém algumas informações avançadas sobre como alterar as configurações e fazer suas próprias coisas. bem como alguma explicação do que o resto do meu código está fazendo.

Etapa 5: avançado e opcional: dentro do código

Detecção de impacto e rotação

A detecção de impacto / rotação é feita usando as funções de sensor de alto G do BNO055. Você pode ajustar a sensibilidade dele com as seguintes linhas em initBNO055 ():

• Linha # 316: BNO055_ACC_HG_DURATION - quanto tempo o evento deve durar
• Linha nº 317: BNO055_ACC_HG_THRESH - quão difícil deve ser o impacto
• Linha # 319: BNO055_GYR_HR_Z_SET - limite de velocidade de rotação
• Linha # 320: BNO055_GYR_DUR_Z - quanto tempo a rotação ainda tem que durar

Ambos os valores são binários de 8 bits, atualmente o impacto é definido como B11000000, que é 192 de 255.

Quando um impacto ou giro é detectado, o BNO055 define um valor que o código procura logo no início do Loop:

// Detecta quaisquer interrupções acionadas, ou seja, devido a alto G byte intStatus = readByte (BNO055_ADDRESS, BNO055_INT_STATUS); if (intStatus> 8) {impact (); } else if (intStatus> 0) {spin (); }

Procure a linha void impact () acima no código para alterar o comportamento no impacto ou void spin () para alterar o comportamento do spin.

Ajudantes

Criei uma função auxiliar simples (void setAllLeds ()) para definir rapidamente todos os LEDs para uma única cor. Pode-se usá-lo para desligá-los:

setAllLeds (CRGB:: Preto);

Ou você pode escolher qualquer cor reconhecida pela biblioteca FastLED:

setAllLeds (CRGB:: Vermelho);

Há também uma função fadeAllLeds () que escurece todos os LEDs em 25%.

A classe de partículas

Para simplificar muito a fiação, eu queria usar uma única string de LEDs, mas fazer com que se comportassem como várias strings. Como esta foi minha primeira tentativa, eu queria mantê-lo o mais simples possível, então eu trato uma corda como duas, com o (s) LED (s) do meio lá onde estaria a divisão. Como podemos ter um número par ou ímpar, precisamos levar isso em consideração. Começo com algumas variáveis globais:

/ * * Variável e contêineres para LEDs * / CRGB leds [NUM_LEDS]; estático sem sinal int curLedDelay = MAX_LED_DELAY; estático int centerLed = NUM_LEDS / 2; estático int maxLedPos = NUM_LEDS / 2; bool estático oddLeds = 0; partícula bool estáticaDir = 1; estático bool speedDir = 1; dirCount longo sem sinal; unsigned long hueCount;

E algum código em setup ():

if (NUM_LEDS% 2 == 1) {oddLeds = 1; maxLedPos = NUM_LEDS / 2; } else {oddLeds = 0; maxLedPos = NUM_LEDS / 2 - 1; }

Se tivermos números ímpares, queremos usar o ponto 1/2 como o meio, caso contrário, queremos o ponto 1/2 - 1. Isso é fácil de ver com 10 ou 11 LEDs:

• 11 LEDs: 11/2 com números inteiros devem ser avaliados em 5. e os computadores contam a partir de 0. Portanto, 0 - 4 é uma metade, 6 - 10 é a outra metade e 5 está entre eles. Tratamos # 5 neste caso como se fosse parte de ambos, ou seja, é # 1 para ambas as cadeias virtuais de LEDs
• 10 LEDs: 10/2 é 5. Mas como os computadores contam a partir de 0, precisamos remover um. Então temos 0 - 4 para uma metade e 5 - 9 para a outra. # 1 para a primeira string virtual será 4, e # 1 para a segunda string virtual será # 5.

Então, em nosso código de partículas, temos que fazer algumas contagens de nossa posição geral até as posições reais na string de LED:

if (oddLeds) {Pos1 = centerLed + currPos; Pos2 = centerLed - currPos; } else {Pos1 = centerLed + currPos; Pos2 = (centerLed -1) - currPos; }

O código também tem condições em que a partícula pode mudar de direção, então também temos que levar isso em consideração:

if (particleDir) {if ((currPos == NUM_LEDS / 2) && oddLeds) {currPos = 0; } else if ((currPos == NUM_LEDS / 2 - 1) && (! oddLeds)) {currPos = 0; } else {currPos ++; }} else {if ((currPos == 0) && oddLeds) {currPos = centerLed; } else if ((currPos == 0) && (! oddLeds)) {currPos = centerLed - 1; } else {currPos--; }}

Portanto, usamos a direção pretendida (particleDir), para calcular qual LED deve ser aceso em seguida, mas também temos que considerar se alcançamos a extremidade real da string de LED ou nosso ponto central, que também atua como uma extremidade para cada uma das strings virtuais.

Depois de descobrir tudo isso, acendemos a próxima luz conforme necessário:

if (particleDir) {if (oddLeds) {Pos1 = centerLed + currPos; Pos2 = centerLed - currPos; } else {Pos1 = centerLed + currPos; Pos2 = (centerLed -1) - currPos; }} else {if (oddLeds) {Pos1 = centerLed - currPos; Pos2 = centerLed + currPos; } else {Pos1 = centerLed - currPos; Pos2 = (centerLed -1) + currPos; }} leds [Pos1] = CHSV (currHue, 255, 255); leds [Pos2] = CHSV (currHue, 255, 255); FastLED.show ();}

Por que fazer disso uma aula? Do jeito que está, isso é bastante simples e não precisa realmente estar em uma aula. No entanto, tenho planos futuros para atualizar o código para permitir que mais de uma partícula ocorra ao mesmo tempo, e fazer com que algumas trabalhem ao contrário, enquanto outras estão avançando. Eu acho que existem algumas possibilidades realmente ótimas para a detecção de spin usando várias partículas.