Semnalizatoare dinamice - facem lumini de mers din trusa KIT. Clasă de master despre realizarea de semnale de direcție dinamice „de rulare” Diagrama de conectare Arduino pentru un semnal de viraj care funcționează

Acasă / Îngheață

Să luăm în considerare crearea unui semnal de viraj ca la un Audi, folosind exemplul unui far de la o mașină Renault Clio. Să facem semnale de viraj și DRL-uri într-un singur dispozitiv.

Ce veți avea nevoie pentru asta: bandă LED constând din LED-uri ws2812b Controler Arduino nano(poate fi folosit în orice alt factor de formă) Auto încărcător Pentru telefoane mobile cu iesire USB. Deoarece controlerul Arduino are nevoie de o tensiune de 5V, vom folosi acest încărcător ca convertor de tensiune de la 12V la 5V. Stabilizator de tensiune pentru 5V KR142EN5V (KREN5V) sau orice alt analog importat. 3 rezistențe de 10 kOhm ca rezistență de tragere.

Schema de conectare

Controlerul Arduino trebuie conectat la rețeaua mașinii printr-un convertor de 12V -> 5V, astfel încât tensiunea către circuit să provină de la punerea contactului. Trebuie să conectați firul pozitiv de la semnalizarea existentă la stabilizatorul de tensiune KREN5V. Acest articol discută despre conectarea și firmware-ul unui singur semnal de întoarcere pentru a face un al doilea semnal de întoarcere, trebuie să îl conectați pe cel de-al doilea în același mod; Banda LED la orice ieșire digitală gratuită a Arduino (de exemplu 7) și, de asemenea, adăugați cod pentru aceasta în firmware, conform exemplului nostru.

Firmware-ul controlerului

Pentru a lucra cu LED-uri pixeli veți avea nevoie de o bibliotecă . Îl puteți instala după cum urmează: Schiță -> Conectați biblioteca -> Gestionați bibliotecile. Apoi, introduceți numele bibliotecii Adafruit_NeoPixel.h în meniul de căutare și faceți clic pe butonul de instalare. După aceea, introduceți schița în program și înlocuiți numărul de LED-uri din cod (folosim 22 de diode):

#include // conectați biblioteca
Adafruit_NeoPixel strip = Adafruit_NeoPixel(22, 8, NEO_GRB + NEO_KHZ800);
int t,t1,t2,t3,t4,p2,p1 = 0;//variabila timp
void setup() (
pinMode(2, INPUT);
pinMode(3, INPUT);
pinMode(4, INPUT);
digitalWrite(2, LOW);
digitalWrite(3, LOW);
digitalWrite(4, LOW);

strip.begin();
strip.show();

}
void loop() (
if (digitalRead(2) == LOW) ( //Dacă semnalul de întoarcere este oprit
for(int i = 0; i< 23; i++) {
strip.setPixelColor(i, strip.Color(255,255,255)); // R=255, G=255, B=255 - culoarea albă a LED-ului, când este aprins aprindem luminile de mers
}
strip.show();
}

if ((digitalRead(2) == HIGH) & (t == 1)) ( // verifică dacă semnalul de direcție este pornit
for(int i = 0; i< 23; i++) {
strip.setPixelColor(i, strip.Color(0, 0, 0)); // stinge toate diodele
}
strip.show();
pentru(int k = 0; k< 3; k++){ // цикл до трех - сигнал «перестроения» , при кратковременном включении мигает 3 раза,

for(int i = 0; i< 23; i++){

if (digitalRead(2) == HIGH) (k = 0;) // dacă în timp ce semnalizatorul clipește, primim un alt semnal pozitiv, apoi resetați contorul astfel încât semnalizatorul să clipească încă de cel puțin 3 ori
strip.setPixelColor(i, strip.Color(255, 69, 0)); // R=255, G=69, B=0 - culoare LED

întârziere((t4)/22);
strip.show();

}
if (digitalRead(2) == HIGH) (t4=t4+20;) // dacă toate diodele sunt aprinse galben, dar semnalul de la releu încă vine, atunci creștem timpul de ardere
if (digitalRead(2) == LOW) (t4=t4-20;) // dacă toate diodele sunt aprinse galben, dar semnalul de la releu încă vine, atunci creștem timpul de ardere

for(int i = 0; i< 23; i++){

strip.setPixelColor(i, strip.Color(0, 0, 0)); // R=0, G=0, B=0 - culoare LED

întârziere((t3)/22);
strip.show();

}
dacă ((digitalRead(2) == LOW)) (t3=t3+20;)
dacă ((digitalRead(2) == HIGH)) (t3=t3-20;)
}

if ((digitalRead(2) == HIGH) & (t == 0)) ( // verifică dacă semnalul de direcție este pornit

t1 = milis(); //amintește-ți la ce oră ai pornit
for(int i = 0; i< 22; i++) {
strip.setPixelColor(i, strip.Color(255, 69, 0)); // când porniți semnalizatorul pentru prima dată, porniți toate diodele galbene
}
strip.show();
în timp ce (digitalRead(2) == HIGH) ()
t2 = milis(); // amintește-ți la ce oră s-a stins semnalizatorul
t4=t2-t1;

for(int i = 0; i< 22; i++) {
strip.setPixelColor(i, strip.Color(0, 0, 0)); // sting diodele când dispare semnalul de la releul de viraj
}
strip.show();
în timp ce (digitalRead(2) == LOW) (
dacă ((millis()-t2)>2000)(break;)
}
dacă ((millis()-t2)<2000) {
t3 = milis()-t2; // timp pentru care se sting semnalizatoarele
t = 1; // steag, știm că valoarea timpului a fost salvată.
}
}

if (digitalRead(4) == HIGH) ( //semnale speciale
pentru(int j = 0; j< 16; j++) {
for(int i = 0; i< 22; i++) {
strip.setPixelColor(i, strip.Color(255, 0, 0)); // R=255, G=0, B=0 - culoare LED
}
strip.show();
întârziere (20);
for(int i = 0; i< 22; i++){

}
strip.show();
întârziere (20);
}

pentru(int j = 0; j< 16; j++) {
for(int i = 0; i< 22; i++) {
strip.setPixelColor(i, strip.Color(0, 0, 255)); // R=0, G=0, B=255 - culoare LED
}
strip.show();
întârziere (20);
for(int i = 0; i< 22; i++){
strip.setPixelColor(i, strip.Color(0, 0, 0)); // R=0, G=0, B=0 - culoare LED
}
strip.show();
întârziere (20);
}
}

if (digitalRead(3) == HIGH) ( //strobe
pentru(int j = 0; j< 24; j++) {
for(int i = 0; i< 22; i++) {
strip.setPixelColor(i, strip.Color(255, 255, 255)); // R=255, G=255, B=255 - culoare LED
}
strip.show();

întârziere (15);
for(int i = 0; i< 22; i++){
strip.setPixelColor(i, strip.Color(0, 0, 0)); // R=0, G=0, B=0 - culoare LED
}
strip.show();
întârziere (15);
}
întârziere (500);

Faceți același lucru pentru codul pentru al doilea semnal de întoarcere.

Videoclip despre cum funcționează farul nostru

Am spus „Gop” anul trecut - este timpul să sară :)
Sau, mai degrabă, faceți revizuirea promisă a semnalelor de direcție.
Am comandat 1 metru de bandă neagră WS2812B (144 LED-uri) într-un tub de silicon, la comandă am ales „Black 1m 144led IP67” (poate că cineva îi va plăcea culoarea albă a substratului, există o astfel de alegere).

Un cuvânt de precauție

Am primit o bandă lipită din două bucăți de jumătate de metru. Dezavantajul este un punct de lipit vulnerabil (contactele se pot rupe în timp) și un decalaj crescut între LED-uri.
Înainte de a cumpăra, verificați cu vânzătorul despre acest punct.

Firele de contact au fost lipite de bandă pe ambele părți pentru a conecta mai multe piese în serie, deoarece Nu aveam nevoie de asta, așa că am dezlipit firele pe o parte, am sigilat totul cu un etanșant neutru și am înfășurat puțin mai multă bandă electrică neagră.



Atașat de sticlă folosind bandă adezivă transparentă, de exemplu.

Detalii de instalare

Am degresat suprafețele, mai întâi am lipit bandă adezivă pe tub (o voi numi așa, chiar dacă secțiunea transversală este dreptunghiulară), am tăiat excesul proeminent al benzii mai late, am împins marginile tubului în crăpăturile dintre tavanul și părțile superioare ale panourilor decorative ale stâlpilor din spate (firele de contact cu conectorul erau ascunse în spatele unui panou ), l-au centrat și au început să îl apese pe sticlă, trăgând încet stratul protector al benzii.
Din păcate, nu există niciun videoclip - nu existau mâini libere pentru filmare, iar mașina fiecăruia este diferită.
Dacă ceva nu este clar, întrebați în comentarii.
Testul în căldura verii a avut succes - nimic nu s-a desprins sau nu a plutit.
Singurul negativ este că unghiul sticlei este blând, LED-urile strălucesc mai mult în sus. Într-o zi însorită este greu de văzut, dar deoarece acestea sunt semnale duplicat,

Acum să trecem la umplutura electronică.
L-am folosit, dar l-am descoperit nu de mult

Pentru aproximativ același cost primim mai multe bunătăți

Schița va funcționa fără modificări speciale pe Wemos la programarea în IDE-ul Arduino, iar dacă implementați un server web mic, atunci când vă conectați la acesta prin Wi-Fi, puteți modifica valorile variabilelor, cum ar fi timpul de întârziere între clipiri, cantitatea de decelerare în timpul frânării de urgență etc.
Aici, în viitor, dacă cineva este interesat să implementeze un proiect pe ESP8266, pot posta un exemplu pentru modificarea setărilor prin interfața web, salvarea lor în EEPROM și apoi citirea lor.
Serverul web poate fi lansat, de exemplu, prin pornirea semnalului de direcție și prin apăsarea pedalei de frână la punerea contactului (în procedura de configurare, interogați starea intrărilor corespunzătoare).

Pentru a implementa un mod intermitent în timpul frânării puternice, am achiziționat
Schița monitorizează nivelul de decelerare la apăsarea pedalei de frână, dacă aceasta depășește 0,5G (decelerare bruscă, dar fără scârțâit de frâne), atunci un mod intermitent este pornit pentru câteva secunde pentru a atrage o atenție suplimentară.
Semnalele de control către intrările Arduino de la „plusul” de opriri, semnale de întoarcere și inversare sunt furnizate prin izolație galvanică - optocuple cu rezistențe de limitare a curentului, care în cele din urmă formează nivelul LOW la intrările Arduino (tras în mod constant la pozitiv prin rezistențe de 10 kOhm). ).
Alimentare - 5 volți printr-un convertor descendente DC-DC.
Întregul lucru este pliat într-un sandwich și ambalat într-o cutie potrivită, pe care direcția de instalare este marcată cu o săgeată pentru orientarea corectă a senzorului de gravitație

Diagrama si fotografie



Valoarea nominală a rezistențelor pull-up (la pozitive) este standard - 10 kOhm, limitând curentul rezistențelor optocupler - 1 kOhm. Am scos optocuptoarele de pe placile vechi, doua erau PC123, doua PC817.


In prima poza se vede doua terminale suplimentare eu le-am facut pentru semnalizatoare. Deoarece în mașina mea, când maneta coloanei de direcție este pornită, există un scurtcircuit la masă, am conectat firele la blocul de pârghii și la intrările Arduino. Dacă maneta coloanei de direcție comută plusul sau luați semnalul de la „+” lămpilor de semnalizare stânga/dreapta, atunci conectați-le prin izolație galvanică.



Ei bine, acum schița în sine (Arduino IDE)

#include #include //câteva comentarii generale // Am stins unul dintre LED-urile cele mai exterioare, pentru că... s-au reflectat pe panourile decorative ale rafturilor //vizibile în exemplul acestui ciclu pentru (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; //apoi schimba ciclurile din blocul STOP pentru (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); }

Am încercat să comentez pe cât posibil, dar dacă există întrebări, voi încerca să adaug comentarii (de aceea o plasez în textul recenziei și nu ca fișier atașat). Acest lucru, apropo, se aplică și altor puncte ale recenziei - o voi completa și dacă există întrebări semnificative în comentarii.

Și în final, o demonstrație a lucrării (pentru videoclip am folosit o schiță cu modul demo).

Actualizare. Am făcut schița cu modul demo special pentru a încadra totul într-un videoclip scurt.
Lampa de frana clipeste doar in timpul franarii puternice (asta s-a discutat mai sus), in timpul franarii lin si cand stai in ambuteiaje se aprinde pur si simplu, fara a iritati soferii din spate.
Luminozitatea pe timp de noapte nu este excesivă, pentru că Datorită înclinării sticlei, luminile sunt îndreptate mai mult în sus decât în ​​spate.
Luminile standard funcționează ca de obicei, această bandă le dublează.

Designerul luminilor de rulare de la Aliexpress este o placă de circuit imprimat și un set de componente radio. Tot ce trebuie să faceți este să lipiți componentele pe placă.

Dar puteți obține efecte mai interesante ale luminilor de rulare din el. De exemplu, pentru semnalizatoarele auto sau luminile de frână, sau doar pentru ghirlande pentru o vacanță.


Acest circuit poate funcționa în intervalul de tensiune de alimentare de 3 -15 volți. Generatorul de impulsuri este asamblat pe cipul NE555, apoi impulsurile sunt trimise la un contor zecimal cu un decodor - un cip CD4017 (sau K561IE8), la ieșirile cărora LED-urile sunt conectate prin rezistențe de limitare a curentului.

Viteza de comutare a luminilor de mers este reglată de un rezistor de reglare. Adăugați un circuit cu declanșatoare și comutatoare cu tranzistori de ieșire. Nu este nevoie să programezi nimic etc. Ca rezultat, puteți obține efecte de iluminare mai interesante ale luminilor de rulare. Trebuie să facem o altă placă de circuit imprimat cu declanșatoare K561TM2 și întrerupătoare de alimentare KT815. Un impuls de la fiecare ieșire K561IE8 este furnizat la intrarea de declanșare folosind principiul „blocare”, adică la ieșirea de declanșare semnalul rămâne constant până când pulsul de resetare ajunge de la pinul 11 ​​al microcircuitului CD4017(K561IE8). 9 canale sunt pornite pe ciclu.

Toți cei care au văzut o mașină mai mult sau mai puțin modernă nu pentru a doua oară și chiar dacă a fost o chestiune de condus, și-au notat de mult una dintre opțiunile utile... Oamenii o numesc semnal de direcție leneș sau politicos. semnal de viraj. Întreaga sa esență se rezumă la faptul că la virarea la dreapta sau la stânga șoferul atinge doar o singură dată maneta semnalizatorului, fără a o fixa. Adică, pur și simplu face ca circuitele semnalizatoarelor să funcționeze, dar nu pornește tocmai acest comutator. Drept urmare, după eliberarea manetei, indicatoarele de direcție sunt activate de încă 3-4 ori, iar în acest moment șoferul își poate desfășura deja „afacerea”, adică să se dedice complet drumului. Opțiunea este foarte utilă atunci când trebuie să schimbați benzile. La urma urmei, când pârghia semnalizatorului este complet pornită, oprirea automată nu va avea loc, din cauza unghiului nesemnificativ de rotație al volanului, ceea ce înseamnă că va trebui să împingeți înainte și înapoi cu indicatorul în sine sau să-l susțineți constant cu mâna ta pe punctul de a se aprinde pentru a imita funcționarea semnalizatorului. Și dacă există o astfel de opțiune, atunci am atins ușor maneta și am uitat. În general, credem că esența lucrării a fost pe deplin dezvăluită, dar acum merită menționată posibilitatea implementării unei astfel de opțiuni pe mașina dvs.

Pentru ce circuite electrice este potrivit un semnal de întoarcere politicos pe Arduino?

Înainte de a intra în toate problemele serioase legate de producerea unui semnal de întoarcere politicos, trebuie să înțelegeți pentru ce diagrame de conectare electrică va fi potrivită, fără a modifica circuitul electric al mașinii.
Aici ni se prezintă două opțiuni principale care diferă în principiu. Primul este atunci când semnalizatoarele se aprind atunci când sunt conectate ca sarcină. Adică, pornirea are loc datorită comutării circuitului lămpilor de semnalizare, în care se află chiar pârghia semnalizatorului, acesta este cel care închide circuitul, după care are loc operațiunea. În acest caz, nu va fi posibil să folosim opțiunea noastră, deoarece atunci când pârghia deschide circuitul cu lămpile, dezactivăm imediat posibilitatea de indicare a luminii, chiar dacă un semnal ajunge la pârghie în sine, pur și simplu nu va merge deloc. mai departe.
A doua opțiune este a noastră, când există semnale de control și sunt semnale de putere de ieșire. În acest caz, în locul releului standard, puteți instala exact circuitul pe care am dori să vă aducem la cunoștință.

Modul de putere releu care poate fi achiziționat de pe Internet pentru a controla sarcina de putere

Schiță și circuitul unui semnal de întoarcere leneș (politicos) pe Arduino

Deci, se poate argumenta despre utilizarea Arduino ca unitate principală pentru semnalele de viraj leneși, deoarece aceasta nu este, de asemenea, o soluție complet ideală, ceea ce are dezavantajele sale. De exemplu, va fi necesar să aveți putere constantă după pornirea contactului pentru a asigura performanța, va fi necesar să conectați circuitele de alimentare. În același timp, cablarea în sine a componentelor radio suplimentare este practic inutilă aici, deoarece în acest caz puteți pur și simplu să programați un microcontroler și să îl utilizați numai. Dar acest minus este și un plus, pentru că oricine are unul poate programa Arduino, iar pentru microcontrolere vei avea nevoie și de un programator.
Scrierea unui program va fi una dintre cele mai dificile sarcini. Aici un începător va trebui să petreacă mai mult de o oră din timpul său liber și să studieze munca algoritmilor, dar din fericire există Internet și există noi. Deci iată schița.

Int switchPinR=8; int switchPinL=7; int ledPinR=11; int ledPinL=12; boolean ledOn = fals; int i=0; int z=0; void setup() ( // puneți aici codul de configurare, pentru a rula o dată: pinMode(switchPinR, INPUT); pinMode(switchPinL, INPUT); pinMode(ledPinR, OUTPUT); pinMode(ledPinL, OUTPUT); Serial.begin(9600) ) void loop() ( // puneți aici codul principal, pentru a rula în mod repetat: //2 etichetă: if (digitalRead(switchPinR) == HIGH && digitalRead(switchPinL) == HIGH) ( digitalWrite(ledPinR, HIGH) ; digitalWrite(ledPinL, HIGH);<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; ) //ciclarea semnalului de urgență dacă (digitalRead(switchPinR) == HIGH && digitalRead(switchPinL) == HIGH) (du-te la etichetă;) //Semnalizator dreapta. dacă (digitalRead(switchPinR) == HIGH) ( digitalWrite(ledPinR, HIGH); i=0; în timp ce (i<7) { ledOn = !ledOn; digitalWrite(ledPinR, ledOn); delay(400); i++; z++; if (digitalRead(switchPinR) == LOW && z>=7) ( break; ) ) ) else ( digitalWrite(ledPinR, LOW); z=0; ) //Semnal de viraj stânga. dacă (digitalRead(switchPinL) == HIGH) ( digitalWrite(ledPinL, HIGH); i=0; în timp ce (i<7) { ledOn = !ledOn; digitalWrite(ledPinL, ledOn); delay(400); i++; z++; if (digitalRead(switchPinL) == LOW && z>=7) ( break; ) ) ) else ( digitalWrite(ledPinL, LOW); z=0; ) ) )

Pentru a rezuma pe scurt, schița are 2 intrări și 2 ieșiri. În acest caz, atunci când la intrarea (8,7) este introdus un semnal pozitiv, adică de nivel înalt, primim un anumit număr de clipiri (z sau i) la ieșirea corespunzătoare (11,12). Pe scurt, ceva de genul acesta. Adică, dacă doriți să schimbați ceva în schiță în ceea ce privește numărul de clipiri și ieșirile de intrare, atunci acordați atenție acestor variabile. Dacă trebuie să modificați durata clipirilor, atunci atenția dvs. ar trebui să se concentreze asupra funcției de întârziere.
O altă caracteristică a programului este o ieșire de alarmă oarecum neobișnuită. Mai întâi, indicatoarele din stânga și din dreapta sunt procesate, apoi se aprind luminile de avarie. Acest lucru se datorează faptului că se poate porni numai dacă intrarea este mare în același timp la intrările 8 și 7. Și această condiție va fi îndeplinită doar în al doilea ciclu, deoarece apăsarea a două butoane simultan este imposibil din punct de vedere fizic. Viteza microcontrolerului vă va permite să citiți mai repede ieșirea ridicată de la un buton și să decideți că aceasta este, până la urmă, o condiție pentru declanșarea semnalului de direcție și nu o alarmă. Deși nu ar trebui să vă faceți griji pentru asta, cu excepția cazului în care să vă mulțumesc pe drum va fi problematic.

Caracteristici de conectare a unui semnal de viraj leneș (politicos) într-o mașină folosind Arduino

Nu ar trebui să utilizați pinul 13 ca ieșire, deoarece de fiecare dată când porniți și opriți alimentarea, indicatorii care vor fi conectați la această ieșire pot pâlpâi.
Când treceți de la semnalele de control la semnalele de alimentare, utilizați blocuri corespunzătoare achiziționate de pe Internet sau asamblate de dvs. Am vorbit deja despre astfel de blocuri - module.
Când primiți semnalul 1 de la o tensiune de 12 volți, plasați o rezistență de 10 Kom în fața intrării.

Acestea sunt toate instrucțiunile pentru a face un semnal de întoarcere leneș pentru o mașină folosind un microcontroler Arduino, iar acum cam același lucru în videoclip...

© 2024 ermake.ru -- Despre repararea PC-ului - Portal de informații