Բջջային հեռախոսներ և գաջեթներ

1 Տեսակներկոճակներ

Կոճակները տարբեր են, բայց բոլորն էլ կատարում են նույն գործառույթը՝ ֆիզիկապես միացնում են (կամ, ընդհակառակը, կոտրում) հաղորդիչները միմյանց՝ էլեկտրական շփում ապահովելու համար։ Ամենապարզ դեպքում սա երկու հաղորդիչների միացումն է, կան կոճակներ, որոնք միացնում են ավելի մեծ թվով հաղորդիչներ։

Որոշ կոճակներ սեղմելիս թողնում են լարերը միացված ( կողպման կոճակներ), մյուսները - բաց թողնելուց անմիջապես հետո բացեք միացումը ( սեղմել կոճակները).

Կոճակները նույնպես բաժանվում են.

• սովորաբար բաց,
• սովորաբար փակ.

Այժմ կոճակների տեսակը, որոնք կոչվում են «տակտ կոճակներ». Ժամացույց - ոչ թե «տակտ» բառից, այլ «շոշափելի» բառից, քանի որ սեղմելը լավ զգացվում է մատների կողմից: Բայց այս սխալ տերմինը տեղավորվել է, և այժմ այս կոճակները մեր երկրում ամենուր այդպես են կոչվում: Սրանք կոճակներ են, որոնք սեղմելիս փակում են էլեկտրական շղթան, իսկ բաց թողնելուց բացվում են, այսինքն. դրանք չփակող, սովորաբար բաց կոճակներ են:

2 շաղակրատելկոնտակտներ

Կոճակը շատ պարզ և օգտակար գյուտ է, որը ծառայում է մարդու և տեխնոլոգիայի ավելի լավ փոխգործակցությանը: Բայց, ինչպես բնության մեջ ամեն ինչ, այն կատարյալ չէ։ Դա դրսեւորվում է նրանով, որ կոճակը սեղմելիս եւ երբ այն բաց է թողնվում, այսպես կոչված. «ցատկում» (անգլերեն «ցատկում»): Սա կոճակի վիճակի կրկնվող փոխարկումն է կարճ ժամանակահատվածում (մի քանի միլիվայրկյանների կարգի) մինչև այն ստաբիլ վիճակ ընդունելը: Այս անցանկալի երեւույթը տեղի է ունենում կոճակի միացման պահին՝ կոճակի նյութերի առաձգականության կամ էլեկտրական շփման ժամանակ առաջացող միկրոկայծերի պատճառով։

Հետևյալ հոդվածը մանրամասնում է կոնտակտները փակելիս և բացելիս «ցատկելու» հետ կապված հիմնական ուղիները: Միևնույն ժամանակ հաշվի առեք կոճակը Arduino-ին միացնելու տարբերակները։

3 Սխալ կապկոճակներ

Սովորաբար բաց տակտային կոճակը Arduino-ին միացնելու համար կարող եք դա անել ամենապարզ ձևով՝ կոճակի մի ազատ լարը միացնել հոսանքի կամ հողին, մյուսը՝ Arduino-ի թվային ելքին: Բայց, ընդհանուր առմամբ, սա սխալ է։ Փաստն այն է, որ այն պահերին, երբ կոճակը չի փակվում, Arduino-ի թվային ելքի վրա կհայտնվեն էլեկտրամագնիսական պիկապներ, և դրա պատճառով հնարավոր են կեղծ պոզիտիվներ:

Միջամտությունից խուսափելու համար թվային ելքը սովորաբար միացված է բավական մեծ ռեզիստորի միջոցով (10 կՕմ) կամ հողին կամ հոսանքին: Առաջին դեպքում կոչվում է «ձգվող դիմադրության միացում», երկրորդում - «քաշվող դիմադրության միացում». Եկեք նայենք նրանցից յուրաքանչյուրին:

4 Կոճակի միացումձգվող դիմադրության միացում

Նախ, մի կոճակ միացրեք Arduino-ին, օգտագործելով ձգվող դիմադրություն: Դա անելու համար մենք կոճակի մեկ կոնտակտը միացնում ենք գետնին, երկրորդը` թվային ելքին «2»: Թվային «2» ելքը նույնպես կմիացվի 10 կՕմ անվանական արժեք ունեցող ռեզիստորի միջոցով +5 Վ սնուցման:

Եկեք նման ուրվագիծ գրենք կոճակի սեղմումների մշակման համար և վերբեռնենք այն Arduino-ում։

// Սահմանել փին թվերը՝ const int buttonPin = 2; const int ledPin = 13; void setup()( pinMode (ledPin, OUTPUT); pinMode (կոճակPin, INPUT); } void loop() ( int buttonState = digitalRead (buttonPin); // կարդալ կոճակի վիճակը, եթե (buttonState == ԲԱՐՁՐ) ( digitalWrite (ledPin, HIGH); // միացնել LED-ը, երբ կոճակը սեղմված է ) այլապես ( digitalWrite (ledPin, LOW); // անջատել LED-ը երբ կոճակը բաց է թողնվում) }

Ներկառուցված լուսադիոդը «13» կոճակի վրա մշտապես վառվում է մինչև կոճակ սեղմելը: Նրանք. Arduino պորտը «2» միշտ բարձր է: Երբ մենք սեղմում ենք կոճակը, «2» պորտի լարումը դառնում է LOW, և LED-ը մարում է:

5 Կոճակի միացումիջնող ռեզիստորի միացում

Հիմա եկեք մի շղթա հավաքենք իջնող ռեզիստորով: Կոճակի մեկ կոնտակտը միացված է +5 Վ սնուցմանը, երկրորդը` թվային ելքին «2»: Միացրեք թվային ելքը «2» 10 կՕմ ռեզիստորի միջոցով գետնին: Էսքիզը չի փոխվի։

