Arduino ղեկի ջոյստիկի կառավարում։ Joystick Arduino - կապ և ուրվագիծ: Միացում Arduino տախտակին

Դա տվյալների մուտքագրման մոդուլ է: Նրա օգնությամբ դուք կարող եք կառավարել ռոբոտներ, մանիպուլյատորներ, հաստոցներ, տարբեր մոդելներ (մեքենաներ, տանկեր, ինքնաթիռներ, ուղղաթիռներ, կվադոկոպերներ, նավակներ և այլն), ինչպես նաև օգտագործել խաղային կոնսուլներ ստեղծելու համար, ընտրել ցանկի տարրեր էկրանների և ցուցիչների վրա, մուտքագրեք արժեքներ և այլն: Ջոյստիկը կարելի է ոչ միայն տեղափոխել X և Y առանցքներով, այլև սեղմել դրա վրա:

Տեսանյութ.

Տեխնիկական:

  • Մատակարարման լարումը: 5V / 3.3V (երկու լարումները գտնվում են ընդունելի միջակայքում):
  • Էներգիայի սպառում:< 10 мА
  • Չափերը՝ 30x30 մմ

«Trema» գծի բոլոր մոդուլները պատրաստված են նույն ձևաչափով

Միացում:

  • Մոդուլի «X» և «Y» կապանքները միացված են Arduino-ի ցանկացած անալոգային մուտքին: Այս քորոցներից կարդացվող արժեքները մեծանում են, երբ ջոյսթիկը տեղափոխում եք ձախից աջ և ներքևից վերև:
  • K փին թվային է և միանում է Arduino-ի ցանկացած փին: Նորմալ վիճակում այն ​​ունի տրամաբանական «0» մակարդակ, իսկ երբ սեղմում եք ջոյսթիկն այն փոխվում է տրամաբանական «1»-ի։
  • V և G կապերը հոսանքի կապում են:

Հարմար է մոդուլը միացնել 3 եղանակով՝ կախված իրավիճակից.

Մեթոդ - 1:Օգտագործելով լարային ժապավենային մալուխ և Piranha UNO

Օգտագործելով «Papa - Mama» լարերը, մենք ուղղակիորեն միանում ենք Piranha UNO վերահսկիչին


Մեթոդ - 2. Օգտագործելով Trema Set Shield-ը

Մոդուլը կարող է միացված լինել Trema Set Shield-ի անալոգային մուտքերից որևէ մեկին:


Մեթոդ - 3. Օգտագործելով լարային ժապավենային մալուխ և վահան

Օգտագործելով 5 մետաղալար ժապավենային մալուխ, դեպի Trema Shield, Trema-Power Shield, Motor Shield, Trema Shield NANO և այլն:


Սնուցում:

Vcc (V) և GND (G) կապերին մատակարարվում է 5V կամ 3.3V DC մուտքային լարում:

Ավելին մոդուլի մասին.

Մոդուլի տվյալները կարդացվում են երկու պոտենցիոմետրից և տակտային կոճակից, որոնք մեխանիկորեն միացված են ջոյսթիկի լծակին: Կոճակը միացված է Vcc էլեկտրամատակարարման ընդմիջմանը և «K» ելքին, որը ռեզիստորի միջոցով սեղմվում է GND-ին։ Հետևաբար, «K» ելքում կարող են սահմանվել միայն երկու վիճակ՝ տրամաբանական «0» (կոճակը բաց է թողնվել) կամ «1» (կոճակը սեղմված է): «X» և «Y» կոորդինատների քորոցները մոդուլի անալոգային ելքերն են, դրանք միացված են պոտենցիոմետրերին այնպես, որ այս կապիչների և GND-ի միջև վերցված լարումը մեծանում է, երբ ջոյստիկը տեղափոխվում է ձախից աջ և ներքևից վերև:

Օրինակներ.

Ջոյսթիկի դիրքի որոշում և միացնել LED-ը՝ սեղմելով կոճակը

