A joystick használata az egyik módja az információcserének egy személy és egy Arduino alapú eszköz (számítógép, mikrokontroller) között. Leggyakrabban mechanizmusok vagy robotok irányítására használják. A jól ismert játékvilág analógiájára a joysticket gyakran gamepadnek is nevezik. A gamepad egyszerű és könnyen használható. Napjainkban a joystick-nek számos fajtája létezik a szabadsági fokok számát, az információolvasás gyakoriságát és az alkalmazott technológiát tekintve. Ebben a cikkben megvizsgáljuk a legnépszerűbb lehetőséget, megtanuljuk a joystick vezérlését és csatlakoztatását.

Az analóg bot úgy néz ki, mint egy zsanérra szerelt gomb, két potenciométerrel, amelyek meghatározzák az X és Y tengelyt, valamint egy Z gombbal. A gomb megdöntésével vagy elfordításával egy speciális mozgó érintkezőt forgat, amely megváltoztatja a kimeneti feszültséget. Maga a gamepad rugóval van felszerelve, aminek köszönhetően bármely pozícióból való elengedés után simán visszaáll eredeti központi állapotába. A készülék lehetővé teszi a középső (nulla) ponttól való eltérés mértékének gördülékenyebb nyomon követését.

Joystick csatlakoztatása arduinóhoz

A joystick csatlakoztatása az Arduino Uno-hoz az alábbi ábra szerint történik.

A modul 5 kimenettel rendelkezik - Vcc, Gnd, X, Y és Key (a megnevezések az eszköztől függően változhatnak).

Az X tengelyen lévő adatok az A0 bemenetre, az Y tengely mentén pedig az A1 bemenetre kerülnek kiadásra. A gomb megnyomásának vizuális vezérléséhez csatlakoztathatja a D11 LED-et is. Az áramellátást 5 voltos feszültség biztosítja. A GND érintkező az Arduino kártyán lévő érintkezőhöz csatlakozik. Az SW érintkező bármely digitális érintkezőhöz csatlakoztatható.

Mint látható, a joystick modul csatlakoztatása nem nehéz. Ha az eszköz a csatlakoztatás után nem működik, ellenőrizze, hogy az összes érintkezőt megfelelően csatlakoztatta-e.

A joystick aktuális helyzetének vagy irányának nyomon követése

A joystick valós projektben való használatához egy vázlatot kell írnunk, amely feldolgozza azokat az adatokat, amelyeket a joystick küld a működése során.

A potenciométerek értékétől függően megtudhatja, hogy éppen milyen helyzetben van a készülék. A mozgás a merőleges X és Y tengelyek irányában történik. Az információ a játékvezérlőről olvassa be - 0 és 1023 közötti értékeket jelenít meg. Argumentumként megkapja a csapok számát amelyhez a joystick csatlakozik:

Serial.println(analogRead(A0)); // mutatja az X koordináta pozícióját

Serial.println(analogRead(A1)); // mutatja az Y koordináta pozícióját

A kényelem érdekében konstansok használata javasolt a végső kód csökkentésére és egyszerűsítésére. Az analóg érintkezők állandóvá nyilváníthatók:

const bájt PIN_ANALOG_X = A0; // konstans X koordinátához

const bájt PIN_ANALOG_Y = A1; // konstans Y koordinátához

A mozgás irányának meghatározása a joystickkal

A joystick vezérlés azt jelenti, hogy ismernünk kell a joystick fogantyújának mozgási irányát. Ehhez minden tengelyen adatokat kell fogadnunk és értelmeznünk.

Az X és Y tengely pozícióinak értékéből megállapítható, hogy a joystick középen van-e, vagy történt-e eltolás. Az értékek minden irányban 0 és 1023 között vannak, amint azt korábban tárgyaltuk. Először is az a gondolat jön, hogy a középpont körülbelül 511-512 értékben lesz. Ez a következtetés nem teljesen helytálló, mivel nem lehet abszolút pontos álláspontot meghatározni.

A középső érték helytelen meghatározása hibás információkat eredményezhet a joystick mozgásáról, ha az álló állapotban van. Ehhez válasszon ki egy numerikus tartományt, és feltételesen tételezze fel, hogy bármely érték a központi pont lesz. Az értékeket minden egyes joystick típushoz módosítani kell, de hozzávetőlegesen az 505-518 tartományba esik. A kapott értékek konstansként íródnak a kódba:

const int X_THRESHOLD_LOW = 505;

const int X_THRESHOLD_HIGH = 518;

const int Y_THRESHOLD_LOW = 500;

const int Y_THRESHOLD_HIGH = 510;

A következő lépésben a koordinátákat -1 és 1 közötti tartományba kell transzformálni. X esetén -1 balra mozog, 0 nem mozgás, 1 jobbra. Y-n -1 - lefelé mozgás, 0 - központi érték, 1 - felfelé. Kezdetben minden értéket 0-ra állítunk. Annak ellenőrzésére, hogy a mozgás megtörténik-e, if / else utasításokat használunk.

Buktatók a gamepad működésében

Mint minden eszköz esetében, a joystickok sem hibátlanok. Először is, a rugó jelenléte nem teszi lehetővé, hogy a fogantyú pontosan visszatérjen a középső helyzetbe a mechanikus részek súrlódása miatt. Ez ahhoz a tényhez vezet, hogy programozottan meg kell határoznia a központi pozíciót, vagy inkább azt az értéktartományt, amelyben bármely pont feltételesen középsőnek tekinthető.

A második probléma az úgynevezett holt zónák jelenléte. A két legnagyobb eltérésű szélső értéknek 0 V-nak és a tápfeszültségnek kell lennie. A valóságban ezek az értékek eltérhetnek, mivel az ellenállásváltozás teljes elektromos tartományát nem használják fel. A probléma megoldásához a szélső pontok 1 kΩ és 9 kΩ értékeknek felelhetnek meg.

JoyStick pajzs bővítő tábla

A robotok vagy más mechanizmusok vezérléséhez néha szükség van egy joystick használatára a gombokhoz és a kommunikációhoz. Annak érdekében, hogy ne jöjjön minden alkalommal új dizájnnal, ajánlatos a joystickhez kész arduino bővítőkártyát vásárolni, amelybe az összes szükséges elemet beforrasztják.

Fontolja meg, mi ez a pajzs a világhírű Sparkfun arduino gyártótól. Ez a gamepad jól működik és viszonylag olcsó. A készüléket kissé szétszedve szállítjuk, ezért először össze kell szerelni.

A pajzs több szabványos gombot tartalmaz (4 normál gomb az oldalán és egy választógomb). Modelltől függően bluetooth vagy wifi modulok csatlakoztatására szolgáló csatlakozók adhatók az alaplaphoz. Hagyományosan a tűs és fésűs kimenetekkel külső eszközöket csatlakoztathat.

Következtetés

Az Arduino joystick nélkülözhetetlen dolog a projektjeimben. Az ilyen típusú érzékelőknek köszönhetően kényelmes és modern kezelőszervekkel bővítheti készülékét. Bizonyos helyzetekben szinte lehetetlen joystick nélkül: az Arduino joystick robotok, okosgépek, szervók, zene hangerejének és a monitor háttérvilágításának fényerejének vezérlésére szolgál, navigációként különféle játékokban és sok más projektben.

A kész modul csatlakoztatása nem nehéz, maga a vezérlési vázlat is nagyon hozzáférhető. A joystickot leggyakrabban gombokkal ellátott helyen használják, és vezeték nélküli interfészekkel párosítják, mert gyorsan mozgó eszközökkel szinte lehetetlen vezetéken irányítani a joystickot. Ezért ajánlott a munkához kész pajzsokat használni, amelyekben minden szükséges.

Volt nálam egy arduino nano (egy kiváló minőségű kínai klón a RobotDyn-től). Itt pedig a minap egy szervomotor és egy manipulátor is érkezett Kínából, és volt idő is kicsit kitalálni. Tehát a célom egyszerű volt: csatlakoztass egy arduino nano-t, egy szervomotort és egy joystick-ot, és forgasd el a szervót, amikor elfordítják a joystick-ot. Gyakorlati célokra ez használható például a kamera forgásának szabályozására.

Mint kiderült, ez nem is olyan nehéz. A kapcsolási rajz a következő:

1. Arduino és szervo csatlakozás:

• barna (a szervómon) vezeték - föld (gnd);
• piros vezeték - 5V;
• narancssárga vezeték - 8 tűs.

2. Arduino és joystick kapcsolat:

• gnd - gnd;
• 5v - 5v (3,3V-hoz kötöttem);
• VRX (X koordináták jele) - A1;
• VRY (Y koordináták jele) - A0;
• SW (gombos üzemmód - lenyomva vagy felengedve) - 2 tű.

Összekötjük az összes kínai gyártmányú csodánkat, csatlakoztatjuk az arduinót a számítógéphez, megnyitjuk az Arduino IDE-t, feltöltjük az alábbi vázlatot. A vázlat betöltése után a manipulátort oldalra mozgathatja, a szervó elfordul.

#beleértve //Könyvtár szervomotorral való munkához int xPin = A1; //A1 - a joystick analóg jelének X koordinátái int yPin = A0; //A0 - a joystick analóg jelének Y koordinátái int buttonPin = 2; // Pin gomb módhoz (lenyomva vagy felengedve) int xPosition = 0; // változó a joystick aktuális pozíciójának X tengely mentén történő tárolására int yPosition = 0; // változó a joystick aktuális pozíciójának az Y tengely mentén történő tárolására int buttonState = 0; //a gomb aktuális állapota (lenyomva) int szervoPin = 8; // láb a szervomotor jeleihez Szervo szervo; // Szervo típusú változó int angle = 90; //a szervomotor kezdő forgásszöge int currentXpos = 0; //Aktuális X pozíció void setup() ( pinMode(xPin, INPUT); // Az xPin jel bemeneti jelként van definiálva pinMode(yPin, INPUT); // Az yPin jelű jel bemeneti jelként van definiálva pinMode(buttonPin, INPUT_PULLUP); / / aktiválja a felhúzó ellenállást a gombtűn servo.attach(servoPin); // csatolja a servo.write(angle) tűt; // A szervo elforgatása 90 fokkal ) void loop() ( xPosition = analogRead(xPin); // beolvassa az xPin értékét yPosition = analogRead(yPin); // beolvassa az yPin értékét buttonState = digitalRead(buttonPin); // beolvassa a gomb "állapotát" // ha az xPosition értéke nagyobb, mint 360 if(xPosition > 360) ( szög = szög-10; // csökkenti a szögelforgatást 10 fokkal // ha a szög kisebb, mint 0 if(angle< 0) { angle = 0; //устанавливаем значение угла 0 градусов } } //если xPosition меньше 300 if(xPosition < 300) { angle = angle+10; // увеличиваем угол поворота сервомотора на 10 градусов //если угол поворота больше 180 градусов if(angle >180) ( szög = 180; //állítsa be a szög értékét 180 fokra ) ) // ha a joystick gombot megnyomja if(buttonState == 0) ( szög = 90; //állítsa be a szöget 90 fokra ) szervo.write (szög); // a szervót a kívánt szög késleltetésre fordítja(50); // késleltetés hozzáadása az adatok kiolvasása között )

Amikor a joystick 3,3 V-os tápegységhez volt csatlakoztatva, az X és Y pozíciók alapértelmezett értéke 330 volt (5 V-ra csatlakoztatva az értékek eltérőek lehetnek), hogy ellenőrizze a aktuális leolvasást, a kezdeti értéktől 30 egységnyi eltérést vettem.

Az analóg jelek értékeit nyomon követheti a soros port monitor segítségével (megnyithatja így: eszközök -> portmonitor vagy CTRL + SHIFT + M). Ehhez a függvényben beállít() a következőket kell írnod:

Serial.begin(9600); // adatcsere inicializálása soros protokollon keresztül 9600 bps sebességgel

Funkcióban hurok()írd a következőket:

Serial.print("X: "); Serial.print(xPosition); Serial.print(" | Y: "); Serial.print(yPosition); Serial.print(" | Gomb: "); Serial println(buttonState);

Itt egy videó a történtekről:

Tehát ebben a cikkben megvizsgáljuk a szervomotor és a joystick Arduino Nano-hoz való csatlakoztatásának folyamatát, példát adunk egy vázlatra. A jövőben egy második szervomotor csatlakoztatását tervezem, hogy teljes mértékben kihasználhassam a joystick képességeit, és foroghassak az X és Y tengelyek mentén.

Új cikkek

Egy szövegmező egyszerű megvalósítása legördülő tippekkel (hasonlóan a Yandex és a Google kereséseihez), amikor szöveget ír be C# WPF-ben. Felhasználói vezérlés megvalósítása C#/

Új cikkek

● 18. projekt: Adatok feldolgozása a joystickről. Joystick Pan/Tilt Bracket Control

Ebben a kísérletben egy kéttengelyes analóg joystick csatlakoztatását vizsgáljuk meg az Arduino-hoz.

Szükséges alkatrészek:

A joystick kiválóan alkalmas minden olyan Arduino-alapú eszköz vezérlésére, amely 2D koordinátarendszerben mozog. Az Arduino kártyákhoz vannak analóg joystick modulok, amelyekben van egy X, Y tengely (10 kΩ potenciométer) és egy további gomb - a Z tengely. A joystick segítségével simán és pontosan nyomon követheti a nulla ponttól való eltérés mértékét. Maga a joystick rugós terhelésű, így egy bizonyos helyzetből való elengedés után visszatér a középső állapotba.
A Vcc és a GND érintkezők mindhárom érintkezőcsoport között csatlakoztatva vannak. Így 5 vezeték szükséges a csatlakoztatáshoz: X tengely, Y tengely, Z gomb, Vcc táp és közös GND. A joystickok passzív modulok, és nem vesznek fel energiát az Arduino tábláról. A VERT és HORZ érintkezők az Arduino A0 és A1 analóg bemenetére, a SEL - a D2 digitális bemenetre csatlakoznak. A kapcsolási rajz az ábrán látható. 18.1.

Rizs. 18.1. Bekötési rajz a joystick kártyához az Arduinohoz

Készítsünk vázlatot a joystick adatainak beolvasásához és az értékek Arduino IDE soros port monitorra való kiadásához. A vázlat tartalma a 18.1.

Const int tengelyX=A0 // A0-hoz kapcsolt X tengely const int tengelyY=A1 // Az A1-hez csatlakoztatott Y tengely const int tengelyZ=2 // Z tengely (joystick gomb) a D2-hez csatlakoztatva int valX, valY, valZ = 0 ; void setup()( pinMode(tengely_Z, INPUT_PULLUP); // konfigurálja a D2-t INPUT-ként a felvétellel // felhúzó ellenállás a processzoron belül Serial.begin(9600 ); ) void loop()( valX = analógRead(tengelyX); // az X tengely értéke valY = analógRead(axisY); // az Y tengely értéke valZ = 1 -digitalRead(axisZ); // Z tengely értéke (gomb) // értékeket ad ki a monitorra Serial.print("X:" );Serial.print(valX, DEC); Serial.print(" | Y:" );Serial.print(valY, DEC) Serial.print(" | Z: " );Serial.println(valZ, DEC); késleltetés(500 ); // szünet a következő adatolvasás előtt }
Csatlakozási sorrend:

1. Csatlakoztatjuk a joystickot az Arduino kártyához az ábra szerinti diagramnak megfelelően. 18.2.
2. Töltse be a vázlatot a 18.1 listából az Arduino táblára.
3. Az Arduino IDE soros port monitorján megnézzük az eltolási értékeket az X és Y tengelyen, valamint a gomb állapotát (Z tengely).

Rizs. 18.2. Joystick tábla és Pan/Title Brack bekötési rajz az Arduino számára

Hozzunk létre egy érthetőbb példát a joystick használatával egy Pan/Titl Bracket helyzetének szabályozására két szervóval, amelyre például egy kamerát helyezhetünk, és a kamera helyzetét balra/jobbra és le/felfelé változtathatjuk. a joystick. Ennek a kísérletnek a kapcsolási rajza az ábrán látható. 18.2.
A joystickot az X tengely mentén mozgatva az alsó szervo forgását (balra/jobbra), a joystickot az Y tengely mentén mozgatva a felső szervo forgását (fel/le) fogjuk szabályozni. A joystick átlagos semleges helyzete az egyes tengelyeken (512 analóg értékkel) megfelel a szervo 90°-os elfordulási szögének. A vázlat tartalma a 18.2-es listában látható.

#tartalmazza // a Szervo könyvtár összekapcsolása Szervo szervo1, szervo2; const int pinServo1=8 ; // Csap 1 szervó csatlakoztatásához const int pinServo2=9 ; // Pin 2 szervó csatlakoztatásához // változók a szervók elfordulási szögeinek tárolására int szögServo1,angleServo2 = 0 ; const int tengelyX=A0; // A0-hoz kapcsolt X tengely const int tengelyY=A1; // Az A1-hez csatlakoztatott Y tengely int valX, valY = 0; // változók a tengelyértékek tárolására void setup(){ // a szervo1 változó csatlakoztatása a pinServo1 lábhoz szervo1.attach(pinServo1); // a szervo2 változó csatlakoztatása a pinServo2 lábhoz Servo2.attach(pinServo2); ) void loop()( valX = analógRead(tengelyX); // X tengely értéke valY = analógRead(tengelyY); // Y tengely értéke // az értéket 0-180 intervallumra skálázza angleServo1=térkép (valX,0 ,1023 ,0 ,180 ); angleServo2=térkép (valY,0 ,1023 ,0 ,180 ); // fordítsa a szervókat a vett szögbe szervo1.write(angleServo1); szervo2.write(angleServo2); késleltetés(15); // szünet várni, amíg a szervók befordulnak }
Csatlakozási sorrend:

1. Szerelje össze a Pan/Title Bracket és a szervókat.
2. Csatlakoztatjuk a joystickot és a Pan / Title Bracket-et az Arduino kártyához az ábrán látható diagramnak megfelelően. 18.2.
3. Töltse be a 18.2-es listából a vázlatot az Arduino táblára.
4. Szabályozza a Pan/Title Brack helyzetét a joystickot az X és Y tengely mentén mozgatva.

Program listák

Szokásos péntek volt, semmi bajt nem sejtett...

De a "kell tenni valamit" féreg már megkezdte a munkáját. A cikk elolvasása után eszembe jutott, hogy egy Segov gamepad hevert a szemeteimben 15 évig, ha nem több. Azzal a határozott szándékkal vettem, hogy készítsek egy gamepadet az AVR processzorra (akkor még nem hallottam az arduino-ról, de csináltam néhány kisebb projektet az AVR-en).

Az MSX-ről szóló cikk még jobban megerősítette szándékomat, és pénteken úgy döntöttem - megcsinálom!

Egy szétszedett Segov gamepadot húztak ki a kukákból a fehér fénybe. Megdöbbenésemre komplett volt (na jó, kivéve a vágott pályákat és a hiányzó eredeti vezérlőt), csak 2 csavar hiányzott.

Úgy döntöttem, hogy a Beetle-t használom kontrollernek, mivel egyszer rendeltem, de még nem próbáltam, és a "kis portok száma" miatt nem igazán tetszett.

Aztán csalódás várt rám - 6 port, 10 gomb. A bánatomnak nem volt határa, de az agyam így is talált megoldást, kezdetnek úgy döntöttem, megpróbálok összerakni egy 2 gomb prototípusát, mivel úgy döntöttem, hogy bevetek egy trükköt diódával 10 gomb lekérdezéséhez 6 tűvel. Szinte ihletett, leültem ellenőrizni... És akkor történt a következő baj - több mint 10 gomb van a joystickon! Általában ez volt az a pillanat, amikor meg kellett nézni a dokumentációt, bár sok ötlet volt - például forrasztás (igen, az én forrasztópákammal, ami a mikroáramkör egyik oldalán szinte az összes lábát lefedi), ill. megvilágosodást keresni az interneten.
A dokumentáció egyértelműen azt írta, hogy a Bogárnak valójában 10 portja van, nem 6, amitől unalmassá vált a további folyamat (ahogy én gondoltam). (8 tű használata lehetővé teszi 2 * 6 = 12 gomb lekérdezését, amire szükségem volt)

A bekötési rajz egy 6 x 2-es mátrix, mert az eredeti kártya úgy volt bekötve, ahogy nekem kényelmes. (Egyébként az előző feldolgozás során a számokat levágták a billentyűzetvezérlő csatlakoztatásához, vissza kellett állítani, csúnya lett)

A kapott játékvezérlő séma:

Miután gyorsan hozzáadtam egy példát, megbizonyosodtam arról, hogy nem működik ... Nem értem ?! A példa a legegyszerűbb. Gondolkodás után rájöttem, hogy a digitális tűből hiányzik az az ellenállás, amit a gumi vezető gombok adnak, kicsit módosítottam az áramkört, most az analóg jelet olvassa be és hasonlítja össze a maximum felével. Újraforrasztom az érintkezőket, átírom a programot és ... semmi sem működik. A vezérlő nincs meghatározva, minden eltűnt. A kód ellenőrizve, és újraellenőrizve, mindennek működnie kell! A vezérlő pedig egyikben sem látszik. Csökken a motiváció, szünetet tartunk.

Egy idő után, miután sikertelenül játszottam a Bogárral, ez van, a forrasztópákámmal megöltem a kontrollert, sajnálattal kiveszem a ládákból az Arduino Micro-t, villog a firmware és megint csend! Világossá válik, hogy valami nincs rendben a kóddal, végül találok egy banális okot - végtelen hurok a hurokban (), kijavítom, de nem tudom összevarrni! Kiderült, hogy a probléma, amikor a vezérlő nem látható, megoldódik a reset megnyomásával villogás közben (vagy az én esetemben a tűk zárásával)

Az eredmény egy Segov gamepad lett, tesztelt, működőképes, boldog vagyok: játszottam a Metal Gear-rel, a Felix The Cat-el, a Super Marióval.

P.S. "LED trükk". Természetesen nem szükséges LED-et használni, egy közönséges dióda jobban megfelel, a lényeg egyszerű, két következtetés helyett használjon egyet, amely 2 diódán keresztül különböző gombokhoz van csatlakoztatva:

Ez egy adatbeviteli modul. Használható robotok, manipulátorok, gépek, különféle modellek (autók, tankok, repülők, helikopterek, quadrocopterek, csónakok stb.) irányítására, valamint játékkonzolok készítésére, menüelemek kiválasztására a kijelzőkön és indikátorokon, értékek megadására, stb. A joystick nem csak mozgatható az X és Y tengely mentén, hanem meg is nyomható.

Videó:

Leírás:

• Tápfeszültség: 5 V / 3,3 V (mindkét feszültség az elfogadható tartományon belül van).
• A jelenlegi felhasználás:< 10 мА
• Méretek: 30x30 mm

A "Trema" vonal minden modulja ugyanabban a formátumban készül

Kapcsolat:

• A modul "X" és "Y" kimenetei az Arduino bármely analóg bemenetéhez csatlakoznak. Az ezekből a tűkből leolvasott értékek nőnek, ahogy a joystickot balról jobbra és alulról felfelé mozgatják.
• A "K" érintkező digitális, és bármely Arduino tűhöz csatlakozik. Normál állapotban a logikai „0” szintje van rajta, és a joystickot megnyomva logikai „1”-re változik.
• A „V” és „G” érintkezők tápcsatlakozók.

A modult a helyzettől függően 3 módon kényelmes csatlakoztatni:

1. módszer: Vezetékes hurok és Piranha UNO segítségével

Az "Apa - Anya" vezetékek segítségével közvetlenül csatlakozunk a Piranha UNO vezérlőhöz

2. módszer: A Trema Set Shield használata

A modul a Trema Set Shield bármelyik analóg bemenetéhez csatlakoztatható.

3. módszer: Vezetékes kábel és árnyékolás használata

5 eres kábel használatával a Trema Shield, Trema-Power Shield, Motor Shield, Trema Shield NANO stb.

Táplálás:

A bemeneti feszültség 5 V vagy 3,3 V DC, a Vcc (V) és a GND (G) érintkezőkre kapcsolva.

Bővebben a modulról:

A modul adatait két potenciométer és egy, a joystick karjához mechanikusan csatlakoztatott tapintógomb olvassa le. A gomb a Vcc tápegységhez és a „K” kimenethez csatlakozik, amely egy ellenálláson keresztül a GND-re van nyomva. Ezért a "K" kimeneten csak két állapot állítható be: logikai "0" (gomb felengedve) vagy "1" (gomb lenyomva). Az "X" és "Y" koordináta érintkezők a modul analóg kimenetei, potenciométerekhez vannak csatlakoztatva, így a botkormány balról jobbra és alulról felfelé történő mozgatásakor az ezen érintkezők és a GND között felvett feszültség nő.

Példák:

Érzékelje a joystick helyzetét, és kapcsolja be a LED-et a gombnyomásra

const int8_t Xaxis = A0; // Határozza meg a pin számot, amelyhez a joystick X tengely lába csatlakozik const int8_t Yaxis = A1; // Határozza meg a pin számot, amelyhez a joystick Y tengelyének érintkezője csatlakozik const int8_t Button = 2; // Határozza meg a pin számot, amelyhez a joystick gomb érintkezője csatlakozik const int8_t LED = 7; // Határozza meg a PIN-kódot, amelyhez a LED csatlakozik uint16_t XborderMIN = 505; // Állítsa be az értékek határát, ALÁ, amely úgy tekintendő, hogy a joystick az X tengely mentén balra van eltérítve uint16_t XborderMAX = 515; // Állítsuk be az értékek határát, FELÜL a joystick az X tengely mentén jobbra eltérül uint16_t YborderMIN = 505; // Állítsa be az értékek határát, ALATT a rendszer úgy tekinti, hogy a joystick az Y tengely mentén lefelé elhajlik uint16_t YborderMAX = 515; // Állítsa be az értékek határát, amely felett a joystick az Y tengely mentén felfelé billent uint16_t Xvol = 0, Yvol = 0; // Állítsa be azokat a változókat, amelyek a joystick tengelyeiről olvasott értékeket vesznek fel void setup() ( Serial.begin(9600); // Adatátvitel kezdeményezése a soros port monitorra pinMode(LED, OUTPUT); // A LED kimenet beállítása kimeneti módban való működéshez pinMode(Button, INPUT); // A gomb tűjének beállítása beviteli módban való működéshez ) void loop() ( Xvol = analógRead(Xaxis); // X-tengely olvasása Yvol = analógRead(Yaxis); // Tengely olvasása if (Xvol< XborderMIN) { // Проверяем, полученное значение Х меньше нижней границы центрального положения или нет. Если да, то if (Yvol < YborderMIN) { // проверяем, полученное значение У меньше нижней границы центрального положения или нет. Если да, то Serial.println("Left-Down"); // значит джойстик находится в положении ВЛЕВО-ВНИЗ } else if (Yvol >YborderMAX) ( // Ha a kapott Y érték nagyobb, mint a középső pozíció felső határa, akkor Serial.println("Left-Up"); // azt jelenti, hogy a joystick LEFT-UP pozícióban van ) else ( Serial. println("Left"); // Ha a vett Y érték a középső pozíció határain belül van az Y tengely mentén, akkor a joystick BALRA van eltérítve ) ) else if (Xvol > XborderMAX) ( // Ellenőrizze, hogy a a kapott X érték nagyobb, mint a középső pozíció felső határa, vagy sem. Ha igen, akkor ha (Yvol< YborderMIN) { // проверяем, полученное значение У меньше нижней границы центрального положения или нет. Если да, то Serial.println("Right-Down"); // значит джойстик находится в положении ВПРАВО-ВНИЗ } else if (Yvol >YborderMAX) ( // Ha a kapott Y érték nagyobb, mint a középső pozíció felső határa, akkor Serial.println("Right-Up"); // azt jelenti, hogy a joystick RIGHT-UP pozícióban van ) else ( Serial. println("Jobbra"); // Ha Y vett értéke az Y tengely mentén lévő középső pozíció határain belül van, akkor a joystick JOBBRA van eltérítve ) ) else ( // Ha az X vett értéke belül van a középpont határai az X tengely mentén, akkor ha (Yvol< YborderMIN) { // проверяем, полученное значение У меньше нижней границы центрального положения или нет. Если да, то Serial.println("Down"); // значит джойстик находится в положении ВНИЗ } else if (Yvol >YborderMAX) ( // Ha a kapott Y érték nagyobb, mint a középső pozíció felső határa, akkor Serial.println("Fel"); // azt jelenti, hogy a joystick FEL pozícióban van ) else ( Serial.println("Center "); // Ha az Y vett értéke a középső pozíció határain belül van az Y tengely mentén, ami azt jelenti, hogy a joystick középen van. ) ) if (digitalRead(Button)) ( // Ellenőrizze, hogy a gomb pressed delay(1); // Ha a gombot megnyomta, akkor elnyomja a visszapattanást digitalWrite(LED, !digitalRead(LED)); // és módosítsa a LED kimeneti állapotát Serial. println("Button click!"); // Nyomtassa ki azt a szöveget, amely alatt a gombot megnyomták (digitalRead(Button)) () // Ha a gombot lenyomva tartja, akkor ne tegyen semmit késleltetés(10); // Ha a gombot elengedi, akkor nyomja el a visszapattanást ) )

A soros port monitoron látni fogja.