Երբ միացումը միացված է, Arduino-ի «2» թվային պորտը LOW է, իսկ LED-ն անջատված է: Երբ կոճակը սեղմվում է, «2» պորտը բարձրանում է և լուսադիոդը վառվում է:

Եվ Արդուինոայստեղ բացառություն չէ, լուսադիոդը թարթելուց հետո փորձում է միացնել կոճակը և իր օգնությամբ կառավարել հենց այս լուսադիոդի թարթումը։ Այստեղ առանձնապես բարդ բան չկա, բայց կա մեկ նրբերանգ, որը կոչվում է «կոնտակտային ցատկում»: Ինչպես ճիշտ միացնել կոճակը Արդուինո, ինչ է «կոնտակտային ցատկումը», ինչպես է դրսևորվում այս էֆեկտը և դրա դեմ պայքարի մեթոդները և կքննարկվեն այսօր։

Կոճակը միկրոկառավարիչին միացնելու ամենապարզ սխեման հետևյալն է.

Եթե ​​բանալին S1բաց (կոճակը բաց է թողնվել), ապա թվային մուտքագրում Դ ինմիկրոկոնտրոլեր, կունենանք տրամաբանական միավորին համապատասխանող 5 Վ լարում։ Երբ սեղմված է մուտքի կոճակը Դ ինմիանում է գետնին, որը համապատասխանում է տրամաբանական զրոյական մակարդակին, և ամբողջ լարումը կնվազի դիմադրության վրա R1, որի արժեքը ընտրվում է՝ ելնելով այն հանգամանքից, որ կոճակը սեղմելիս դրա միջով շատ հոսանք չի անցնում (սովորաբար մոտ 10 ÷ 100 կՕհմ)։

Եթե ​​դուք պարզապես միացնում եք կոճակը թվային մուտքի և հողի միջև (առանց դիմադրության R1միացված է +5V-ին) կամ մուտքի և +5V-ի միջև, այնուհետև այն դիրքում, երբ կոճակը սեղմված չէ միկրոկոնտրոլերի թվային մուտքի մոտ, կլինի չսահմանված լարում (դա կարող է համապատասխանել 0, կամ գուցե 1 մակարդակին) և մենք կկարդանք պատահական վիճակներ: Հետեւաբար, օգտագործվում է ռեզիստոր R1, որն ասում են, որ կոճակը բաց թողնելիս մուտքը «բարձրացնում է» մինչև +5V:

Կարդալով միկրոկառավարիչի թվային մուտքագրման վիճակը՝ կարող ենք որոշել՝ կոճակը սեղմված է (տրամաբանական 0 վիճակ), թե ոչ (մուտքում կստանանք տրամաբանական միավոր)։

Կոճակի միացում Արդուինո

Միկրոկարգավորիչներ Atmel AVR ATmega(որի հիման վրա էլ կառուցված է Արդուինո) ունեն ներկառուցված ծրագրային ապահովման հետ կապված բեռնման դիմադրիչներ R n 20 կՕհմ, և մենք կարող ենք դրանք օգտագործել՝ պարզեցնելով կապի դիագրամը:

Ներքին վերջնացնող ռեզիստորը միացված է պահանջվող պորտի բիթին տրամաբանական գրելու միջոցով:

Էսքիզային օրինակ Արդուինո, որը միացնում և անջատում է ներկառուցված լուսադիոդը 13-րդ պտուտակի վրա՝ կախված նրանից, թե արդյոք սեղմված է կամ բաց թողնված երկրորդ փին կոճակը, օգտագործելով ներքին ձգվող դիմադրությունը.

