- MPU6050 giroszkópos és gyorsulásmérő érzékelő
- Flex Sensor
- A 3D nyomtatott robot ARM előkészítése:
- Szükséges alkatrészek:
- Kördiagramm:
- MPU6050 és Flex Sensor felszerelése kesztyűhöz
- Arduino Nano programozása robotkarhoz
- Gesztus által vezérelt robotkar működése Arduino segítségével
A robotfegyverek az egyik lenyűgöző mérnöki alkotás, és mindig lenyűgöző nézni, ahogy ezek a dolgok megdőlnek és pásztáznak, hogy összetett dolgokat végezzenek, akárcsak az emberi kar. Ezek a robotkarok általában megtalálhatók a futószalag iparaiban, amelyek intenzív mechanikai munkát végeznek, például hegesztést, fúrást, festést stb., A közelmúltban fejlett, nagy pontosságú robotkarokat is fejlesztik a komplex műtéti műveletek végrehajtására. Korábban 3D-ben kinyomtattunk egy robotkarot, és elkészítettünk egy DIY Pick and Place robotkarot az ARM7 mikrokontroller segítségével. Ismét ugyanazt a 3D nyomtatott robotkart használjuk kézmozdulattal vezérelt robot ARM készítésére Arduino Nano, MPU6050 giroszkóp és flex érzékelő segítségével.
Ezt a 3D nyomtatott robotkar helyzetet egy kézikesztyű vezérli, amelyet MPU6050 giroszkóppal és flex érzékelővel rögzítenek. A Flex érzékelőt a robotkar markolatszervójának vezérléséhez, az MPU6050-et pedig a robot mozgatásához használják X és Y tengelyben. Ha még nincs nyomtatója, akkor egyszerű kartonnal is felépítheti a karját, ahogyan azt Arduino robotkar projektünkhöz építettük. Inspirációként hivatkozhat a Record and Play robotkarra is, amelyet korábban Arduino segítségével építettünk.
Mielőtt részleteznénk, először ismerkedjünk meg az MPU6050 érzékelővel és a flex érzékelővel.
MPU6050 giroszkópos és gyorsulásmérő érzékelő
Az MPU6050 mikromechanikus rendszerek (MEMS) technológián alapul. Ez az érzékelő 3 tengelyes gyorsulásmérővel, 3 tengelyes giroszkóppal és beépített hőmérséklet-érzékelővel rendelkezik. Használható olyan paraméterek mérésére, mint a gyorsulás, a sebesség, a tájolás, az elmozdulás stb. Korábban összekötöttük az MPU6050-et az Arduino és a Raspberry pi készülékkel, és néhány olyan projektet is létrehoztunk, például - Önkiegyensúlyozó robot, Arduino Digital Protractor és Arduino Inclinometer.
Az MPU6050 érzékelő jellemzői:
- Kommunikáció: I2C protokoll konfigurálható I2C címmel
- Bemeneti tápegység: 3-5 V
- A beépített 16 bites ADC nagy pontosságot biztosít
- A beépített DMP nagy számítási teljesítményt nyújt
- Használható más I2C eszközökkel való összeköttetéshez, például magnetométerhez
- Beépített hőmérséklet-érzékelő
Az MPU6050 kitűnő adatai:
| Pin | Használat |
| Vcc | Tápellátást biztosít a modul számára, + 3V és + 5V között lehet. Általában + 5 V-ot használnak |
| Talaj | Csatlakoztatva a rendszer földjéhez |
| Soros óra (SCL) | Órapulzus biztosítására szolgál az I2C kommunikációhoz |
| Soros adatok (SDA) | Adatok továbbítására szolgál I2C kommunikáción keresztül |
| Kiegészítő soros adatok (XDA) | Használható más I2C modulok interfészéhez az MPU6050-vel |
| Segédsoros óra (XCL) | Használható más I2C modulok interfészéhez az MPU6050-vel |
| AD0 | Ha egynél több MPU6050-et használ egyetlen MCU, akkor ez a tű felhasználható a cím megváltoztatására |
| Megszakítás (INT) | Megszakító tű, jelezve, hogy rendelkezésre állnak adatok az MCU számára az olvasáshoz |
Flex Sensor
A Flex Sensor nem más, mint változtatható ellenállás. A hajlító érzékelő ellenállása az érzékelő hajlításakor változik. Rendszerint kétféle méretben kaphatók: 2,2 hüvelyk és 4,5 hüvelyk.
Miért használunk flex szenzorokat a projektünkben?
Ebben a kézmozdulattal vezérelt robotkarban egy flex érzékelőt használnak a robotkar megfogójának irányítására. Amikor a kézikesztyű flex érzékelője meghajlik, a megfogóhoz rögzített szervomotor forog és a megfogó kinyílik.
A Flex szenzorok számos alkalmazásban hasznosak lehetnek, és kevés projektet építettünk a Flex szenzor, például játékvezérlő, Tone generátor stb.
A 3D nyomtatott robot ARM előkészítése:
Az oktatóanyagban használt 3D nyomtatott robotkar az EEZYbotARM által a Thingiverse-ben elérhető terv alapján készült. A 3D nyomtatott robotkar elkészítésének teljes eljárása és a videóval való összeszerelési részlet a fent megosztott Thingiverse linken található.
Fent a 3D nyomtatott robotkarom képe látható, miután összeszereltem 4 szervomotorral.
Szükséges alkatrészek:
- Arduino Nano
- Flex Sensor
- 10k ellenállás
- MPU6050
- Kesztyű
- Vezetékek csatlakoztatása
- Kenyérlemez
Kördiagramm:
A következő kép az Arduino alapú gesztusvezérelt robotkar áramköri csatlakozásait mutatja .
Áramköri kapcsolat az MPU6050 és az Arduino Nano között:
|
MPU6050 |
Arduino Nano |
|
VCC |
+ 5V |
|
GND |
GND |
|
SDA |
A4 |
|
SCL |
A5 |
Áramköri kapcsolat a szervomotorok és az Arduino Nano között:
|
Arduino Nano |
SZERVÓMOTOR |
Adapter |
|
D2 |
1. szervo narancs (PWM tű) |
- |
|
D3 |
Servo 2 Narancs (PWM csap) |
- |
|
D4 |
Servo 3 narancs (PWM csap) |
- |
|
D5 |
Servo 4 narancs (PWM csap) |
- |
|
GND |
Szervó 1,2,3,4 Barna (GND csap) |
GND |
|
- |
Szervó 1,2,3,4 Piros (+ 5 V tű) |
+ 5V |
A flex érzékelő két csapot tartalmaz. Nem tartalmaz polarizált terminálokat. Tehát az egyik P1 tű az Arduino Nano analóg A0 tűjéhez van csatlakoztatva 10k felhúzási ellenállással, és a két P2 tű az Arduino felé van földelve.
MPU6050 és Flex Sensor felszerelése kesztyűhöz
Felszereltük az MPU6050-et és a Flex Sensort egy kézikesztyűre. Itt vezetékes kapcsolatot használnak a kesztyű és a robotkar összekapcsolására, de vezeték nélküli kapcsolatba hozható RF vagy Bluetooth kapcsolat használatával.
Minden csatlakozás után a gesztusvezérelt robotkar végleges beállítása úgy néz ki, mint az alábbi kép:
Arduino Nano programozása robotkarhoz
Szokás szerint a teljes kód és egy működő videó az oktatóanyag végén található. Itt néhány fontos kódsor kerül ismertetésre.
1. Először csatolja a szükséges könyvtárfájlokat. A Wire.h könyvtárat I2C kommunikációra használják az Arduino Nano & MPU6050 és a servo.h között a szervomotor vezérléséhez.
#include
2. Ezután deklaráljuk az osztály szervo objektumait. Négy szervomotor használatával négy objektum jön létre, például a szervo_1, a szervo_2, a szervo_3, a szervo_4.
Servo szervo_1; Servo szervo_2; Servo szervo_3; Servo szervo_4;
3. Ezután deklaráljuk az MPU6050 I2C címét és a használandó változókat.
const int MPU_addr = 0x68; // MPU6050 I2C Cím int16_t tengely_X, tengely_Y, tengely_Z; int minVal = 265; int maxVal = 402; kettős x; kettős y; kettős Z;
4. Ezután a void beállításban 9600 átviteli sebességet állítunk be a soros kommunikációhoz.
Serial.begin (9600);
És létrejön az I2C kommunikáció az Arduino Nano és az MPU6050 között:
Wire.begin (); // Inicializálja az I2C kommunikációs vezetéket.beginTransmission (MPU_addr); // Kommunikáció megkezdése az MPU6050 Wire.write (0x6B); // Írja a 6B regisztrációhoz Wire.write (0); // 0-t ír a 6B regisztrációba a Wire.endTransmission visszaállításához (true); // Befejezi az I2C átvitelét
A szervomotor csatlakozásához négy PWM csap is meg van határozva.
szervo_1.attach (2); // Forward / Reverse_Motor servo_2.attach (3); // Fel / Le_Motor szervo_3.attach (4); // Gripper_Motor szervo_4.attach (5); // Bal / Jobb_Motor
5. Ezután a void loop funkcióban ismét hozza létre az I2C kapcsolatot az MPU6050 és az Arduino Nano között, majd kezdje el olvasni az X, Y, Z-tengely adatait az MPU6050 regiszteréből, és tárolja azokat a megfelelő változókban.
Wire.beginTransmission (MPU_addr); Wire.write (0x3B); // Kezdés regsiter 0x3B Wire.endTransmission (hamis); Wire.requestFrom (MPU_addr, 14, true); // Olvassa el a 14 regisztert tengely_X = Wire.read () << 8-Wire.read (); tengely_Y = Wire.read () << 8-Wire.read (); tengely_Z = Wire.read () << 8-Wire.read ();
Ezt követően térképezze fel az MPU6050 érzékelő tengelyadatainak min és max értékét -90 és 90 között.
int xAng = térkép (tengely_X, minVal, maxVal, -90,90); int yAng = térkép (tengely_Y, minVal, maxVal, -90,90); int zAng = térkép (tengely_Z, minVal, maxVal, -90,90);
Ezután a következő képlettel számítsa ki az x, y, z értékeket 0 és 360 között.
x = RAD_TO_DEG * (atan2 (-yAng, -zAng) + PI); y = RAD_TO_DEG * (atan2 (-xAng, -zAng) + PI); z = RAD_TO_DEG * (atan2 (-yAng, -xAng) + PI);
Ezután olvassa el az flexibilis érzékelő analóg kimeneti adatait az Arduino Nano A0 érintkezőjénél, és a flex érzékelő digitális értékének megfelelően állítsa be a megfogó szervo szögét. Tehát, ha a flex érzékelő adatai nagyobbak 750-nél, akkor a megfogó szervomotorjának szöge 0 fok, és ha 750-nél kisebb, 180 fok.
int megfogó; int flex_sensorip = analogRead (A0); if (flex_sensorip> 750) { megfogó = 0; } else { megfogó = 180; } szervo_3.write (megfogó);
Ezután az MPU6050 mozgása az X tengelyen 0-tól 60- ig 0 és 90 fok között van feltérképezve a szervomotor előre / hátra mozgása a robotkar számára.
if (x> = 0 && x <= 60) { int mov1 = térkép (x, 0,60,0,90); Serial.print ("Mozgás F / R =" -ben); Soros nyomtatás (mov1); Soros.println ((char) 176); szervo_1.write (mov1); }
És az MPU6050 mozgása az X-tengelyen 250-ről 360-ra 0 és 90 fok között van feltérképezve a szervomotor FEL / LE mozgás robotkarjára.
else if (x> = 300 && x <= 360) { int mov2 = térkép (x, 360,250,0,90); Serial.print ("Mozgás fel / le ="); Soros.nyomtatás (mov2); Soros.println ((char) 176); szervo_2.write (mov2); }
Az MPU6050 mozgása az Y tengelyen 0-tól 60- ig 90 és 180 fok között van feltérképezve a szervomotor robotkar bal mozgására.
if (y> = 0 && y <= 60) { int mov3 = térkép (y, 0,60,90,180); Serial.print ("Mozgás balra ="); Soros.nyomtatás (mov3); Soros.println ((char) 176); szervo_4.write (mov3); }
Az MPU6050 mozgása az Y-tengelyben 300-ról 360-ra 0 és 90 fok között van feltérképezve a szervomotor robotkar jobb mozgására.
else if (y> = 300 && y <= 360) { int mov3 = térkép (y, 360,300,90,0); Serial.print ("Mozgás jobbra ="); Soros.nyomtatás (mov3); Soros.println ((char) 176); szervo_4.write (mov3); }
Gesztus által vezérelt robotkar működése Arduino segítségével
Végül töltse fel a kódot az Arduino Nano-ra, és viselje az MPU6050 & Flex Sensor készülékkel felszerelt kézikesztyűt.
1. Most mozgassa a kezét lefelé a robotkar előre mozgatásához, és haladjon felfelé a robotkar felfele mozgatásához.
2. Ezután döntse meg a kezét balra vagy jobbra a robotkar balra vagy jobbra fordításához.
3. Hajlítsa meg a kesztyű ujjával rögzített hajlékony kábelt a megfogó kinyitásához, majd engedje el, hogy bezárja.
A teljes munkát az alábbi videó szemlélteti.