Faça você mesmo Givi V56 para motocicleta Topbox Light Kit com sinais integrados: 4 etapas (com imagens)

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

Como motociclista, estou muito acostumada a ser tratada como se fosse invisível na estrada. Uma coisa que sempre adiciono às minhas bicicletas é um top box que normalmente tem uma luz integrada. Recentemente, atualizei para uma nova bicicleta e comprei a caixa Givi V56 Monokey, pois ela tinha muito espaço para itens. Esta caixa possui um spot para um kit de luz de fábrica que consiste em duas faixas de LEDs de cada lado. O problema é que esse kit custa cerca de US $ 70 e só freia. Existe um kit de reposição que provavelmente faz coisas semelhantes e pode ser um pouco mais fácil de instalar, mas seu preço sobe para US $ 150. Sendo uma pessoa engenhosa e procurando uma desculpa para experimentar as tiras de LED endereçáveis, decidi fazer um sistema integrado que não só tivesse luzes de freio, mas luzes de funcionamento (acesas sempre que em movimento), piscas e luzes de emergência. Só pra cacete, eu até adicionei uma sequência de inicialização…. porque eu poderia. Observe que isso deu muito trabalho, embora eu tivesse muitas coisas a descobrir. Apesar do trabalho, estou bastante feliz com o resultado. Esperançosamente, isso acaba sendo útil para outra pessoa.

A operação básica de como esse sistema funciona é que a unidade Arduino procura sinais nos pinos: luz de freio, luz de curva à esquerda e luz de curva à direita. Para ler o sinal de 12 volts da motocicleta, usei optoisoladores para converter o sinal de 12 V em um sinal de 5 V que o Arduino pudesse ler. O código então espera por um desses sinais e então envia os comandos para a faixa de LED usando a biblioteca FastLED. Esse é o básico, agora para entrar em detalhes.

Suprimentos

Essas são as coisas que eu usei porque na maioria das vezes eu já as tinha espalhadas. Obviamente, eles podem ser trocados conforme necessário:

1. Arduino - usei um nano para considerações de tamanho, mas você pode usar o que quiser, desde que tenha cinco pinos para usar.
2. Regulador de 5V - usei um L7805CV que era capaz de 1,5 amperes. Este projeto usará 0,72 amperes para os LEDs mais a energia para o nano, portanto, 1,5 funciona muito bem para este projeto.
3. Capacitores - você precisará de um de 0,33 uF e um de 0,1 uF para que o regulador de tensão funcione corretamente.
4. 3 optoisoladores - para fazer a conversão do sinal de 12V para 5V. Usei o tipo PC817X que tem apenas quatro pinos, que é tudo o que precisamos.
5. Resistores - você precisará de dois tipos, três de cada tipo. O primeiro precisa ser suficiente para reduzir a corrente através do LED IR do optoisolador. Você precisará de pelo menos 600 ohms, mas 700 seria uma ideia melhor para lidar com as variações de voltagem na motocicleta. O outro deve estar entre 10k e 20k para um sinal rápido do outro lado do optoisolador.
6. Placa protótipo - eu tinha alguns que eram pequenos o suficiente para caber dentro de uma pequena caixa de projeto com um pequeno corte.
7. Caixa do projeto - grande o suficiente para acomodar os componentes, mas pequena o suficiente para ser fácil de encaixar.
8. Fio - usei fio ethernet Cat 6 porque tinha muitos fios por aí. Ele tinha oito fios, todos codificados por cores, o que ajudava em todas as diferentes conexões e era um medidor grande o suficiente para lidar com os consumos de corrente.
9. Plugues - em qualquer lugar onde você quiser que o sistema seja facilmente removível. Usei um plugue à prova d'água para permitir que a caixa superior seja removida e para lidar com a chuva ou água que entrar em contato com ela. Eu também precisava de plugues menores para as tiras de LED, então não tive que fazer grandes furos.
10. Fechos de correr e montagens adesivas de fecho de correr para manter tudo no lugar.
11. Encolher o filme para organizar as conexões.

Etapa 1: Construindo o Circuito

Obviamente, se você estiver seguindo minha construção, não terá que passar pela quantidade de testes que fiz. A primeira coisa que fiz foi certificar-me de que meu código funcionava e que eu poderia obter um sinal adequado dos optoisoladores, bem como controlar adequadamente as tiras de LED. Demorei um pouco para descobrir a melhor forma de conectar os pinos de sinal aos isoladores, mas, por tentativa e erro, encontrei a orientação correta. Acabei de usar uma placa de protótipo padrão, pois estava construindo apenas uma e descobrir um padrão de rastreamento levaria mais tempo do que valeria a pena. A parte superior da placa de circuito parece ótima, mas a parte inferior parece um pouco bagunçada, mas pelo menos é funcional.

O projeto básico começa com a entrada de alimentação de 12 V de uma fonte chaveada (um fio que só fica ligado quando a motocicleta está ligada). Um diagrama de fiação pode realmente ajudar a encontrar esse fio. Isso é alimentado em um lado do regulador de tensão. Um capacitor de 0,33 uF conecta essa entrada ao terra no regulador de tensão, que então realimenta o solo da motocicleta. A saída do regulador de tensão terá um capacitor de 0,1uF ligado a ela ao aterramento. Esses capacitores ajudam a suavizar a tensão do regulador. Se você não consegue encontrá-los na foto da placa de circuito, eles estão embaixo do regulador de tensão. De lá, a linha 5V vai para o Vin no Arduino, para o pino de alimentação que alimentará as tiras de LED e para o lado da fonte do optoisolador que alimentará os pinos do Arduino fornecendo o sinal 5V necessário.

Quanto aos optoisoladores, existem dois lados: um com LED IR e outro com transistor com detector IR. Queremos usar o lado do LED IR para medir o sinal de 12V. Como o LED tem uma tensão direta de 1,2 V, precisamos de um resistor limitador de corrente em série. 12 V - 1,2 V = 10,8 V e para operar o LED a 18 mA (sempre gosto de operar a menos de 20 mA por motivos de vida), você precisará de um resistor de R = 10,8 V / 0,018 A = 600 ohm. As tensões nos veículos também tendem a ficar mais altas, potencialmente até 14 V, então é melhor planejar isso, que é cerca de 710 ohms, embora 700 seja mais do que razoável. A saída para o lado do LED então realimenta o aterramento. Para o lado de saída do optoisolador, a entrada usará o sinal de 5 V do regulador e a saída será conectada a outro resistor antes de ir para o aterramento. Este resistor só precisa ter cerca de 10k - 20k ohm, pelo menos é o que minha ficha técnica mostrou. Isso fornecerá uma medição de sinal rápida, pois não estamos lidando com um ambiente barulhento. A saída para o pino do Arduino sairá entre o resistor e a saída do optoisolador, de forma que, quando o sinal está desligado, o pino está baixo e quando o sinal está no pino alto.

As fitas de LED possuem três fios associados a elas: alimentação, aterramento e dados. A alimentação precisa ser 5V. Este projeto usa 12 LEDs no total (embora eu tenha mais LEDS nas tiras, mas estou usando apenas um em cada três LEDs) e cada um leva 60mA quando a luz branca é usada com brilho total. Isso dá um total de 720 mA. Estamos bem dentro da potência de saída do regulador de tensão, então estamos bem. Apenas certifique-se de que o fio seja de bitola grande o suficiente para suportar a energia, usei fio ethernet Cat 6 de bitola 24. Fio Ethernet era algo que eu tinha por perto e tinha 8 fios codificados por cores, então funcionou bem para este projeto. Os únicos fios que precisam ir para a caixa superior em si são a alimentação e o aterramento (que são divididos entre as tiras) e duas linhas de dados (uma para cada tira).

O resto da fiação está conectada aos pinos do arduino e alimentando-o com energia. Os pinos usados para este projeto foram os seguintes:

1. Vin - conectado a 5V
2. Gnd - conectado ao solo
3. Pino 2 - conectado à linha de dados da faixa esquerda
4. Pin3 - conectado à linha de dados da faixa direita
5. Pino 4 - conectado ao sinal de freio do optoisolador
6. Pino 5 - conectado ao sinal de virar à esquerda do optoisolador
7. Pino 6 - conectado ao sinal de mudança de direção à direita do optoisolador

Etapa 2: Fiação e instalação

Uma vez que o circuito é construído, chega a hora de realmente conectá-lo ao lugar. Usando o esquema de fiação de sua bicicleta, você precisará localizar o seguinte:

• Fonte de alimentação comutada
• Chão
• Sinal de freio
• Sinal de entrada para virar à esquerda
• Sinal de entrada à direita

Para o meu, havia um único plugue que tinha tudo isso, então eu apenas o usei. Com tempo suficiente, eu poderia ter encontrado o mesmo tipo de plugue e apenas fazer um módulo de plugue, mas não o fiz, então apenas removi o isolamento em alguns lugares e soldou o novo fio nele. Usei plugues nessas conexões emendadas para poder remover o resto, caso seja necessário no futuro. De lá, coloquei o Arduino, que agora está em uma caixa de projeto lacrada, sob o assento onde o coloquei. O cabo de saída então passa ao longo da estrutura do rack até um plugue à prova d'água e, em seguida, entra na caixa e passa ao longo da parte traseira até a tampa, onde se divide para cada lado. Os fios passam pelo interior da tampa até o ponto onde estão as conexões para os LEDs. O arame é colocado no lugar por meio de laços zip presos a montagens de laço zip de grau externo com um adesivo atrás. Você pode encontrá-los na seção de instalação de cabos em uma loja de materiais de construção

Usei dois plugues mini JST nas tiras de LED porque precisava de um plugue pequeno o suficiente para passar por um orifício de diâmetro mínimo e porque queria ter certeza de que havia fio suficiente para atender aos requisitos atuais. Novamente, pode ter sido um exagero e eu não tinha nenhum plugue pequeno com três fios à mão. O orifício na caixa para a passagem dos fios de luz foi selado para impedir a entrada de água. Quanto ao posicionamento das tiras de LED, porque há um pequeno descompasso no espaçamento (havia cerca de 1 - 1,5 mm de diferença no espaçamento entre os orifícios do refletor e os LEDs), posicionei-as de forma que dividissem a diferença entre o LED e o buraco, tanto quanto possível. Em seguida, usei cola quente para fixá-los no lugar e selante para selar totalmente a área. As próprias tiras de LED são à prova d'água, então não há problema se molharem. Embora pareça muito para instalar, isso torna o sistema mais fácil de remover no futuro ou peças de reposição são necessárias porque isso pode acontecer.

Etapa 3: O Código

Meu código-fonte deve estar no início deste Instructable. Sempre comento meu código pesadamente para que seja mais fácil de entender mais tarde. Isenção de responsabilidade: não sou um escritor de código profissional. O código foi escrito em um método que era mais fácil de começar primeiro e algumas melhorias foram feitas, mas eu sei que poderia ser mais refinado. Também estou usando uma grande quantidade da função delay () para cronometrar, o que não é tão ideal. No entanto, os sinais que a unidade está recebendo não são sinais rápidos em comparação, então eu ainda me senti justificado em mantê-los usando algo como millis (). Eu também sou um pai e marido muito ocupado, então gastar tempo para melhorar algo que no final das contas não mudará a função não está no topo da lista.

Para este projeto, apenas uma biblioteca é necessária, que é a biblioteca FastLED. Este contém todo o código para controlar as faixas de LED do tipo WS2811 / WS2812B. A partir daí, abordarei as funções básicas que serão usadas.

A primeira, além das definições padrão, é declarar suas duas tiras. Você usará o seguinte código para cada tira:

FastLED.addLeds (leds [0], NUM_LEDS);

Esta linha de código configura o Pino 2 e define esta faixa como faixa 0 com o número de LEDs definidos pela constante NUM_LEDS, que no meu caso é definida como 16. Para definir a segunda faixa, o 2 se tornará 3 (para o pino 3) e a tira será identificada como tira 1.

A próxima linha que será importante é a definição da cor.

leds [0] [1] = Cor_alta CRGB (r, g, b);

Esta linha de código é usada em diferentes aparências (a maioria das minhas usa uma constante). Basicamente, este código envia um valor para cada um dos canais de LED (vermelho, verde, azul) que define cada brilho. O valor do brilho pode ser definido por um número de 0 a 255. Alterando o nível de brilho de cada canal, você pode definir cores diferentes. Para este projeto, eu quero uma cor branca para manter a luz o mais brilhante possível. Portanto, a única mudança que faço é definir o nível de brilho igual em todos os três canais.

O próximo conjunto de códigos é usado para iluminar individualmente cada luz. Observe que para cada faixa, cada LED tem um endereço que começa em 0 para o mais próximo da conexão da linha de dados até o número mais alto de LED que você tem menos 1. Exemplo, são 16 faixas de LED, então o mais alto é 16 - 1 = 15. A razão para isso é porque o primeiro LED é rotulado como 0.

for (int i = NUM_LEDS-1; i> -1; i = i - 3) {// Isso mudará a luz para cada terceiro LED que vai do último para o primeiro. leds [0] = Color_low; // Defina a cor do LED da tira 0 para a cor escolhida. leds [1] = Color_low; // Defina a cor do LED da tira 1 para a cor escolhida. FastLED.show (); // Mostra as cores definidas. leds [0] = CRGB:: Preto; // Desativa a cor definida na preparação para a próxima cor. leds [1] = CRGB:: Preto; atraso (150); } FastLED.show (); // Mostra as cores definidas.

A forma como este código funciona é que uma variável (i) é usada dentro de um loop for como o endereço do LED que é então referenciado ao número total de LEDs (NUM_LEDS). A razão para isso é que eu quero que as luzes comecem no final da faixa, e não no início. A configuração é enviada para ambas as faixas (leds [0] e leds [1]) e, em seguida, um comando para mostrar a alteração é emitido. Depois disso, esta luz é desligada (CRGB:: Black) e a próxima luz acende. A referência Black é uma cor específica na biblioteca FastLED, então não preciso emitir 0, 0, 0 para cada canal, embora eles façam a mesma coisa. O loop For avança 3 LEDs por vez (i = i-3), pois estou usando apenas LEDs alternados. No final deste loop, a sequência de luzes irá de um LED para o próximo com apenas um aceso por faixa, uma espécie de efeito Knight Rider. Se você quiser manter cada luz acesa para que a barra cresça, basta remover as linhas que desligam os LEDs, o que acontece no próximo conjunto de código do programa.

for (int i = 0; i <dim; i ++) {// Desvanece rapidamente as luzes para o nível de luz em execução. rt = rt + 1; gt = gt + 1; bt = bt + 1; for (int i = 9; i <NUM_LEDS; i = i +3) {// Isso acenderá as três últimas luzes da luz de posição. leds [0] = CRGB (rt, gt, bt); // Defina a cor do LED da tira 0 para a cor escolhida. leds [1] = CRGB (rt, gt, bt); // Defina a cor do LED da tira 1 para a cor escolhida. } FastLED.show (); atraso (3); }

O último exemplo de código que uso para os LEDs é um loop de fade. Aqui, eu uso slots temporários para o brilho de cada canal (rt, gt, bt) e aumento-os em 1 com um atraso entre cada exibição para obter a aparência que desejo. Observe também que este código está apenas mudando os últimos três LEDs, pois isso está diminuindo nas luzes de funcionamento, então i começa em 9 em vez de 0.

O resto do código do LED são iterações deles. Todo o resto se concentra em procurar um sinal nos três fios diferentes. A área Loop () do código procura luzes de freio, que piscarão uma vez antes de permanecer acesas (isso pode ser ajustado se desejado) ou procurar por indicadores de direção. Para este código, como não posso presumir que as luzes de mudança de direção à esquerda e à direita acendam exatamente ao mesmo tempo para perigos, faço o código procurar por qualquer uma delas primeiro e, em seguida, após um pequeno atraso, verifico se ambas estão acesas, indicando as luzes de emergência estão acesas. A única parte complicada que tive foram os sinais de mudança, porque a luz vai se apagar por algum tempo, então como posso saber a diferença entre o sinal ainda ligado, mas no período desligado e um sinal cancelado? O que eu inventei foi a implementação de um loop de atraso que é definido para continuar por mais tempo do que o atraso entre os flashes de sinal. Se a seta ainda estiver ligada, o loop de sinal continuará. Se o sinal não voltar quando o atraso terminar, ele voltará para o início do loop (). Para ajustar a duração do atraso, altere o número para a lembrança de lightDelay constante para cada 1 em lightDelay, o atraso muda em 100 ms.

while (digitalRead (leftTurn) == LOW) {for (int i = 0; i <lightDelay; i ++) {leftTurnCheck (); if (digitalRead (leftTurn) == HIGH) {leftTurnLight (); } atraso (100); } for (int i = 0; i <NUM_LEDS; i = i +3) {// Isso mudará a luz para cada terceiro LED que vai do último para o primeiro. leds [0] = CRGB (0, 0, 0); // Defina a cor do LED da tira 0 para a cor escolhida. } for (int i = 9; i <NUM_LEDS; i = i +3) {// Isso configurará as luzes de corrida que usam apenas as três últimas. leds [0] = Cor_low; // Defina a cor do LED da tira 0 para a cor escolhida. } FastLED.show (); // Configurações de saída return; // Uma vez que o sinal de mudança não está mais ligado, volte para o loop. }

Esperançosamente, o resto do código é autoexplicativo. É apenas um conjunto repetido de verificação e ação de acordo com os sinais.

Etapa 4: Resultados

A parte incrível é que esse sistema funcionou na primeira vez que o conectei à moto. Agora, para ser justo, eu testei intensamente na bancada antes disso, mas ainda esperava ter um problema ou um ajuste. Acontece que não precisei fazer nenhum ajuste no código, bem como nas conexões. Como você pode ver no vídeo, o sistema passa pela sequência de inicialização (que você não precisa ter) e, em seguida, assume o padrão em luzes de funcionamento. Depois disso, ele procura os freios, caso em que acenderá todos os LEDs com brilho total e os piscará uma vez antes de permanecer ligado até que os freios sejam liberados. Quando um sinal de mudança de direção é usado, eu fiz um efeito de rolagem para o lado em que a mudança de direção é indicada e o outro lado será as luzes de trânsito ou de freio, se estiverem ligadas. Luzes de perigo piscarão em sincronia com as outras luzes.

Espero que com essas luzes adicionais eu seja mais visível para outras pessoas. No mínimo, é uma boa adição para fazer minha caixa se destacar um pouco mais do que as outras, enquanto fornece utilidade. Espero que este projeto seja útil para outra pessoa também, mesmo que ela não esteja trabalhando com a iluminação da caixa superior de uma motocicleta. Obrigado!