void setup() ( pinMode (13, OUTPUT); // LED 13 pinMode (2, INPUT); // Pin 2-ը մուտքային ռեժիմում է: Կոճակը միացված է գետնին: digitalWrite(2, HIGH); // միացրեք ձգվող դիմադրությունը ) void loop() ( digitalWrite(13, !digitalRead(2)); // կարդալ կոճակի վիճակը և միացնել LED-ը)

Այստեղ մենք շրջում ենք մուտքային պորտից կարդացված արժեքը՝ օգտագործելով բուլյան ՉԻ, որը ֆունկցիայից առաջ նշվում է բացականչական նշանով թվային կարդալ, քանի որ կոճակը սեղմելիս կարդում ենք 0, իսկ պորտում լուսադիոդը միացնելու համար պետք է ուղարկել 1։

Կոնտակտային խոսակցություններ

Ամեն ինչ լավ կլիներ, եթե մենք ապրեինք իդեալական աշխարհում՝ իդեալական կոճակներով։ Իրական մեխանիկական կոնտակտները, որոնք առկա են կոճակներում, երբեք անմիջապես չեն փակվում կամ բացվում: Կարճ ժամանակահատվածում բանալու (կոճակի) կոնտակտները բազմիցս փակվում և բացվում են, ինչի արդյունքում միկրոկոնտրոլերի մուտքի մեջ մտնում է ոչ թե մեկ լարման անկում, այլ իմպուլսների մի ամբողջ պոռթկում։ Այս երեւույթը կոչվում է «կոնտակտային ցատկում»:

Վերևի օրինակում, կոճակն օգտագործելիս մենք պարզապես միացրեցինք և անջատեցինք LED-ը, մենք դա չնկատեցինք, քանի որ «ցատկման» պահին LED-ի միացումը/անջատումը տեղի ունեցավ շատ արագ, և մենք դա պարզապես չտեսանք: մեր աչքերով.

Այս գրադարանը ներառում է հետևյալ մեթոդները.

• ցատկում()- Bounce օբյեկտի սկզբնավորումը
• void interval (չստորագրված երկար ընդմիջում)- սահմանում է անջատման ժամանակը միլիվայրկյաններով
• անվավեր կցում (int pin)- սահմանում է այն քորոցը, որին միացված է կոճակը և միացնում է ներկառուցված ձգվող դիմադրությունը այս փինին
• int թարմացում ()- քանի որ ցատկումչի օգտագործում, դուք «թարմացնում» եք օբյեկտը նախքան նրա վիճակը կարդալը, և դա պետք է արվի անընդհատ (օրինակ՝ ներսում հանգույց) Մեթոդ թարմացնել թարմացնում է օբյեկտը և վերադառնում ՃԻՇՏ(1) եթե քորոցի վիճակը փոխվել է (կոճակը սեղմվել է կամ, ընդհակառակը, բաց է թողնվել) և ՍՈՒՏ(0) հակառակ դեպքում: Մեթոդի զանգ թարմացնել ներսում հանգույցանհրաժեշտ է միայն մեկ անգամ անել:
• intread ()- վերադարձնում է փին-ի թարմացված վիճակը

Լռելյայնորեն, Bounce գրադարանը օգտագործում է կայունացման միջակայք ( կայուն ընդմիջում) իրականացնել հակաբռնում: Սա ավելի հեշտ է հասկանալ և թույլ է տալիս չիմանալ ցատկի տևողությունը:

Պարամետր կայուն ընդմիջումցատկում գրադարաններ

Սահմանելով

#define BOUNCE_LOCK-OUT

ֆայլում Ցատկում.հդուք կարող եք միացնել շաղակրատության հետ գործ ունենալու այլընտրանքային մեթոդ: Այս մեթոդը թույլ է տալիս արագ արձագանքել կոճակի վիճակի փոփոխությանը, այնուամենայնիվ, այն պահանջում է, որ դուք սահմանեք ցատկի տևողությունը, և այս արժեքը, ինչպես վերևում նշեցի, ժամանակի ընթացքում ավելանում է, ինչը նշանակում է, որ ձեզ հարկավոր է. փոփոխություններ կատարեք կոդի մեջ կամ դիտավորյալ ավելի մեծ արժեք սահմանեք:

Ահա այս գրադարանի օգտագործման օրինակ.

#ներառում bounce bouncer = ցատկում (); void setup() (pinMode(2,INPUT); // կոճակը pin 2-ի վրա digitalWrite(2,HIGH); bouncer .attach(2); // set button bouncer .interval(5); Serial.begin(9600); //Սերիական նավահանգիստը սահմանելով 9600 բ/վ ) void loop() ( if (bouncer.update()) ( //եթե իրադարձություն է տեղի ունեցել, եթե (bouncer.read()==0) ( //եթե կոճակը սեղմվել է Սերիական .println ("սեղմված"); // տպել մամուլի հաղորդագրություն ) else Serial. println ("հրապարակված"); // տպել թողարկման հաղորդագրություն))

Եվ ևս մեկ փոքր գործնական օգտակար օրինակ. Ենթադրենք՝ ունենք կոճակ, երբ սեղմվում է 2 վայրկյանից պակաս, փոփոխականը փոխվում է ընթացիկ_ռեժիմ, որը պահպանում է որոշ սարքի գործող ռեժիմը։ Այս օրինակում ռեժիմը 0-ից կփոխվի 5-ի: Սեղմեք մեկ անգամ՝ ռեժիմն ունի 1 թիվը: Կրկին սեղմեք՝ 2: Եվ այսպես շարունակ մինչև հինգը: Հինգից հետո, երբ այն կրկին սեղմում եք, ընթացիկ ռեժիմը դառնում է առաջինը և կրկին շրջանագծի մեջ: Եթե ​​կոճակը սեղմված եք պահում ավելի քան 2 վայրկյան, ապա փոփոխականը ընթացիկ_ռեժիմվերագրվում է 0 արժեքը:

#ներառում #define pressed_long 2000 // long press = 2 seconds #define num_modes 5 // ռեժիմի առավելագույն թիվը կարճ int max_mode = num_modes + 1; // օժանդակ փոփոխական Bounce bouncer = Bounce(); //ստեղծել Bounce դասի օրինակ unsigned long pressed_moment; // կոճակի սեղմման պահին int current_mode = 0; // ընթացիկ ռեժիմի void setup() (pinMode(2,INPUT); // կոճակ 2-րդ պինդ DigitalWrite(2,HIGH); // միացնել ներկառուցված pull-up resistor bouncer .attach(2); // set կոճակը ցատկող .interval( 5); // սահմանել պարամետրի կայուն միջակայքը = 5 ms Serial.begin(9600); //Սերիական պորտը սահմանել 9600 bps արագության վրա) void loop() (if (bouncer.update( )) ( //եթե դա տեղի է ունեցել իրադարձություն, եթե (bouncer.read()==0) ( //եթե կոճակը սեղմված է pressed_moment = millis(); // հիշել սեղմելու ժամանակը) այլ կերպ ( // կոճակն ազատվել է if((millis() - pressed_moment)< pressed_long) { // если кнопка была нажата кратковременно current_mode++; // увеличиваем счетчик текушего режима current_mode %= max_mode; // остаток от целочисленного деления if (current_mode == 0) current_mode = 1; // режим меняется от 1 до num_modes } else { // кнопка удерживалась долго current_mode = 0; pressed_moment = 0; // обнуляем момент нажатия } Serial.println("Current mode:"); Serial.println(current_mode); // выводим сообщение о текущем режиме } } }

Անձնական համակարգչի ինքնուրույն հավաքումը ոչ միայն հետաքրքիր գործունեություն է, որը համեմատելի է կոնստրուկտոր խաղալու հետ, այլ նաև արժանապատիվ գումար խնայելու հիանալի միջոց (սպասարկման կենտրոնում այս ծառայությունն արժե միջինը բոլոր բաղադրիչների արժեքի 10%-ը): )