const int8_t Xaxis = A0; // Որոշեք այն պտուտակի թիվը, որին միացված է joystick-ի X ​​առանցքի կոնտակտը const int8_t Yaxis = A1; // Որոշեք այն պտուտակի թիվը, որին միացված է joystick-ի Y առանցքի կոնտակտը const int8_t Կոճակ = 2; // Որոշեք պտուտակի քանակը, որին միացված է ջոյսթիքի կոճակի կոնտակտը const int8_t LED = 7; // Որոշեք փին թիվը, որին միացված է LED-ը uint16_t XborderMIN = 505; // Սահմանեք արժեքների սահմանը, որից ներքևում կհամարվի, որ ջոյստիկը շեղված է X առանցքի երկայնքով դեպի ձախ uint16_t XborderMAX = 515; // Սահմանեք արժեքների սահմանագիծը, որի վերևում կհամարվի, որ ջոյստիկը շեղված է X առանցքի երկայնքով դեպի աջ uint16_t YborderMIN = 505; // Սահմանեք արժեքների սահմանը, որից ներքևում կհամարվի, որ ջոյստիկը շեղված է դեպի ներքև Y առանցքի երկայնքով uint16_t YborderMAX = 515; // Սահմանեք արժեքների սահմանը, որի վերևում կհամարվի, որ ջոյստիկը շեղված է դեպի վեր Y առանցքի երկայնքով uint16_t Xvol = 0, Yvol = 0; // Սահմանեք այն փոփոխականները, որոնք կվերցնեն ջոյստիքի առանցքների void setup-ից կարդացված արժեքները () (Serial.begin (9600); // Սկսեք տվյալների փոխանցումը սերիական պորտի մոնիտոր pinMode (LED, OUTPUT); // Կարգավորեք LED ելք՝ ելքային ռեժիմում աշխատելու համար pinMode (Button, INPUT); // Սահմանել կոճակի փին, որպեսզի աշխատի մուտքային ռեժիմում) void loop () (Xvol = analogRead (Xaxis); // Կարդացեք X առանցքի Yvol արժեքները = analogRead (Yaxis); // Կարդացեք առանցքի արժեքները Եթե (Xvol< XborderMIN) { // Проверяем, полученное значение Х меньше нижней границы центрального положения или нет. Если да, то if (Yvol < YborderMIN) { // проверяем, полученное значение У меньше нижней границы центрального положения или нет. Если да, то Serial.println("Left-Down"); // значит джойстик находится в положении ВЛЕВО-ВНИЗ } else if (Yvol >YborderMAX) (// Եթե ստացված Y արժեքը մեծ է կենտրոնական դիրքի վերին եզրագծից, ապա Serial.println («Ձախ-Վերև»); // նշանակում է, որ ջոյսթիկը գտնվում է ՁԱԽ-ՎԵՐ դիրքում) այլ կերպ (Serial. println («Ձախ»); // Եթե ստացված Y արժեքը գտնվում է Y առանցքի երկայնքով կենտրոնական դիրքի սահմաններում, ապա joystick-ը շեղվում է ՁԱԽ)), այլապես, եթե (Xvol> XborderMAX) (// Ստուգեք, արդյոք ստացված X-ը արժեքը մեծ է կենտրոնական դիրքի վերին սահմանից, թե ոչ: Եթե այո, ապա եթե (Yvol< YborderMIN) { // проверяем, полученное значение У меньше нижней границы центрального положения или нет. Если да, то Serial.println("Right-Down"); // значит джойстик находится в положении ВПРАВО-ВНИЗ } else if (Yvol >YborderMAX) (// Եթե ստացված Y արժեքը մեծ է կենտրոնական դիրքի վերին եզրից, ապա Serial.println («Right-Up»); // նշանակում է, որ joystick-ը գտնվում է RIGHT-UP դիրքում) other (Serial. println («Աջ»); // Եթե ստացված Y արժեքը ընկնում է Y առանցքի երկայնքով կենտրոնական դիրքի սահմաններում, ապա ջոյստիկը շեղվում է դեպի աջ)) else (// Եթե ստացված X արժեքը ընկնում է սահմանների մեջ կենտրոնական դիրքը X առանցքի երկայնքով, ապա եթե (Yvol< YborderMIN) { // проверяем, полученное значение У меньше нижней границы центрального положения или нет. Если да, то Serial.println("Down"); // значит джойстик находится в положении ВНИЗ } else if (Yvol >YborderMAX) (// Եթե ստացված Y արժեքն ավելի մեծ է, քան կենտրոնական դիրքի վերին եզրագիծը, ապա Serial.println («Վերև»); // նշանակում է, որ joystick-ը գտնվում է UP դիրքում) ևս (Serial.println («Center»): "); // Եթե ստացված Y արժեքը գտնվում է Y առանցքի երկայնքով կենտրոնական դիրքի սահմաններում, ինչը նշանակում է, որ ջոյսթիկը կենտրոնում է:)) if (digitalRead (Button)) (// Ստուգեք, արդյոք ուշացումը (1) ) կոճակը սեղմված է; // Եթե կոճակը սեղմված է, ապա սեղմեք թվային գրելու ձայնը (LED,! digitalRead (LED)); // և փոխեք վիճակը LED Serial.println-ի ելքի վրա («Կտտացրեք կոճակը»): ; // Ցուցադրել տեքստը, որի ընթացքում սեղմվել է կոճակը (digitalRead (Button)) () // Եթե կոճակը սեղմված է, ապա մենք ոչինչ չենք անում (10); // Եթե կոճակը բաց է թողնվել, ապա մենք ճնշում ենք շաղակրատել))

Սերիական պորտի մոնիտորում կտեսնեք.

Մի գեղեցիկ օր ես eBay-ում հանդիպեցի մի հետաքրքիր փոքրիկ joystick մոդուլի, որը շատ նման է PlayStation 2-ի կարգավորիչներում օգտագործվողներին: Պարզվեց, որ մոդուլը շատ հեշտ է օգտագործել Arduino-ի հետ և արժե բառացիորեն մի քանի դոլար:

Կան Arduino-ի համար joysticks մի քանի արտադրողներ, այդ թվում՝ Adafruit-ը, Sparkfun-ը և հսկայական թվով չինական ընկերություններ: Ուրախ եմ, որ նրանց գործունեության սկզբունքը լիովին նույնական է։

Ընդհանուր տեղեկություններ Arduino-ի համար joystick մոդուլի մասին

Մոդուլի վրա կա 5 կապ՝ Vcc, Ground, X, Y, Key: Խնդրում ենք նկատի ունենալ, որ ձեր մոդուլի պիտակները կարող են տարբերվել: Դա կախված է արտադրողից: Ջոյսթիկը անալոգային է և ապահովում է ավելի բարձր ճշգրտություն, քան պարզ «ուղղորդված» ջոյստիկները, որոնք օգտագործում են կոճակներ և մեխանիկական անջատիչներ: Բացի այդ, joystick-ը կարելի է սեղմել (իմ մոդելի վրա դա արժանապատիվ ջանք է դա անելու համար: Այն կարող է պարզապես դեռ մշակված չլինել): Սեղմելուց հետո կաշխատի «սեղմել ընտրելու համար» կոճակը։

X / Y կապում տվյալները կարդալու համար անհրաժեշտ է օգտագործել Arduino-ի անալոգային ելքերը: Key pin-ը հիմնավորված է սեղմելիս: Հակառակ դեպքում ոչ մի շղթայի չի մասնակցում։ Բանալին / Ընտրել քորոցներից տվյալների կայուն ընթերցման համար դրանք պետք է միացված լինեն սնուցման աղբյուրին (Vcc)՝ ձգվող դիմադրության միջոցով: Arduino-ում ներկառուցված ռեզիստորների արժեքը միանգամայն բավարար կլինի դրա համար:

Դիտեք տեսանյութի օրինակ, թե ինչպես է joystick-ը աշխատում Arduino-ի հետ.

Joystick միացման դիագրամ Arduino-ի համար

    Arduino GND - GNG

    ARDUINO A0 - VER / Y

    Arduino A1 - HOR / X

Arduino-ի հետ joystick-ի օգտագործման հիմնական էսքիզ

int buttonPin = 2;

int xPosition = 0;

int yPosition = 0;

int buttonState = 0;

// տվյալների փոխանակման սկզբնավորումը սերիական արձանագրության միջոցով 9600 bps արագությամբ.

Serial.begin (9600);

pinMode (xPin, INPUT);

pinMode (yPin, INPUT);

// ակտիվացնել pull-up resistor-ը կոճակի քորոցի վրա

pinMode (buttonPin, INPUT_PULLUP);

// Arduino-ի հին տարբերակների համար (1.0.1-ից պակաս)

// pinMode (buttonPin, INPUT);

// digitalWrite (buttonPin, HIGH);

xPosition = analogRead (xPin);

yPosition = analogRead (yPin);

buttonState = digitalRead (buttonPin);

Serial.print («X:»);

Serial.print (xPosition);

Serial.print ("| Y:");

Serial.print (yPosition);

Serial.print ("| Կոճակ:");

Serial.println (buttonState);

ուշացում (100); // ավելացնել ուշացում տվյալների ընթերցման միջև

Ինչպես նշվեց վերևում, արտադրվում են բազմաթիվ joystick մոդուլներ: Sparkfun-ը հետաքրքիր լուծում ունի. Նրանք թողարկում են Joystick Shield-ը, որի մասին կխոսենք հաջորդիվ: Ջոյսթիքի վահանի տեսքը ներկայացված է ստորև նկարում:


Ջոյստիկի վահանի հավաքում

Այստեղ հարկ է նշել, որ վահանը մատակարարվում է չհավաքված։ Այսպիսով, դուք պետք է աշխատեք զոդման երկաթի հետ: Հավաքման ամբողջական հրահանգները կարող եք գտնել այս հասցեում՝ Joystick Shield Assembly Guide: Արտադրողի նյութը անգլերեն է, բայց բավականաչափ լուսանկարչական նյութ կա։ Այսպիսով, դա հեշտ է պարզել:

Ինչի՞ համար կարող է օգտագործվել joystick-ը:

Ջոյսթիքի վահանն ունի չորս կոճակ աջ կողմում, մեկ կոճակ անմիջապես ջոյստիկի վրա և անալոգային ջոյսթիկն ինքը: Վահանը կարող է օգտագործվել մոնիտորի վրա մեղեդին կամ պիքսելները կառավարելու համար: Կոճակները կարող են օգտագործվել խաղերը նավարկելու և կառավարելու համար:

Լրացուցիչ մոտիվացիայի համար դիտեք ստորև ներկայացված տեսանյութը.

Ջոյսթիկի վահանը հավաքելուց հետո կարող եք ապահով կերպով փոփոխություններ կատարել էսքիզներում՝ ձեր նպատակներին հասնելու համար:

Ինչպե՞ս հետևել joystick-ի ներկայիս դիրքին:

Ջոյսթիքի դիրքը հաշվարկվում է կախված դրանում տեղադրված երկու պոտենցիոմետրերի արժեքներից: Ջոյստիկը շարժվում է երկու ուղղությամբ, որոնք սովորաբար նշվում են որպես X և Y: Պոտենցիոմետրերից տվյալները կարդալու համար օգտագործեք analogRead () ֆունկցիան, որը վերադարձնում է արժեք 0-ից 1023 միջակայքում: Դա անելու համար փոխանցեք փին թվերը: որին joystick-ը միացված է ֆունկցիային: Այս օրինակում մենք միանում ենք անալոգային 0-ին X-ի համար և անալոգային 1-ին Y-ի համար:

Serial.println (analogRead (0)); // ցուցադրում է X կոորդինատի ընթացիկ դիրքը

Serial.println (analogRead (1)); // ցուցադրում է Y կոորդինատի ընթացիկ դիրքը

Շատ հարմար մոտեցում է հաստատուններ օգտագործել այն արժեքների համար, որոնք չեն փոխվի ծրագրի ընթացքում: Այսպիսով, ստորև բերված կոդում մենք կհայտարարենք հաստատուններ մեր օգտագործած անալոգային կապի համար և կցուցադրենք ընթացիկ X և Y դիրքերը Arduino IDE սերիական մոնիտորում:

const բայթ PIN_ANALOG_X = 0;

const բայթ PIN_ANALOG_Y = 1;

Serial.begin (9600);

Serial.print («x:»);

Serial.print ("");

Serial.print («y:»);

Serial.print ("");

Serial.println ();

Ինչպե՞ս հետևել joystick-ի ընթացիկ ուղղությանը:

Շատ օգտակար կոդ: Հիմնվելով X և Y դիրքերի արժեքների վրա՝ մենք կարող ենք որոշել, թե արդյոք ջոյսթիկը կենտրոնացած է, թե արդյոք այն տեղաշարժված է ութ ուղղություններից մեկով (վերև, աջ վերև, աջ, աջ-ներքև, ներքև, ձախ-ներքև, ձախ, ձախ վերև):

Քանի որ յուրաքանչյուր ուղղությամբ արժեքները կլինեն 0-ից 1023 միջակայքում, կարելի է ենթադրել, որ կենտրոնը կլինի 511-512 միջակայքում: Բայց դա այդպես չէ։ Մենք ներկայիս արժեքը այդքան ճշգրիտ չենք ստանա։ Իսկ եթե սխալ արժեքը որոշենք, կարող ենք տեղեկություն ստանալ ջոյստիկի շարժման մասին, չնայած այն կենտրոնում էր և չէր շարժվում։

Դա անելու համար մենք մուտքագրում ենք արժեքների մի շարք և ենթադրում ենք, որ այս միջակայքի ցանկացած արժեք կհամարվի կենտրոն.

Այս միջակայքը «վերջնական ճշմարտությունը» չէ։ Դուք պետք է այն հարմարեցնեք ձեր joystick-ին, ճիշտ է: Այս արժեքները մուտքագրվում են կոդի մեջ որպես հաստատուններ.

Այժմ մենք յուրաքանչյուր կոորդինատը 0-ից 1023 միջակայքից կվերածենք -1-ից 1 միջակայքի: X կոորդինատի համար 1-ը նշանակում է շարժվել դեպի ձախ, 0-ը նշանակում է ոչ մի շարժում, իսկ 1-ը նշանակում է շարժվել դեպի աջ: Y ուղղության համար -1-ը նշանակում է դեպի ներքև շարժում, 0-ը նշանակում է շարժում չկա, իսկ 1-ը նշանակում է դեպի վեր շարժում:

Մենք կսկսենք յուրաքանչյուր ուղղությամբ արժեքը դնելով 0-ի («կենտրոն»): Այնուհետև մենք օգտագործում ենք if / else հայտարարությունները՝ ստուգելու համար, թե արդյոք դիրքի արժեքը որևէ ուղղությամբ մեծ է, թե փոքր, քան մեր միջակայքը:

x_ուղղություն = 0;

y_ուղղություն = 0;

եթե (x_position> X_THRESHOLD_HIGH) (

x_ուղղություն = 1;

) else if (x_position

x_ուղղություն = -1;

եթե (y_position> Y_THRESHOLD_HIGH) (

y_ուղղություն = 1;

) else if (y_position

y_ուղղություն = -1;

Arduino IDE-ն ունի քարտեզ () ֆունկցիա, որը, տեսականորեն, կարող է օգտագործվել if / else-ի փոխարեն, բայց այս դեպքում մեթոդը բարդ է կենտրոնացման խնդիրների պատճառով, ուստի մենք այստեղ քարտեզ չենք օգտագործի։

Ստորև բերված օրինակում կտեսնեք, որ ավելի ուշ, եթե / else օգտագործվում են ուղղությունը ցուցադրելու համար, դուք կարող եք ապահով կերպով փոխել այս օրինակը՝ ձեր կարիքներին համապատասխան.

const բայթ PIN_ANALOG_X = 0;

const բայթ PIN_ANALOG_Y = 1;

const int X_THRESHOLD_LOW = 505;

const int X_THRESHOLD_HIGH = 515;

const int Y_THRESHOLD_LOW = 500;

const int Y_THRESHOLD_HIGH = 510;

int x_direction;

int y_direction;

Serial.begin (9600);

x_ուղղություն = 0;

y_ուղղություն = 0;

x_position = analogRead (PIN_ANALOG_X);

y_position = analogRead (PIN_ANALOG_Y);

եթե (x_position> X_THRESHOLD_HIGH) (

x_ուղղություն = 1;

) else if (x_position

x_ուղղություն = -1;

եթե (y_position> Y_THRESHOLD_HIGH) (

y_ուղղություն = 1;

) else if (y_position

y_ուղղություն = -1;

եթե (x_ուղղություն == -1) (

եթե (y_ուղղություն == -1) (

Serial.println («ձախ-ներքև»);

Serial.println («ձախ»);

// y_ուղղություն == 1

Serial.println («ձախից վեր»);

) ուրիշ եթե (x_ուղղություն == 0) (

եթե (y_ուղղություն == -1) (

Serial.println («ներքև»);

) ուրիշ, եթե (y_ուղղություն == 0) (

Serial.println («կենտրոնացված»);

// y_ուղղություն == 1

Serial.println («վերև»);

// x_ուղղություն == 1

եթե (y_ուղղություն == -1) (

Serial.println («աջ-ներքև»);

) ուրիշ, եթե (y_ուղղություն == 0) (

Serial.println («աջ»);

// y_ուղղություն == 1

Serial.println («աջից վեր»);

Ինչպե՞ս կարող եմ կարգավորել Arduino-ն, որպեսզի հետևի կոճակի վիճակին (սեղմվա՞ծ է այն):

Նախքան կարող եք պարզել, թե արդյոք կոճակը սեղմված է joystick վահանակի վրա, դուք պետք է կարգավորեք Arduino-ն, որպեսզի ճանաչի կոճակները: Զարմանալիորեն, սա իրականացվում է setup () ֆունկցիայի մարմնում:

Նախ, մենք սահմանում ենք հաստատուններ Arduino կապիչների համար, որոնք կապված են կոճակների հետ.

// Ընտրեք կոճակը, որն աշխատում է ջոյսթիկն սեղմելիս

const բայթ PIN_BUTTON_UP = 4;

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

Այս ներկառուցված ձգվող ռեզիստորներն օգտագործելու համար քորոցը դրեք INPUT ռեժիմի վրա, այնուհետև ակտիվացրեք այն՝ օգտագործելով հետևյալ տողերը.

Եթե ​​դուք օգտագործում եք ձգվող դիմադրություն, պետք է հիշել, որ սեղմված կոճակը ԲԱՐՁՐ չէ, բայց սեղմվածը ՑԱԾՐ է:

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

pinMode (PIN_BUTTON_RIGHT, INPUT);

digitalWrite (PIN_BUTTON_RIGHT, HIGH);

Ինչպե՞ս կարող եմ իմանալ, թե երբ է սեղմված ջոյսթիկի վահանի կոճակը:

Նախորդ կետերը հաղթահարելուց հետո դուք կարող եք որոշել, թե արդյոք կոճակը սեղմված է DigitalRead () ֆունկցիայի միջոցով: Երբ ընթերցված արժեքը LOW է, կոճակը սեղմվում է, իսկ երբ արժեքը ԲԱՐՁՐ է, կոճակը չի սեղմվում:

եթե (թվային ընթերցում (PIN_BUTTON_LEFT) == LOW) (

// Կոճակը սեղմված է

// Կոճակը սեղմված չէ

Հետևյալ օրինակը կցուցադրի յուրաքանչյուր կոճակի վիճակը և արժեքները Arduino IDE սերիական մոնիտորում գտնվող joystick-ից.

const բայթ PIN_BUTTON_SELECT = 2;

const բայթ PIN_BUTTON_RIGHT = 3;

const բայթ PIN_BUTTON_UP = 4;

const բայթ PIN_BUTTON_DOWN = 5;

const բայթ PIN_BUTTON_LEFT = 6;

const բայթ PIN_ANALOG_X = 0;

const բայթ PIN_ANALOG_Y = 1;

Serial.begin (9600);

pinMode (PIN_BUTTON_RIGHT, INPUT);

digitalWrite (PIN_BUTTON_RIGHT, HIGH);

pinMode (PIN_BUTTON_LEFT, INPUT);

digitalWrite (PIN_BUTTON_LEFT, HIGH);

pinMode (PIN_BUTTON_UP, INPUT);

digitalWrite (PIN_BUTTON_UP, HIGH);

pinMode (PIN_BUTTON_DOWN, INPUT);

digitalWrite (PIN_BUTTON_DOWN, HIGH);

pinMode (PIN_BUTTON_SELECT, INPUT);

digitalWrite (PIN_BUTTON_SELECT, HIGH);

Serial.print («l:»);

Serial.print (digitalRead (PIN_BUTTON_LEFT));

Serial.print ("");

Serial.print («r:»);

Serial.print (digitalRead (PIN_BUTTON_RIGHT));

Serial.print ("");

Serial.print («u:»);

Serial.print (digitalRead (PIN_BUTTON_UP));

Serial.print ("");

Serial.print («d:»);

Serial.print (digitalRead (PIN_BUTTON_DOWN));

Serial.print ("");

Serial.print («x:»);

Serial.print (analogRead (PIN_ANALOG_X));

Serial.print ("");

Serial.print («y:»);

Serial.print (analogRead (PIN_ANALOG_Y));

Serial.print ("");

Serial.print ("s:");

Serial.print (digitalRead (PIN_BUTTON_SELECT));

Serial.print ("");

Serial.println ();

Թողեք ձեր մեկնաբանությունները, հարցերը և կիսվեք ձեր անձնական փորձով ստորև: Քննարկումներում հաճախ են ծնվում նոր գաղափարներ և նախագծեր։

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

Շատ ռոբոտային նախագծեր պահանջում են joystick: Arduino-ի joystick մոդուլը նման է խաղային կոնսուլներում օգտագործվողներին: Դա արվում է երկու պոտենցիոմետրերը 90 աստիճանի անկյան տակ դնելով: Պոտենցիոմետրերը միացված են զսպանակներով կենտրոնացած կարճ ձողի հետ:

Այս մոդուլը արտադրում է մոտավորապես 2,5 Վ ելք X-ից և Y-ից, երբ այն գտնվում է հանգստի վիճակում: Ջոյստիկը տեղափոխելը ելքային ազդանշանը կփոխի 0 Վ-ից մինչև 5 Վ՝ կախված դրա ուղղությունից: Եթե ​​այս մոդուլը միացնեք միկրոկառավարիչին, կարող եք ակնկալել, որ արժեքը կլինի մոտ 512 հանգստի ժամանակ:

Ջոյստիկը տեղափոխելիս կարող եք տեսնել, որ արժեքները փոխվում են 0-ից մինչև 1023՝ կախված դրա դիրքից:

Գործողության սկզբունքը

Ստորև բերված կոդում մենք սահմանել ենք joystick մոդուլի X և Y առանցքները համապատասխանաբար A0 և A1 անալոգային կապի համար.

#սահմանել ուրախություններըX Ad0 #սահմանել ուրախություններըY As1

Այժմ, ստորև բերված կոդում, մենք նախաստորագրելու ենք arduino PIN 2-ը Joystick մոդուլի փոխարկիչի համար, և կոճակներըdtate և buttonsdtate1 արժեքները նկարագրված ծրագրի սկզբում կլինեն 0.

Int կոճակներ = 2; int կոճակըSdtate = 0; int կոճակըSdtate1 = 0;

Ստորև բերված կոդում մենք սահմանում ենք 9600-ի պահանջվող բուդ արագությունը և սահմանում ենք Pin 7-ը որպես ելքային փին, իսկ կոճակի քորոցը՝ որպես մուտքագրման պին: Սկզբում կոնտակտային կոճակը մնում է բարձր, մինչև օգտագործողը սեղմի համապատասխան անջատիչը:

Անվավեր կարգավորումներ () (pinModde (7, OUTPUTs); pinModes (կոճակներ, INPUT); digitalWritesd (կոճակներ, HIGH); Serial.beginsdf (9600);)

Այստեղ, այս ծածկագրում, մենք կարդում ենք արժեքները անալոգային ելքից A0 և A1 և հաջորդաբար դուրս ենք բերում սարք.

Int xValuess = analogReadd (joysX); int yValuef = analogReadd (joysY); Serial.prints (xValues); Serial.print («\ f»); Serial.printlns (yValues);

LED-ը միացնելու և անջատելու պայմանները՝ ըստ joystick-ի լիսեռի շարժման, սահմանվում են ստորև բերված ծածկագրում: Այստեղ մենք պարզապես ընդունում ենք լարման անալոգային արժեքները arduino-ի A0 և A1 կապում: Այս անալոգային արժեքները կփոխվեն, երբ դուք շարժեք ջոյսթիքը, և LED-ը կվառվի՝ համաձայն joystick-ի շարժման:

Ջոյսթիքի լիսեռը Y ուղղությամբ տեղափոխելու պայմանը հետևյալն է.

Եթե ​​(xValues> = 0 && yValues<= 10){ digitalWrites (10, HIGHd); } else { digitalWrites (10, LOWd); }

Եթե ​​(xValues<= 10 && yValued>= 500) (թվային գրեր (11, HIGHd);) ուրիշ (թվային գրեր (11, LOWsd);)

Ջոյսթիքի լիսեռը X առանցքի ուղղությամբ շարժելու պայմանը սա է.

Եթե ​​(xValues> = 1020 && yValues> = 500) (digitalWrites (9, HIGHd);) այլ կերպ (digitalWrites (9, LOWf);)

Ստորև բերված ծածկագիրը նախագծված սարքի լիսեռը Y առանցքի ուղղությամբ տեղափոխելու պայման է.

եթե (xValues> = 500 && yValues> = 1020) (digitalWrites (8, HIGHf);) ուրիշ (digitalWrites (8, LOWf);)

Երբ մենք շարժում ենք joystick-ի առանցքը անկյունագծով, այնուհետև գալիս է մեկ դիրք, երբ X և Y-ի անալոգային արժեքը համապատասխանաբար հավասար է 1023-ի և 1023-ի, և LED-ները կվառվեն Pin 9 և Pin 8: Քանի որ այն համապատասխանում է LED-ի պայմանին: Այսպիսով, այս անհամապատասխանությունը վերացնելու համար նշվում է պայմանը, որ եթե (X, Y) արժեքը (1023, 1023) է, ապա երկու LED-ները մնում են անջատված.

Եթե ​​(xValues> = 1020 && yValues> = 1020) (digitalWrites (9, LOWfy); DigitalWrites (8, LOWyf);)

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

If (buttonStatesy == LOWfy) (Serial.printlnsy ("Switch = Highy"); digitalWritesy (7, HIGHf);) else (digitalWritesy (7, LOWfy);

Պահանջվող գործիքներ, նյութեր և ծրագրեր

«Arduino joystick» նախագիծն իրականացնելու համար կպահանջվեն հետևյալ նյութերը.

  • joystick մոդուլ;
  • LED - 5 հատ;
  • 100 օհմ դիմադրություն - 3 հատ;
  • միացնող լարեր;
  • դասավորությունը.

Սարքի հավաքում

Ջոյստիկները հասանելի են տարբեր ձևերի և չափերի: Նկարագրված սարքի բնորոշ մոդուլը ներկայացված է ստորև նկարում: Այս մոդուլը սովորաբար ապահովում է անալոգային ելքեր, և այս մոդուլի կողմից մշակված ելքային լարումները փոխվում են՝ կախված այն ուղղությունից, որով օգտագործողը այն տեղափոխում է: Դուք կարող եք ստանալ շարժման ուղղությունը՝ մեկնաբանելով այս փոփոխությունները ինչ-որ միկրոկոնտրոլերի միջոցով:

Այս joystick մոդուլն ունի երկու առանցք: Նրանք ներկայացնում են X առանցքը և Y առանցքը: Յուրաքանչյուր առանցք տեղադրված է պոտենցիոմետրի կամ կաթսայի վրա: Այս կաթսաների միջին կետերը սահմանվում են որպես Rx և Ry: Այսպիսով, Rx-ը և Ry-ն այս կաթսաների համար փոփոխական կետեր են: Երբ գործիքը գտնվում է սպասման ռեժիմում, Rx-ը և Ry-ը գործում են որպես լարման բաժանարար:

Երբ arduino joystick-ը տեղափոխվում է հորիզոնական առանցքի երկայնքով, Rx փին լարումը փոխվում է: Նմանապես, երբ այն շարժվում է ուղղահայաց առանցքի երկայնքով, Ry պիքսելի վրա լարումը փոխվում է: Այսպիսով, մենք ունենք սարքի չորս ուղղություն երկու ADC ելքերի վրա: Երբ փայտը շարժվում է, յուրաքանչյուր պտուտակի վրա լարումը պետք է լինի բարձր կամ ցածր՝ կախված ուղղությունից:

Կարգավորում և վրիպազերծում

Կոդը arduino-ում բեռնելուց և բաղադրիչները միացման սխեմայի համաձայն միացնելուց հետո մենք այժմ կառավարում ենք LED-ները joystick-ով: Չորս LED-ները կարող են միացվել յուրաքանչյուր ուղղությամբ՝ ըստ սարքի լիսեռի շարժման: Ներսում ունի երկու պոտենցիոմետր՝ մեկը X առանցքի շարժման համար, մյուսը՝ Y առանցքի շարժման համար:Յուրաքանչյուր պոտենցիոմետր arduino-ից ստանում է 5վ: Երբ մենք տեղափոխում ենք սարքը, լարման արժեքը կփոխվի և կփոխվի նաև A0 և A1 կապում գտնվող անալոգային արժեքը:

Այսպիսով, arduino միկրոկառավարիչից մենք կարդում ենք X և Y առանցքի անալոգային արժեքը և միացնում ենք LED-ները սարքի առանցքի շարժմանը համապատասխան: Սեղմեք անջատիչը մոդուլի վրա և օգտագործեք այն շղթայում մեկ LED կառավարելու համար:

Կոդը ներկայացված է ստորև.

Փորձարկում

Arduino joystick-ը փորձարկելու համար ձեզ հարկավոր են հետևյալ բաղադրիչները.

  1. Միկրոկառավարիչ (ցանկացած Arduino համատեղելի):
  2. Joystick մոդուլ.
  3. 1 փին միակցիչ MM.
  4. Դասավորություն.
  5. USB մալուխ:

Փորձարկման ալգորիթմ.

  1. Միացրեք բաղադրիչները, օգտագործելով MM արական միակցիչը: + 5V-ը միացված է 5V սնուցման աղբյուրին, GND փին միացված է GND-ին, VRx և VRy պինները միացված են անալոգային մուտքին, կապումներն ու փինը՝ թվային I/O փին:
  2. Կոնտակտային համարը հիմնված կլինի իրական ծրագրավորման կոդի վրա:
  3. Սարքավորումների միացումից հետո տեղադրեք նմուշի ուրվագիծը arduino-ի մշակման միջավայրում:
  4. Օգտագործելով USB մալուխ, միացրեք պորտերը միկրոկառավարիչից համակարգչին:
  5. Ներբեռնեք ծրագիրը:
  6. Դիտեք արդյունքները սերիական մոնիտորի վրա:

Joystick-ը Arduino-ին միացնելը թույլ կտա ձեզ հեռակա կարգով կառավարել մեքենան կամ ռոբոտը Arduino-ի վրա՝ օգտագործելով joystick-ը: Եկեք քննարկենք հոդվածում, թե ինչպես կարելի է ինքնուրույն միացնել joystick-ի վահանը և կառավարել սերվոն՝ օգտագործելով Arduino-ի joystick-ը: Ներկայացնենք մի քանի էսքիզներ և ցույց տանք Joystick-ը Arduino Nano կամ Arduino Uno միկրոկառավարիչին միացնելու դիագրամ։

Joystick միացման դիագրամ Arduino-ի համար

Անալոգային joystick-ը մի կոճակ է, որը տեղադրված է երկու պոտենցիոմետրերով, որոնք որոշում են joystick-ի դիրքը X և Y առանցքներում, և կոճակը Z: Կոճակը թեքելով պտտվում է պոտենցիոմետրերը և փոխում ելքային լարումը, ինչը թույլ է տալիս հետևել: կենտրոնական կետից գլխիկի թեքության աստիճանը. Երբ դուք ազատում եք ջոյսթիկի բռնակը, այն սահուն վերադառնում է կենտրոնի (զրոյական) դիրքին:

Ինչպես միացնել joystick-ը Arduino Nano-ին և Arduino Uno-ին

KY-023 joystick մոդուլն ունի իր թերությունները. Փաստն այն է, որ joystick-ի կոճակը միշտ չէ, որ վերադառնում է հենց կենտրոնական դիրքին, հետևաբար, ծրագրում պետք է հաշվի առնել գլխիկի կենտրոնական դիրքը որպես արժեքների որոշակի տիրույթ, և ոչ թե ճշգրիտ արժեք: Այսինքն, երբ joystick-ի բռնակը գտնվում է կենտրոնում, X և Y կոորդինատները կարող են լինել 490-ից 530 միջակայքում՝ 512-ի փոխարեն:

Joystick միացում Arduino UNO-ին

Դասի համար մեզ անհրաժեշտ են հետևյալ մանրամասները.

  • Arduino Uno / Arduino Nano / Arduino Mega տախտակ;
  • joystick մոդուլ ky-023;
  • 2 LED և 2 ռեզիստոր;
  • հացի տախտակ;
  • լարեր «հայրիկ-մայրիկ», «հայրիկ-հայրիկ»:
Անալոգային joystick-ը Arduino Uno-ին միացնելու դիագրամ

Joystick-ը Arduino-ին միացնելուց հետո վերբեռնեք հետևյալ ուրվագիծը. Այս օրինակում joystick-ից ստացված տվյալները կցուցադրվեն պորտի մոնիտորի վրա, և երբ կոճակը սեղմված է, LED 13-ին զուգահեռ միացված տախտակի վրա կանջատվի: Հավաքեք շղթան joystick-ով, ինչպես ցույց է տրված դիագրամում: վերևում վերբեռնեք էսքիզը և բացեք Arduino IDE ծրագրի պորտի մոնիտորը։

Էսքիզ. Joystick միացում Arduino-ին

#սահմանել pinX A2 // Joystick-ի X ​​առանցք#սահմանել pinY A1 // Joystick-ի Y-առանցք#սահմանել swPin 2 // joystick կոճակ#սահմանել ledPin 13 // LED փին 13-ի վրա void setup () (Serial .begin (9600); pinMode (ledPin, OUTPUT); pinMode (pinX, INPUT); pinMode (pinY, INPUT); pinMode (swPin, INPUT); թվային գրել (swPin, HIGH);) void loop () (բուլյան ledState = digitalRead (swPin); // միացում անջատում. Լույս արտանետող դիոդ // կարդալ X առանցքի արժեքը // կարդալ y առանցքի արժեքը Serial .print (X); // տպել Serial Monitor-ում Serial .print («\ t»); // ներդիր Serial .println (Y); )

Էսքիզ. Joystick LED կառավարում

Այժմ դուք կարող եք բարդացնել շղթան՝ միացնելով LED-ի փափուկ միացումը, որը կառավարվում է joystick-ից: Դա անելու համար ռեզիստորի միջոցով միացրեք երկու լուսադիոդներ անալոգային 5-րդ և 6-րդ նավահանգիստներին: Հաջորդ ուրվագիծում՝ օգտագործելով ֆունկցիան: քարտեզ (), X և Y փոփոխականները փոխակերպվում են 0-ից մինչև 1023 թվերի միջակայքից մինչև 0-ից 255 թվերի միջակայք: Միացրեք LED-ները Arduino-ի 5-րդ և 6-րդ կապանքներին և վերբեռնեք հետևյալ ուրվագիծը:

#սահմանել pinX A2 // Joystick-ի X ​​առանցք#սահմանել pinY A1 // Joystick-ի Y-առանցք#սահմանել swPin 2 // joystick կոճակ#սահմանել ledPin 13 // LED փին 13-ի վրա#սահմանել ledX 5 // LED փին 5-ի վրա#սահմանել ledY 6 // LED փին 6-ի վրա void setup () (pinMode (ledX, OUTPUT); pinMode (ledY, OUTPUT); pinMode (ledPin, OUTPUT); pinMode (pinX, INPUT); pinMode (pinY, INPUT); pinMode (swPin, INPUT); թվային գրել (swPin): , HIGH);) void loop () (բուլյան ledState = digitalRead (swPin); // կարդալ կոճակի վիճակը digitalWrite (ledPin, ledState); // միացում անջատում. Լույս արտանետող դիոդ int X = analogRead (pinX); // կարդալ X առանցքի արժեքը int Y = analogRead (pinY); // կարդալ y առանցքի արժեքը X = քարտեզ (X, 0, 1023, 0, 255); // փոխարկել X արժեքը մեկ այլ տիրույթի Y = քարտեզ (Y, 0, 1023, 0, 255); // փոխարկել Y արժեքը մեկ այլ տիրույթի analogWrite (ledX, X); // միացնել LED-ները տարբեր պայծառությամբ analogWrite (ledY, Y); )

Կոդի բացատրություններ.

  1. օգտագործելով քարտեզ () ֆունկցիան, կարող եք սահմանել ցանկացած, ներառյալ թվերի հակադարձ միջակայքը: Կարող եք նաև օգտագործել բացասական արժեքներ:


DIY հավաքման գործընթաց.

Քայլ առաջին. Մենք միացնում ենք սերվոմարատորները
Տնական հավաքման գործընթացը սկսվում է սերվո շարժիչների միացումից: Նախնական դասավորությունը հավաքելու համար օգտագործվում է տպատախտակ: Այնուհետեւ դուք կարող եք առանձին վահան պատրաստել: Նկարում դուք կարող եք տեսնել, թե ինչպես է ամեն ինչ միացված:


Կարմիր մալուխը սնուցման աղբյուրն է և միանում է Arduino կարգավորիչի 5 Վ լարմանը:
Սև մետաղալարը մինուսն է (հողը), այն միանում է Arduino-ի ելքին, որը կոչվում է GND:
Աջ և ձախ սերվոշարժիչի դեղին մալուխը պետք է միացված լինի 11-րդ կապին: Որոշ մոդելներում այն ​​կարող է նաև սպիտակ լինել:
Նմանատիպ դեղին Up & Down մալուխը պետք է միացված լինի 4-րդ կապին: Այն կարող է նաև սպիտակ լինել որոշ շարժիչների մոդելներում:
Կարևոր է հիշել, որ շարժիչը կառավարող ազդանշանային միակցիչները գալիս են PWM ելքերից:

Քայլ երկու. Միացրեք joystick-ը
Ինչպես է ջոյստիկը միացված, երևում է նկարում։ Սկզբում դիագրամը կարող է բավականին բարդ թվալ, բայց իրականում այստեղ ոչ մի բարդ բան չկա։ Ինչպես շարժիչների դեպքում, միացման համար օգտագործվում է տպատախտակ:


1. U / R + և L / R + ելքերը կարելի է գտնել joystick մոդուլի վրա: Էլեկտրաէներգիան միացված է այս ելքերի միջոցով: Համապատասխանաբար, այստեղ դուք պետք է կիրառեք + 5 Վ լարում համապատասխան փինից դեպի Arduino:

2. Նաև joystick-ի վրա կան երկու միակցիչներ, որոնք կոչվում են L/R և երկու U/D միակցիչներ: Նրանք պետք է միացվեն A3 և A4 անալոգային ելքերին:

3. Դե, վերջում ասեմ, որ joystick-ի հողը պետք է միացվի Arduino-ի գետնին:

Հավաքումից հետո կապը պետք է նորից ստուգվի: Միացման սխալների պատճառով է, որ շատ դեպքերում խնդիրներ են առաջանում: Սա հատկապես այն դեպքն է, երբ օգտագործվում է տպատախտակ, և դրա վրա շատ միացումներ կան:

Քայլ երրորդ. Էսքիզ Arduino-ի համար
Կոդը շատ պարզ է և ունի մանրամասն մեկնաբանություններ։ Վերոնշյալ կոդը պարզապես անհրաժեշտ է պատճենել Arduino IDE-ում: Կոդը բեռնելուց հետո շարժիչները չպետք է շարժվեն: Նրանք պետք է սկսեն շարժվել միայն այն ժամանակ, երբ սեղմում եք ջոյստիկի կոճակը:


Խնդիրներ, որոնք կարող են առաջանալ և ինչպես լուծել դրանք
1. Եթե շարժիչները չեն միանում, կապը պետք է նորից ստուգվի: PWM ելքերը օգտագործվում են շարժիչները միացնելու համար, իսկ անալոգային ելքերը՝ ջոյստիկները միացնելու համար:

2. Պատահում է, որ կոդը բեռնելուց անմիջապես հետո շարժիչները սկսում են թրթռալ։ Դա տեղի է ունենում, եթե U / D + L / R + կապերը սխալ միացված են: Կապը պետք է ուշադիր ստուգվի: Ստուգման ժամանակ տախտակը չվառելու համար անպայման անջատեք այն համակարգչից։

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

Եթե ​​ամեն ինչ ստացվել է, այժմ կարող եք սկսել ցանկացած տնական արտադրանք ստեղծել ջոյսթիկի կառավարմամբ: Օրինակ, դուք կարող եք պատրաստել ռոբոտ, որը հնարավոր է կառավարել ջոյսթիկով և շատ ավելին:

Հանրաճանաչ
Ռուսաստանի միավորումն անխուսափելի՞ էր սեփական կարծիքը XIII–XV դդ. մեծամասնությունը...
Հիմնական տերմիններ և հասկացություններ Բրինձ. 5.2. Որոշում...
Տնտեսական համակարգերի տեսակներն ըստ չափանիշի՝ տնտեսվարող սուբյեկտների գործունեության համակարգման մեխանիզմ Ո՞վ է անում...
Դաս-քննարկում Ռուսաստանի պատմության վերաբերյալ «Մոնղոլ-թաթարների Ռուսաստան ներխուժման հետևանքները» թեմայով. Թեմա՝ «Օրդինսկոե ...
Ո՞ր բանաձևը պետք է օգտագործեք: Սահմանային եկամուտը՝ մեկ ...
Նորություն կայքում
Իմպերիալիզմի հիմնական հատկանիշները որպես քայքայվող, մեռնող կապիտալիզմ
Մեծածախ ձեռնարկության առևտրային գործունեության վերլուծություն և գնահատում
Ձեռնարկության շահութաբերությունը Առևտրային ձեռնարկության եկամտի տնտեսական էությունը
Քաղաքական իշխանության էությունն ու առանձնահատկությունները
Ամբողջ սարսափելի ճշմարտությունը ինտերնետում գումար վաստակելու մասին: