Muitos entusiastas de automóveis, para melhorar a aparência de seus carros, ajustam sua “Andorinha” com luzes LED. Uma das opções de ajuste é um pisca-pisca em movimento, que chama a atenção dos demais usuários da estrada. O artigo fornece instruções para instalar e configurar piscas com luzes de circulação.

[Esconder]

Instruções de montagem

As lâmpadas LED são elementos semicondutores que brilham quando expostos à corrente elétrica. O principal elemento neles é o silício. Dependendo das impurezas utilizadas, a cor das lâmpadas muda.

Galeria de fotos “Possíveis opções para indicadores de direção dinâmicos”

Ferramentas e materiais

Para fazer um pisca-pisca com suas próprias mãos, você precisará das seguintes ferramentas:

• ferro de soldar;
• cortadores laterais ou alicates;
• ferro de solda e material de solda;
• testador.

Você precisa preparar um laminado de fibra de vidro a partir de consumíveis. É necessário para a fabricação de uma placa de circuito impresso na qual será colocado o elemento semicondutor. Os LEDs necessários são selecionados. Dependendo das características dos LEDs e dos valores de corrente e tensão da rede de bordo, são calculadas as características dos resistores de proteção. Usando cálculos, os demais componentes da rede são selecionados (o autor do vídeo é Evgeny Zadvornov).

Sequência de trabalho

Antes de fazer sinais de mudança de direção, você precisa escolher um esquema adequado.

Em seguida, com base no diagrama, faça uma placa de circuito impresso e aplique marcações nela para colocar futuros elementos.

A montagem consiste em uma sequência de ações:

1. Primeiro, você deve desligar o carro desconectando o terminal negativo da bateria.
2. Em seguida, você precisa remover os piscas antigos e desmontá-los cuidadosamente.
3. As lâmpadas antigas devem ser desparafusadas.
4. As juntas devem ser limpas de cola, desengorduradas, lavadas e deixadas secar.
5. No lugar de cada elemento antigo, um novo pisca-pisca é instalado.
6. A seguir, a montagem e instalação das luzes são feitas na ordem inversa.
7. Após a instalação, os fios estão conectados.

Na próxima etapa, uma fonte de energia estabilizada adicional é conectada à rede. Sua entrada recebe energia do relé intermediário e a saída é conectada a um diodo. É melhor colocá-lo no painel de instrumentos.

Ao conectar LEDs, você deve garantir que o ânodo esteja conectado ao positivo da fonte de alimentação e o cátodo ao negativo. Se a conexão não for feita corretamente, os elementos semicondutores não acenderão e poderão até queimar.

Recursos de instalação e configuração de indicadores de direção em movimento

Você pode instalar piscas dinâmicos em vez de LEDs convencionais. Para isso, a placa com LEDs e resistores limitadores de corrente é removida e desmontada. No repetidor, você precisa arrancar o vidro do corpo. Então você deve cortar cuidadosamente o refletor e removê-lo.

No lugar do refletor remoto, é instalada uma placa SMD 5730, na qual estão localizados LEDs amarelos. Como o repetidor tem formato curvo, a placa deverá ser delaminada e um pouco dobrada. Você precisa cortar a peça com o conector da placa antiga e soldá-la para conectar o controlador. Em seguida, todos os componentes são devolvidos aos seus lugares.

Para ajustar o tempo das luzes LED em funcionamento, um interruptor é soldado ao microcontrolador. Quando uma velocidade adequada é encontrada, os jumpers são soldados no lugar da chave. Ao conectar dois pinos ao terra, o tempo mínimo entre as piscadas do LED será de 20 ms. Quando os contatos estiverem fechados, esse tempo será de 30 ms.

Questão de preço

Você pode fazer um sinal de mudança de direção com luzes diurnas. Seu custo é de 600 rublos. Neste caso, você pode usar LEDs RGB de “pixel” como fontes de luz no valor de 7 peças para cada pisca em funcionamento. O custo de um elemento é de 19 rublos. Para controlar os LEDs, você precisa adquirir um Arduino UNO no valor de 250 rublos. Assim, o custo total será de 1.060 rublos.

Todos aqueles que viram um carro mais ou menos moderno não pela segunda vez, e mesmo que se tratasse de dirigir, há muito notaram para si um dos opções úteis... As pessoas chamam isso de sinal de mudança de direção preguiçoso ou educado sinal de mudança de direção. Toda a sua essência se resume ao fato de que ao virar à direita ou à esquerda, o motorista toca apenas uma vez na alavanca do pisca, sem fixá-la. Ou seja, ele simplesmente faz os circuitos dos piscas funcionarem, mas não liga essa mesma chave. Com isso, após a alavanca ser liberada, os indicadores de direção são acionados mais 3 a 4 vezes, e neste momento o motorista já pode cuidar do seu “negócio”, ou seja, dedicar-se totalmente à estrada. A opção é muito útil quando você precisa mudar de faixa. Afinal, quando a alavanca do pisca estiver totalmente ligada, o desligamento automático não ocorrerá, devido ao insignificante ângulo de rotação do volante, o que significa que você terá que cutucar para frente e para trás com o próprio indicador ou apoiá-lo constantemente com sua mão prestes a ligar para imitar o funcionamento do pisca-pisca. E se existe essa opção, então toquei levemente na alavanca e esqueci. De uma forma geral, pensamos que a essência do trabalho foi totalmente revelada, mas agora vale a pena mencionar a possibilidade de implementar tal opção na sua máquina.

Para quais circuitos elétricos um sinal de mudança de direção educado no Arduino é adequado?

Antes de entrar em todos os problemas sérios sobre a produção de um pisca-pisca educado, você precisa entender para quais diagramas de conexão elétrica ele será adequado, sem modificar o circuito elétrico do carro.
Aqui nos são apresentadas duas opções principais que diferem em princípio. A primeira é quando os piscas são ligados quando estão conectados como uma carga. Ou seja, o acendimento ocorre devido ao acionamento do circuito das lâmpadas dos piscas, no qual está localizada a própria alavanca dos piscas, é esta que fecha o circuito, após o que ocorre o acionamento. Neste caso, não será possível utilizar a nossa opção, pois quando a alavanca abre o circuito com as lâmpadas, desabilitamos imediatamente a possibilidade de indicação luminosa, mesmo que chegue um sinal na própria alavanca, ela simplesmente não irá nenhum avançar.
A segunda opção é a nossa, quando existem sinais de controle e sinais de potência de saída. Neste caso, em vez do relé padrão, você pode instalar exatamente o circuito que gostaríamos de chamar a sua atenção.

Módulo de potência de relé que pode ser adquirido na Internet para controlar a carga de energia

Esboço e circuito de um sinal de mudança preguiçoso (educado) no Arduino

Portanto, pode-se argumentar sobre o uso do Arduino como unidade principal para piscas preguiçosos, já que essa também não é uma solução ideal, o que tem suas desvantagens. Por exemplo, será necessário ter potência constante após ligar a ignição; para garantir velocidade, será necessário conectar circuitos de potência; Ao mesmo tempo, o próprio chicote de componentes extras de rádio é basicamente inútil aqui, porque neste caso você pode simplesmente programar um microcontrolador e usá-lo apenas. Mas esse ponto negativo também é um ponto positivo, porque qualquer pessoa que tenha um pode programar o Arduino, e para microcontroladores você também precisará de um programador.
Escrever um programa será uma das tarefas mais difíceis. Aqui um iniciante terá que gastar mais de uma hora do seu tempo livre estudando o trabalho dos algoritmos, mas felizmente existe a Internet e existe nós. Então aqui está o esboço.

Int switchPinR = 8; int switchPinL = 7; int ledPinR = 11; int ledPinL = 12; booleano ledOn = falso; int i=0; intz=0; void setup() ( // coloque seu código de configuração aqui, para executar uma vez: pinMode(switchPinR, INPUT); pinMode(switchPinL, INPUT); pinMode(ledPinR, OUTPUT); pinMode(ledPinL, OUTPUT); Serial.begin(9600 ); ) void loop() ( // coloque seu código principal aqui, para executar repetidamente: //2 label: if (digitalRead(switchPinR) == HIGH && digitalRead(switchPinL) == HIGH) ( digitalWrite(ledPinR, HIGH) ;digitalWrite(ledPinL, ALTO);<7) { ledOn = !ledOn; digitalWrite(ledPinR, ledOn); digitalWrite(ledPinL, ledOn); delay(400); i++; z++; if (digitalRead(switchPinL) == LOW && digitalRead(switchPinR) == LOW && z>=7) ( break; ) ) ) else ( digitalWrite(ledPinR, LOW); digitalWrite(ledPinL, LOW); z=0; ) //ciclando o sinal de emergência if (digitalRead(switchPinR) == HIGH && digitalRead(switchPinL) == ALTO) (vá para o rótulo;) //Sinalizador de direção à direita. if (digitalRead(switchPinR) == HIGH) ( digitalWrite(ledPinR, HIGH); i=0; while (i<7) { ledOn = !ledOn; digitalWrite(ledPinR, ledOn); delay(400); i++; z++; if (digitalRead(switchPinR) == LOW && z>=7) ( break; ) ) ) else ( digitalWrite(ledPinR, LOW); z=0; ) //Sinalizador de direção à esquerda. if (digitalRead(switchPinL) == HIGH) ( digitalWrite(ledPinL, HIGH); i=0; while (i<7) { ledOn = !ledOn; digitalWrite(ledPinL, ledOn); delay(400); i++; z++; if (digitalRead(switchPinL) == LOW && z>=7) ( break; ) ) ) else ( digitalWrite(ledPinL, LOW); z=0; ) ) )

Para resumir brevemente, o esboço possui 2 entradas e 2 saídas. Neste caso, quando um sinal positivo, ou seja, de alto nível, é introduzido na entrada (8,7), recebemos um certo número de piscadas (z ou i) na saída correspondente (11,12). Resumindo, algo assim. Ou seja, se você quiser alterar algo no sketch em relação ao número de piscadas e saídas de entrada, então preste atenção nessas variáveis. Se você precisar alterar a duração das piscadas, sua atenção deve estar focada na função de atraso.
Outra característica do programa é uma saída de alarme um tanto incomum. Primeiro, os indicadores esquerdo e direito são processados ​​e, em seguida, as luzes de emergência acendem. Isso se deve ao fato de que ele só poderá ligar se a entrada estiver alta ao mesmo tempo nas entradas 8 e 7. E essa condição só será atendida no segundo ciclo, pois pressionar dois botões ao mesmo tempo é fisicamente impossível. A velocidade do microcontrolador permitirá que você leia mais rapidamente a saída alta de um botão e decida que esta é, afinal, uma condição para acionar o pisca-pisca, e não um alarme. Embora você não deva se preocupar com isso, a menos que dizer obrigado na estrada seja problemático.

Recursos de conexão de um pisca-pisca preguiçoso (educado) em um carro usando Arduino

Não se deve utilizar o pino 13 como saída, pois toda vez que ligar e desligar a alimentação, os indicadores que serão conectados a esta saída poderão piscar.
Ao passar de sinais de controle para sinais de potência, use blocos apropriados adquiridos na Internet ou montados por você. Já falamos sobre esses blocos - módulos.
Ao receber o sinal 1 de uma tensão de 12 volts, coloque um resistor de 10 Kom na frente da entrada.

Essas são todas as instruções para fazer um sinal de mudança de direção preguiçoso para um carro usando um microcontrolador Arduino, e agora sobre a mesma coisa no vídeo...

Eu disse “Gop” no ano passado - é hora de pular :)
Ou melhor, faça a revisão prometida dos piscas em funcionamento.
Encomendei 1 metro de fita preta WS2812B (144 LEDs) em tubo de silicone, ao fazer o pedido escolhi “Preta 1m 144led IP67” (talvez alguém goste da cor branca do substrato, existe essa escolha).

Uma palavra de cautela

Recebi uma fita soldada com duas peças de meio metro. A desvantagem disso é um ponto de solda vulnerável (os contatos podem quebrar com o tempo) e um maior espaço entre os LEDs.
Antes de comprar consulte o vendedor sobre esse ponto.

Fios de contato foram soldados à fita em ambos os lados para conectar diversas peças em série, pois Eu não precisava disso, então dessoldei os fios de um lado, selei tudo com selante neutro e enrolei um pouco mais de fita isolante preta.

Fixado no vidro com fita adesiva transparente dupla-face, por exemplo.

Detalhes de instalação

Desengordurei as superfícies, primeiro colei fita adesiva no tubo (vou chamar assim, embora a seção transversal seja retangular), cortei o excesso saliente da fita mais larga, empurrei as bordas do tubo nas fendas entre o teto e as partes superiores dos painéis decorativos dos pilares traseiros (os fios de contato com o conector estavam escondidos atrás de um painel), centralizou-o e começou a pressioná-lo contra o vidro, puxando lentamente a camada protetora da fita.
Infelizmente, não há vídeo - não havia mãos livres para filmar e o carro de cada pessoa é diferente.
Se algo não estiver claro, pergunte nos comentários.
O teste no calor do verão foi bem-sucedido - nada saiu ou flutuou.
O único aspecto negativo é que o ângulo do vidro é suave, os LEDs brilham mais para cima. Em um dia ensolarado é difícil ver, mas como são sinais duplicados,

Agora vamos passar para o recheio eletrônico.
Eu usei, mas descobri há pouco tempo

Por aproximadamente o mesmo custo, obtemos mais guloseimas

O sketch funcionará sem nenhuma modificação especial no Wemos ao programar no Arduino IDE, e se você implementar um pequeno servidor web, então quando conectado a ele via Wi-Fi, você pode alterar os valores de variáveis ​​​​como o tempo de atraso entre flashes, a quantidade de desaceleração durante a frenagem de emergência, etc.
Aqui futuramente, caso alguém tenha interesse em implementar um projeto no ESP8266, posso postar um exemplo de alteração das configurações via interface web, salvando-as na EEPROM e depois lendo-as.
O servidor web pode ser iniciado, por exemplo, ligando o pisca-pisca e pressionando o pedal do freio quando a ignição é ligada (no procedimento de configuração, pesquise o status das entradas correspondentes).

Para implementar um modo intermitente durante frenagens bruscas, comprei
O esboço monitora o nível de desaceleração ao pressionar o pedal do freio; se exceder 0,5G (desaceleração brusca, mas sem freios barulhentos), um modo intermitente é ativado por alguns segundos para atrair atenção adicional.
Os sinais de controle para as entradas do Arduino do “mais” de paradas, sinais de giro e reversão são fornecidos através de isolamento galvânico - optoacopladores com resistores limitadores de corrente, que em última análise formam o nível BAIXO nas entradas do Arduino (constantemente puxados para positivo através de resistores de 10 kOhm) .
Fonte de alimentação - 5 volts através de um conversor abaixador DC-DC.
Tudo é dobrado em um sanduíche e embalado em uma caixa adequada, na qual o sentido de instalação está marcado com uma seta para a correta orientação do sensor de gravidade

Diagrama e foto

O valor nominal dos resistores pull-up (para positivo) é padrão - 10 kOhm, limitando a corrente dos resistores do optoacoplador - 1 kOhm. Retirei os optoacopladores de placas antigas, dois eram PC123, dois eram PC817.


Na primeira foto você pode ver dois terminais adicionais que fiz para os piscas; Como no meu carro, quando a alavanca da coluna de direção é acionada, ocorre um curto-circuito com o terra, conectei os fios ao bloco da alavanca e às entradas do Arduino. Se a alavanca da coluna de direção mudar o sinal positivo ou você receber o sinal do “+” das lâmpadas dos piscas esquerdo/direito, conecte-as através do isolamento galvânico.

Bem, agora o esboço em si (Arduino IDE)

#incluir #incluir //alguns comentários gerais // Desliguei um dos LEDs mais externos, porque... refletiram nos painéis decorativos das estantes //visíveis no exemplo deste ciclo for (int i=1; i<143; i++) //если отключать не нужно, заменяем на for (int i=0; i<144; i++) //задний ход и аварийка у меня не используются, т.к. в первом случае яркость никакая, во втором надо подключать входы к лампам поворотников //поворотники и стоп-сигнал одновременно не включаются, чтобы это реализовать, нужно переписывать соответствующий код скетча (делить ленту на три секции, подбирать тайминги миганий, менять диапазон переменных циклов). //Дерзайте - все в ваших руках // Пин для подключения управляющего сигнала светодной ленты const int PinLS = 2; //Пины для подключения датчиков //если более удобно будет подключать контакты в другом порядке - просто поменяйте значения переменных const int buttonPinL = 3; const int buttonPinR = 4; const int buttonPinS = 6; const int buttonPinD = 5; //начальные статусы входов (подтянуты к плюсу) int buttonStateS = HIGH; int buttonStateD = HIGH; int buttonStateL = HIGH; int buttonStateR = HIGH; // пауза pause_pov1 (в миллисекундах) нужна, чтобы синхронизировать циклы "пробегания" полоски и включения лампочки поворотника // такое может быть, если используется меньше половины светодиодов // в моем случае паузы нет (pause_pov1 = 0) int pause_pov1 = 1; // этой паузой регулируем длительность состояния, когда все светодиоды выключены //я определял опытным путем - включал поворотник, засекал по отдельности время ста мыргов лампочкой и ста беганий полоски, разницу делил на 100, на полученное время увеличивал или уменьшал значение переменной (в зависимости от того, отставали или убегали вперед лампочки) int pause_pov2 = 62; // переменная для получения значения ускорения int ix; Adafruit_NeoPixel strip = Adafruit_NeoPixel(144, PinLS, NEO_GRB + NEO_KHZ800); Adafruit_ADXL345_Unified accel = Adafruit_ADXL345_Unified(12345); void setup() { pinMode(buttonPinS, INPUT); pinMode(buttonPinD, INPUT); pinMode(buttonPinL, INPUT); pinMode(buttonPinR, INPUT); strip.begin(); // гасим ленту for (int i=0; i<144; i++) strip.setPixelColor(i, strip.Color(0,0,0)); strip.show(); accel.begin(); // ограничиваем измеряемый диапазон четырьмя G (этого хватит с большим запасом) accel.setRange(ADXL345_RANGE_4_G); accel.setDataRate(ADXL345_DATARATE_100_HZ); } void loop() { // СТОПЫ: если включены - высший приоритет //Чтобы сделать меняющуюся по ширине полоску в зависимости от интенсивности торможения //(уточнение - никакой светомузыки, ширина полосы после нажатия на тормоз не меняется!) //от плавного торможения до тапки в пол. //Добавляем еще одну переменную, например, ix2, //присваиваем ей значение ix с коэффициентом умножения, //заодно инвертируем и округляем до целого //ix = event.acceleration.x; //ix2 = -round(ix*10); //ограничиваем для плавного торможения в пробках //(чтобы не менялась при каждом продвижении на 5 метров) //if (ix2<10) ix2 = 0; //и для резкого торможения. //Реальный диапазон изменения переменной ix - от 0 до -5 //для максимальной ширины полосы при G равном или большем 0.5 //if (ix2 >50)ix2 = 50; //então altere os ciclos no bloco STOP para (int i=1; i<143; i++) на for (int i=51-ix2; i<93+ix2; i++) //Получаем минимальную ширину полоски ~30 см (для стояния в пробке) и максимальную для резкого торможения //конец комментария buttonStateS = digitalRead(buttonPinS); if (buttonStateS == LOW) { sensors_event_t event; accel.getEvent(&event); ix = event.acceleration.x; // проверка резкого торможения - мигающий режим // значение 5 - это 0,5G, минус - торможение if (ix < -5) { for (int is=0; is<15; is++) { for (int i=1; i<143; i++) strip.setPixelColor(i, strip.Color(240,0,0)); strip.show(); delay(10 + is*10); for (int i=1; i<143; i++) strip.setPixelColor(i, strip.Color(0,0,0)); strip.show(); delay(10 + is*3); buttonStateS = digitalRead(buttonPinS); if (buttonStateS == HIGH) return; } } // помигали - и хватит, включаем постоянный режим, если педаль тормоза еще нажата // или если не было резкого торможения и предыдущее условие не сработало if (buttonStateS == LOW) { for (int i=1; i<143; i++) strip.setPixelColor(i, strip.Color(200,0,0)); strip.show(); while(buttonStateS == LOW){ buttonStateS = digitalRead(buttonPinS); delay(50); } // плавно гасим for (int is=0; is<20; is++) { for (int i=1; i<143; i++) strip.setPixelColor(i, strip.Color(190 - is*10,0,0)); strip.show(); delay(10); } // СТОПЫ конец } } else // если СТОПЫ выключены { // ЗАДНИЙ ХОД: если включен - средний приоритет buttonStateD = digitalRead(buttonPinD); if (buttonStateD == LOW) { for (int i=1; i<37; i++) strip.setPixelColor(i, strip.Color(63,63,63)); for (int i=107; i<143; i++) strip.setPixelColor(i, strip.Color(63,63,63)); strip.show(); while(buttonStateD == LOW){ buttonStateD = digitalRead(buttonPinD); delay(50); } //плавно гасим for (int is=0; is<16; is++) { for (int i=1; i<37; i++) strip.setPixelColor(i, strip.Color(60 - is*4,60 - is*4,60 - is*4)); for (int i=107; i<143; i++) strip.setPixelColor(i, strip.Color(60 - is*4,60 - is*4,60 - is*4)); strip.show(); delay(10); } } buttonStateL = digitalRead(buttonPinL); buttonStateR = digitalRead(buttonPinR); // если включена аварийка if (buttonStateL == LOW && buttonStateR == LOW) { for (int il=0; il<71; il++) { strip.setPixelColor(71-il, strip.Color(63,31,0)); strip.setPixelColor(il+72, strip.Color(63,31,0)); strip.show(); delay(pause_pov1); } for (int il=0; il<71; il++) { strip.setPixelColor(71-il, strip.Color(0,0,0)); strip.setPixelColor(il+72, strip.Color(0,0,0)); strip.show(); delay(pause_pov1); } delay(pause_pov2); } // если включен ЛЕВЫЙ ПОВОРОТНИК if (buttonStateL == LOW && buttonStateR == HIGH) { for (int il=0; il<71; il++) { strip.setPixelColor(il+72, strip.Color(220,120,0)); strip.show(); delay(pause_pov1); } for (int il=0; il<71; il++) { strip.setPixelColor(il+72, strip.Color(0,0,0)); strip.show(); delay(pause_pov1); } delay(pause_pov2); } // если включен ПРАВЫЙ ПОВОРОТНИК if (buttonStateL == HIGH && buttonStateR == LOW) { for (int il=0; il<71; il++) { strip.setPixelColor(71-il, strip.Color(220,120,0)); strip.show(); delay(pause_pov1); } for (int il=0; il<71; il++) { strip.setPixelColor(71-il, strip.Color(0,0,0)); strip.show(); delay(pause_pov1); } delay(pause_pov2); } //правый поворотник конец } //конец условия else Стоп // задержка для следующего опроса датчиков delay(10); }

Tentei comentar o máximo possível, mas se houver dúvidas tentarei adicionar comentários (por isso estou colocando no texto da resenha, e não como arquivo anexo). A propósito, isso também se aplica a outros pontos da revisão - também irei complementá-lo se houver dúvidas significativas nos comentários.

E por fim, uma demonstração do trabalho (para o vídeo usei um esboço com modo demo).

Atualizado. Fiz o esboço com o modo de demonstração especificamente para encaixar tudo em um pequeno vídeo.
A luz de freio pisca apenas durante frenagens bruscas (isso foi discutido acima durante frenagens lentas e em engarrafamentos, simplesmente acende, sem irritar os motoristas atrás);
A luminosidade à noite não é excessiva, pois Devido à inclinação do vidro, as luzes são direcionadas mais para cima do que para trás.
As luzes padrão funcionam normalmente, esta faixa as duplica.