Աշխատանքի կատարման ճշգրտության և հետևողականության լրացուցիչ պարգևը կլինի կատարյալ աշխատող համակարգիչը և ձեր ձեռքբերումներով հպարտության զգացումը:

Համակարգի միավորի հավաքումը սկսվում է համակարգչի հիմնական բաղադրիչները (վիդեո քարտ, կոշտ սկավառակ, պրոցեսոր, սնուցման աղբյուր և այլն) մայր տախտակին միացնելուց:

Այս փուլում հարցեր են ծագում չափազանց հազվադեպ, քանի որ բոլոր միակցիչները և խրոցակները պատրաստված են այնպես, որ պարզապես չի աշխատի ինչ-որ բան շփոթել տեղերում կամ միացնել այն սխալ կողմից:

Երբ ամբողջ «երկաթը» դասավորվում է, անհրաժեշտ է համակարգային միավորի պատյանը միացնել մայր տախտակին։ Դրա վրա ցուցադրվում են կարևոր հսկիչներ և ցուցիչներ:

Խոսքը միացման կոճակների (Power) և ԱՀ-ի հարկադիր վերագործարկման (Reset), ինչպես նաև հոսանքի և կոշտ սկավառակի ակտիվության ցուցիչների մասին է։

Մանրանկարչական միակցիչներով լարերը հեռանում են նշված տարրերից յուրաքանչյուրից: Դրանք պետք է դրվեն մայր տախտակի համապատասխան խրոցակների վրա։

Որպեսզի պարզ լինի, թե կոնկրետ ինչ գործառույթի համար է պատասխանատու կոնկրետ մետաղալարը, արտադրողները յուրաքանչյուր մինի միակցիչի վրա դնում են հետևյալ նշանները.

• Power SW (Power Switch) - միակցիչ, որը գալիս է հոսանքի կոճակից (Power): Այս կոճակը սեղմելով՝ համակարգիչը միանում է;
• Reset SW (Reset Switch) - միակցիչ, որը գալիս է համակարգչի հարկադիր վերագործարկման կոճակից;
• Power Led - համակարգչի միացման/անջատման ցուցիչի միակցիչ;
• HDD LED - հաղորդալար, որը գալիս է համակարգչի կոշտ սկավառակի կարգավիճակի ցուցիչից;
• SPEAKER - համակարգի բարձրախոսի միացման միակցիչ («Tweeter»);
• HD Աուդիո - խոսափող և ականջակալներ;
• USB - USB միակցիչ:

Մենք գործի կոճակները միացնում ենք մայր տախտակին

Իրավունքի համար միացնելով Power և Reset կոճակները մայր տախտակինդուք պետք է ձեռքի տակ ունենաք ձեռնարկը: Տախտակի դիագրամում դուք պետք է տեղեկատվություն գտնեք կոնտակտային բլոկի գտնվելու վայրի մասին:

Շատ դեպքերում արտադրողներն այն անվանում են «F_Panel», «Front Panel» կամ պարզապես «Panel»: Եթե ​​հրահանգը կորել է, պարզապես անհրաժեշտ է ուշադիր ուսումնասիրել մայր տախտակը և գտնել դրա վրա միակցիչների այս խումբը:

1. Նախ, մենք միացնում ենք Power SW (Power Switch) հոսանքի կոճակի միակցիչը տախտակին: Մայր տախտակի վրա դրա տեղը նշանակված է որպես «PWR_BTN»: Քանի որ սա կոճակ է, ոչ թե ցուցիչ, միացման կոճակը մայր տախտակին միացնելու բևեռականությունը նշանակություն չունի: Միացման կոճակի մալուխը կարող է միացված լինել ցանկացած ուղղությամբ:
2. Հաջորդը, մենք միացնում ենք հարկադիր վերակայման կոճակը Reset SW (Reset Switch): Մայր տախտակի վրա այս միակցիչի գտնվելու վայրը պիտակավորված է «Վերականգնել» կամ «RESET_SW» և գտնվում է անմիջապես հոսանքի կոճակի միակցիչի տակ: Այս դեպքում բևեռականությունը նույնպես նշանակություն չունի։
3. Մենք միացնում ենք համակարգի միավորի ցուցիչները մայր տախտակին
4. Կենտրոնանալով գծապատկերի վրա՝ ցուցումների կամ մայր տախտակի վրա տպված նշանների վրա, դուք պետք է միացնեք ցուցադրման միակցիչները:

Ցուցանիշները միացնելիս կարևոր է դիտարկել բևեռականությունը, հակառակ դեպքում դրանք պարզապես չեն այրվի: Ինքնատախտակի վրա բևեռականությունը նշվում է «+» և «-» նշաններով:

Այն պետք է լինի նաև միակցիչների վրա: Եթե ​​այն չկա կամ տեսանելի չէ, ապա պետք է օգտագործել ակնարկը՝ սպիտակ մետաղալարը մինուս է, գունավոր մետաղալարը՝ գումարած։

Մայր տախտակի վրա ԱՀ-ի միացման/անջատման ցուցիչի միակցիչի (Power Led) տեղը նշանակված է որպես «PWR_LED», HDD LED միակցիչը միացնելու համար՝ «HDD_LED»:

ՏԵՍԱՆՅՈՒԹ ՀՐԱՀԱՆՄԱՆ

Եթե ​​համակարգիչը միացնելուց հետո ցուցիչներից որևէ մեկը չի աշխատում, պարզապես միացրեք միակցիչը՝ այն մյուս կողմը դարձնելով:

Նմանապես, համակարգի միավորի պատյանից եկող այլ միակցիչներ միացված են մայր տախտակին՝ SPEAKER, HD Audio և USB:

Հրահանգ

Կոճակները տարբեր են, բայց բոլորն էլ կատարում են նույն գործառույթը՝ ֆիզիկապես միացնում են (կամ, ընդհակառակը, կոտրում) հաղորդիչները միմյանց՝ էլեկտրական շփում ապահովելու համար։ Ամենապարզ դեպքում սա երկու հաղորդիչների միացումն է, կան կոճակներ, որոնք միացնում են ավելի մեծ թվով հաղորդիչներ։
Որոշ կոճակներ, երբ սեղմված են, թողնում են հաղորդիչները միացված (սողնակային կոճակներ), մյուսները բացում են շղթան անմիջապես բաց թողնելուց հետո (չփակող):
Նաև կոճակները բաժանվում են սովորաբար բաց և սովորաբար փակ: Առաջինը, երբ սեղմված է, փակեք միացումը, երկրորդը `բաց:
Այժմ այն ​​կոճակները, որոնք կոչվում են «տակտ կոճակներ», լայն կիրառություն են գտել։ Ժամացույց - ոչ թե «տակտ» բառից, այլ ավելի շուտ «շոշափելի» բառից, քանի որ. սեղմելը լավ զգացվում է մատների կողմից: Սրանք կոճակներ են, որոնք սեղմելիս փակում են էլեկտրական շղթան, իսկ բաց թողնելուց հետո բացում են այն։

Կոճակը շատ պարզ և օգտակար գյուտ է, որը ծառայում է մարդու և տեխնոլոգիայի ավելի լավ փոխգործակցությանը: Բայց, ինչպես բնության մեջ ամեն ինչ, այն կատարյալ չէ։ Դա դրսեւորվում է նրանով, որ կոճակը սեղմելիս եւ երբ այն բաց է թողնվում, այսպես կոչված. " " ("ցատկում" -ի մեջ): Սա կոճակի վիճակի կրկնվող փոխարկումն է կարճ ժամանակահատվածում (մի քանի միլիվայրկյանների կարգի) մինչև այն ստաբիլ վիճակ ընդունելը: Այս անցանկալի երևույթը տեղի է ունենում կոճակի միացման պահին՝ կոճակի նյութերի առաձգականության կամ էլեկտրականության ժամանակ առաջացող միկրոկայծերի պատճառով։
Դուք կարող եք տեսնել ձեր սեփական աչքերով Arduino-ի միջոցով, որը մենք կանենք մի փոքր ուշ:

Սովորաբար բաց տակտային կոճակը Arduino-ին միացնելու համար կարող եք դա անել ամենապարզ ձևով՝ կոճակի մի ազատ լարը միացնել հոսանքի կամ հողին, մյուսը՝ Arduino-ի թվային ելքին: Բայց, ընդհանուր առմամբ, սա սխալ է։ Փաստն այն է, որ այն պահերին, երբ կոճակը չի փակվում, Arduino-ի թվային ելքի վրա կհայտնվեն էլեկտրամագնիսական պիկապներ, և դրա պատճառով հնարավոր են կեղծ պոզիտիվներ:
Միջամտությունից խուսափելու համար թվային ելքը սովորաբար միացված է բավական մեծ ռեզիստորի միջոցով (10 կՕմ) կամ հողին կամ հոսանքին: Առաջին դեպքում այն ​​կոչվում է «ձուլվող ռեզիստորով», երկրորդում՝ «շղթա հանվող ռեզիստորով»։ Եկեք նայենք նրանցից յուրաքանչյուրին:

Նախ, մի կոճակ միացրեք Arduino-ին, օգտագործելով ձգվող դիմադրություն: Դա անելու համար կոճակի մի կոնտակտը միացնում ենք գետնին, երկրորդը` թվային ելքին 2: Միացնում ենք նաև թվային ելքը 2 10 կՕհմ անվանական արժեքով մինչև +5 Վ ռեզիստորի միջոցով:

Եկեք նման ուրվագիծ գրենք կոճակի սեղմումների մշակման համար և վերբեռնենք այն Arduino-ում։
Այժմ 13-րդ մատիտի վրա ներկառուցված LED-ն անընդհատ միացված է, մինչև կոճակը սեղմվի: Երբ սեղմում ենք կոճակը, այն դառնում է LOW, և լուսադիոդը մարում է:

Կոճակի սենսորը arduino-ին միացնելը պահանջում է որոշակի գիտելիքներ և հմտություններ: Այս հոդվածում մենք կխոսենք այն մասին, թե ինչ է նրբանկատ կոճակը, ինչ է կոճակի ցատկումը, ինչպես ճիշտ միացնել կոճակը քաշվող և իջնող ռեզիստորով, ինչպես կարող եք կառավարել LED-ները և այլ սարքերը կոճակով:

Կոճակը (կամ կոճակի անջատիչը) ամենապարզն ու մատչելին է բոլոր տեսակի սենսորներից: Սեղմելով դրա վրա, դուք ազդանշան եք տալիս վերահսկիչին, որն այնուհետև հանգեցնում է որոշակի գործողության. LED-ները միանում են, հնչում են ձայներ, շարժիչները միանում են: Մեր կյանքում մենք հաճախ ենք հանդիպում տարբեր անջատիչների հետ և լավ ծանոթ ենք այս սարքին:

Տակտ և միացման կոճակներ

Ինչպես միշտ, մենք սկսում ենք բաժինը պարզ բաներով, որոնք հետաքրքիր են միայն սկսնակների համար: Եթե ​​դուք գիտեք հիմունքները և ցանկանում եք իմանալ կոճակը arduino-ին միացնելու տարբեր տարբերակների մասին, կարող եք բաց թողնել այս պարբերությունը:

Ի՞նչ է կոճակը: Փաստորեն, սա բավականին պարզ սարք է, որը փակում և բացում է էլեկտրական ցանցը: Դուք կարող եք կատարել այս փակումը/բացումը տարբեր ռեժիմներով՝ ֆիքսելով կամ չֆիքսելով ձեր դիրքը: Համապատասխանաբար, բոլոր կոճակները կարելի է բաժանել երկու մեծ խմբի.

• Կոճակի անջատիչներ ամրագրմամբ: Նրանք ազատվելուց հետո վերադառնում են իրենց նախնական վիճակին։ Երբ, կախված նախնական վիճակից, դրանք բաժանվում են սովորաբար փակ և սովորաբար բաց կոճակների։
• Պահական կոճակներ (տակտ կոճակներ): Նրանք ֆիքսված են և մնում են այն դիրքում, որում մնացել են։

Կան բազմաթիվ տարբերակներ տարբեր կոճակների համար, սա իսկապես էլեկտրոնային բաղադրիչների ամենատարածված տեսակներից մեկն է:

Arduino կոճակներ պարզ նախագծերի համար

Մեր նախագծերում մենք կաշխատենք շատ պարզ 4-փին տակտ կոճակներով, որոնք գալիս են գրեթե ցանկացած arduino հավաքածուի հետ: Կոճակը երկու զույգ կոնտակտներով անջատիչ է: Մեկ զույգի կոնտակտները փոխկապակցված են, ուստի միացումում մեկից ավելի անջատիչ չի կարող իրականացվել, բայց դուք կարող եք միաժամանակ կառավարել երկու զուգահեռ հատվածներ, դա կարող է օգտակար լինել:

Կախված իրավիճակից, դուք կարող եք ստեղծել և՛ սովորաբար փակ, և՛ սովորաբար բաց սխեմաներ. այն ամենը, ինչ դուք պետք է անեք, համապատասխանաբար միացրեք շղթան:

Օգտագործման հեշտության համար նրբանկատ կոճակը սովորաբար գալիս է ինչ-որ գույնի պլաստիկ գլխարկով, այն ակնհայտորեն դրված է կոճակի վրա և նախագծին տալիս է ավելի քիչ խաբուսիկ տեսք:

Arduino կոճակի միացում

LED-ի միացումն ու անջատումը կոճակով

Եկեք սկսենք տակտային անջատիչ միացնելու ամենահեշտ ձևից: Դիտարկենք Arduino-ով մի շղթա՝ որպես հոսանքի աղբյուր, LED-ով, 220 օմ սահմանափակող ռեզիստորով և կոճակով, որը կփակի և կբացի շղթան:

Երկու զույգ ոտքերով կոճակը միացնելիս կարևոր է ընտրել ճիշտ ընդմիջման կոնտակտները: Ուշադիր նայեք պատկերին. կոճակի կողքերում տեղադրված են զույգ ոտքեր: Կոճակն ինքնին քառակուսի է, բայց զույգ կոնտակտների միջև եղած հեռավորությունները տեսողականորեն նկատելի են. դուք կարող եք անմիջապես տարբերակել երկուսը մի կողմից և երկուսը մյուս կողմից: Այսպիսով, կողքի մեկ «զույգի» միջև է, որ անջատիչը կիրականացվի: Շղթայում ընդգրկվելու համար մենք միանում ենք մեկին և մյուսին, որոնց միջև կա նվազագույն հեռավորություն: Կոնտակտների երկրորդ զույգը պարզապես կրկնօրինակում է առաջինը:

Եթե ​​ունեք այլ տիպի անջատիչ, ապա կարող եք ապահով կերպով ընտրել կոնտակտներ հակառակ անկյուններից (որոշ կոճակների վրա հատուկ նշան է արված խորշի տեսքով, որով կարող եք որոշել, թե որ կողմում են գտնվում զուգակցված կոնտակտները): Ճիշտ ոտքերը որոշելու ամենահուսալի միջոցը կոնտակտները ստուգիչով զանգելն է:

Շղթան ինքնին կոճակով, LED-ով և Arduino կարգավորիչով շատ բացատրության կարիք չունի: Կոճակը խախտում է միացումը, LED-ն անջատված է: Երբ սեղմված է, միացումը փակվում է, LED- ը միանում է: Եթե ​​կոնտակտները խառնեք (միացնեք կոճակի փակ զույգ կոնտակտների միջոցով), ապա կոճակը չի աշխատի, քանի որ շղթան երբեք չի բացվի: Պարզապես փոխեք կոնտակտները:

Կոճակի միացում ձգվող ռեզիստորով

Այժմ կոճակը միացնենք arduino-ին, որպեսզի կարողանանք կարդալ դրա վիճակը էսքիզում: Դա անելու համար մենք օգտագործում ենք հետևյալ սխեման.

Էսքիզում մենք կհետևենք պորտի մոնիտորում հաղորդագրություն սեղմելու և ցուցադրելու փաստին: Ավելի հետաքրքիր օրինակ և բուն սխեմայի մանրամասն բացատրությունը կտրվի ավելի ուշ:

Ուշադրություն դարձրեք 10K դիմադրությանը, որը մենք ավելացրել ենք այս շղթայում: Դրա նպատակի մասին ավելի մանրամասն կխոսենք ավելի ուշ, պարզապես հիշեք, որ նման դիմադրությունն անհրաժեշտ է շղթայի ճիշտ աշխատանքի համար:

Էսքիզ Arduino կոճակի համար՝ ձգվող ռեզիստորով.

/* Arduino-ում տակտ կոճակի օգտագործման օրինակ: Կոճակը միացված է փին 2-ին: */ const int PIN_BUTTON = 2; void setup() ( Serial.begin(9600); pinMode(PIN_LED, OUTPUT); ) void loop() (// Ստացեք կոճակի վիճակը և ցուցադրեք պորտի մոնիտորին int buttonState = digitalRead(PIN_BUTTON); Serial.println(buttonState); ուշացում (50);

Կոճակի միացում INPUT_PULLUP ռեժիմում

Վերոնշյալ միացումում մենք օգտագործեցինք դիմադրություն, որը կոչվում է pull-up resistor՝ թվային պորտի վրա որոշակի ազդանշանի մակարդակ առաջացնելու համար: Բայց կա կոճակ առանց ռեզիստորի միացնելու մեկ այլ տարբերակ՝ օգտագործելով arduino տախտակի ներքին դիմադրությունը։ Կարգավորման բլոկում մենք պարզապես պետք է սահմանենք կապի տեսակը, որին մենք կմիացնենք կոճակը, որպես INPUT_PULLUP:

PinMode (PIN_BUTTON, INPUT_PULLUP);

Այլընտրանքային տարբերակ կլինի փին ռեժիմը որպես OUTPUT ընտրելը և այս պորտում ազդանշանի մակարդակը բարձր դնելը: Ներկառուցված ձգվող ռեզիստորը միանում է ավտոմատ կերպով:

PinMode (PIN_BUTTON, INPUT_PULLUP); digitalWrite (PIN_BUTTON, HIGH);

Եվ այսքանը: Դուք կարող եք հավաքել նման բարդ միացում և աշխատել էսքիզում գտնվող կոճակով:

Լուսադիոդը թարթում է կոճակը սեղմելուց հետո

Նախորդ օրինակում LED-ներով, մենք մի կոճակ միացրինք arduino տախտակին և հասկացանք, թե ինչպես է այն աշխատում: LED- ը միացավ և անջատվեց, բայց դա արեց ամբողջովին պասիվ ռեժիմով - վերահսկիչն ինքնին այստեղ բացարձակապես ավելորդ էր, այն կարող էր փոխարինվել մարտկոցներով: Հետևաբար, եկեք մեր նոր նախագիծն ավելի «խելացի» դարձնենք. կոճակը սեղմելիս մենք կստիպենք LED-ն անընդհատ թարթել։ Դուք չեք կարող դա անել սովորական սխեմայով լամպով և անջատիչով. մենք կօգտագործենք մեր միկրոկարգավորիչի հզորությունը այս, թեև պարզ, բայց ոչ աննշան խնդիրը լուծելու համար:

Ծրագրի ամբողջական սխեման ներկայացված է նկարում.

LED-ով շղթայի մի հատված մեզ արդեն լավ հայտնի է: Մենք սովորական փարոս ենք հավաքել լուսադիոդով և սահմանափակող ռեզիստորով։ Բայց երկրորդ մասում մենք տեսնում ենք ծանոթ կոճակ և մեկ այլ ռեզիստոր: Թեև մենք չենք խորանա մանրամասների մեջ, մենք պարզապես կհավաքենք սխեման և կվերբեռնենք պարզ ուրվագիծ arduino-ում: Շղթայի բոլոր տարրերը գտնվում են ամենապարզ arduino մեկնարկային փաթեթներում:

/* Սխեմատիկ ուրվագիծ՝ օգտագործելով տակտ կոճակը և լուսադիոդը Կոճակը սեղմելիս լուսադիոդը թարթում է: Կոճակը քաշվում է գետնին, սեղմելով մուտքագրման վրա համապատասխանում է HIGH */ const int PIN_BUTTON = 2; const int PIN_LED = 13; void setup() ( Serial.begin(9600); pinMode(PIN_LED, OUTPUT); ) void loop() ( // Ստացեք կոճակի վիճակը int buttonState = digitalRead(PIN_BUTTON); Serial. println(buttonState); // Եթե կոճակը սեղմված չէ, այնուհետև ոչինչ մի արեք, եթե (!buttonState) ( հետաձգում(50); վերադարձ; (1000); թվային գրել (PIN_LED, LOW); ուշացում (1000); )

Սեղմեք և պահեք - լուսադիոդը թարթում է: Բաց թող - դուրս է գալիս: Հենց այն, ինչ ուզում էին։ Մենք ուրախությունից ծափ ենք տալիս և անցնում մեր արածի վերլուծությանը։

Եկեք նայենք էսքիզին. Դրանում մենք տեսնում ենք բավականին պարզ տրամաբանություն.

1. Որոշեք, արդյոք կոճակը սեղմված է:
2. Եթե ​​կոճակը սեղմված չէ, ապա մենք պարզապես դուրս ենք գալիս հանգույցի մեթոդից՝ առանց որևէ բան ներառելու կամ փոխելու:
3. Եթե ​​կոճակը սեղմված է, ապա մենք թարթում ենք՝ օգտագործելով ստանդարտ ուրվագծի մի հատված.
   1. Միացրեք լուսադիոդը` լարումը կիրառելով ցանկալի պորտին
   2. Մենք անհրաժեշտ դադար ենք անում, երբ լուսադիոդը միացված է
   3. LED-ն անջատելը
   4. Մենք անհրաժեշտ դադար ենք անում, երբ LED-ն անջատված է

Էսքիզում կոճակի վարքագծի տրամաբանությունը կարող է կախված լինել ձգվող ռեզիստորով միացման եղանակից: Այս մասին կխոսենք հաջորդ հոդվածում։

arduino կոճակի ցատկում

Կոճակների հետ աշխատելու ընթացքում կարող ենք հանդիպել շատ տհաճ երեւույթի, որը կոչվում է կոճակի ցատկում։ Ինչպես ենթադրում է անունը, այս երևույթը պայմանավորված է կոճակի անջատիչի ներսում շփման ցատկումով: Մետաղական թիթեղները ակնթարթորեն չեն դիպչում միմյանց (թեև մեր աչքերի համար շատ արագ), ուստի շփման գոտում կարճ ժամանակով տեղի են ունենում լարման բարձրացումներ և անկումներ: Եթե ​​մենք չենք կանխատեսում նման «աղբի» ազդանշանների հայտնվելը, ապա ամեն անգամ կարձագանքենք դրանց և կարող ենք մեր նախագիծը տուն բերել։

Շատախոսությունները վերացնելու համար օգտագործվում են ծրագրային և ապարատային լուծումներ: Մի խոսքով, մենք միայն կնշենք խոսակցությունները ճնշելու հիմնական մեթոդները.

• Մենք ուրվագծում ավելացնում ենք 10-50 միլիվայրկյան դադար՝ arduino փինից արժեքներ ստանալու միջև:
• Եթե ​​մենք օգտագործում ենք ընդհատումներ, ապա ծրագրային մեթոդը չի կարող օգտագործվել, և մենք կազմում ենք ապարատային պաշտպանություն։ Դրանցից ամենապարզը RC ֆիլտրն է կոնդենսատորով և ռեզիստորով:
• Շրջանառության ավելի ճշգրիտ զսպման համար օգտագործվում է ապարատային ֆիլտր, որն օգտագործում է Schmidt ձգան: Այս տարբերակը թույլ կտա ձեզ ստանալ գրեթե կատարյալ ձևի ազդանշան arduino-ի մուտքի մոտ:

Դուք կարող եք ավելի շատ տեղեկություններ գտնել շաղակրատության հետ կապված ուղիների մասին այս մեկում:

Ռեժիմների փոխարկում կոճակով

Որպեսզի որոշեք, թե արդյոք կոճակը սեղմված է, պարզապես անհրաժեշտ է արձանագրել այն սեղմված լինելու փաստը և պահպանել հատկանիշը հատուկ փոփոխականում:

Մենք որոշում ենք սեղմելու փաստը՝ օգտագործելով digitalRead () ֆունկցիան։ Արդյունքում մենք կստանանք HIGH (1, TRUE) կամ LOW (0, FALSE), կախված նրանից, թե ինչպես է միացված կոճակը: Եթե ​​կոճակը միացնենք ներքին ձգվող ռեզիստորով, ապա կոճակը սեղմելով մուտքը կհայտնվի 0 մակարդակում (FALSE):

Դուք կարող եք օգտագործել բուլյան փոփոխական՝ կոճակի սեղմման մասին տեղեկությունները պահելու համար.

բուլյան ստեղնը սեղմված = թվային կարդալ (PIN_BUTTON)==ՑԱԾ;

Ինչու ենք մենք օգտագործում նման շինարարություն և չենք արել սա.

բուլյան ստեղնը սեղմված = թվային կարդալ (PIN_BUTTON);

Բանն այն է, որ digitalRead()-ը կարող է վերադառնալ HIGH, բայց դա չի նշանակում, որ կոճակը սեղմված է: Ձգվող ռեզիստորով շղթա օգտագործելու դեպքում HIGH կնշանակի, որ կոճակը, ընդհակառակը, սեղմված չէ: Առաջին տարբերակում (digitalRead(PIN_BUTTON)==LOW), մենք անմիջապես համեմատեցինք մուտքագրումը մեզ անհրաժեշտ արժեքի հետ և որոշեցինք, որ կոճակը սեղմված է, թեև մուտքագրումն այժմ ցածր է: Եվ կոճակի կարգավիճակը պահպանեց փոփոխականում: Փորձեք հստակորեն նշել ձեր կատարած բոլոր տրամաբանական գործողությունները, որպեսզի ձեր կոդը ավելի թափանցիկ դարձնեք և խուսափեք անհարկի հիմար սխալներից:

Ինչպե՞ս փոխել գործառնական ռեժիմները կոճակը սեղմելուց հետո:

Հաճախ իրավիճակ է ստեղծվում, երբ կոճակների օգնությամբ պետք է հաշվի առնել կոճակը ոչ միայն սեղմելու, այլեւ բաց թողնելու հանգամանքը։ Օրինակ, սեղմելով և բաց թողնելով կոճակը, մենք կարող ենք միացնել լույսը կամ փոխել շղթայի աշխատանքային ռեժիմը: Այսինքն՝ մենք պետք է ինչ-որ կերպ ֆիքսենք կոճակի սեղմման փաստը և հետագայում օգտագործենք տեղեկատվությունը, նույնիսկ եթե կոճակն այլևս չի սեղմվում։ Տեսնենք, թե ինչպես կարելի է դա անել:

Ծրագրի տրամաբանությունը շատ պարզ է.

• Մենք հիշում ենք ծառայության փոփոխականում սեղմելու փաստը:
• Սպասում ենք, մինչև չխկչխկոցի հետ կապված երևույթներն անցնեն։
• Մենք սպասում ենք այն փաստին, որ կոճակը թողարկվի։
• Մենք հիշում ենք բաց թողնելու փաստը և առանձին փոփոխականի մեջ դրել ենք կոճակն ամբողջությամբ սեղմված նշան:
• Ծառայության փոփոխականի մաքրում:

Ինչպե՞ս հայտնաբերել կոճակների մի քանի սեղմում:

Պարզապես պետք է հիշել համապատասխան փոփոխականի կամ arduino զանգվածի կոճակներից յուրաքանչյուրի վիճակը։ Այստեղ հիմնականը հասկանալն է, որ յուրաքանչյուր նոր կոճակ զբաղված փին է: Հետևաբար, եթե ձեր ունեցած կոճակների թիվը մեծ է, ապա կարող է առաջանալ անվճար կոնտակտների պակաս: Այլընտրանքային տարբերակ է օգտագործել կոճակների միացումը մեկ անալոգային պինդին` ըստ դիմադրողական բաժանարարի սխեմայի: Այս մասին մենք կխոսենք հետագա հոդվածներում: