- Senzor gyroskopického a akcelerometra MPU6050
- Flex senzor
- Príprava 3D tlačeného robotického ramena:
- Požadované komponenty:
- Schéma zapojenia:
- Montáž senzora MPU6050 a Flex na rukavice
- Programovanie Arduino Nano pre robotické rameno
- Fungovanie robotického ramena ovládaného gestami pomocou Arduina
Robotické zbrane sú jedným z fascinujúcich inžinierskych výtvorov a je vždy fascinujúce sledovať, ako sa tieto veci nakláňajú a otáčajú, aby sa dokončili zložité veci, ako by to urobila ľudská ruka. Tieto robotické ramená sa bežne vyskytujú v priemyselných odvetviach na montážnej linke vykonávajúcich intenzívne mechanické práce, ako sú zváranie, vŕtanie, lakovanie atď., V poslednej dobe sa vyvíjajú aj pokročilé robotické ramená s vysokou presnosťou na vykonávanie zložitých chirurgických operácií. Predtým sme 3D vytlačili robotické rameno a vytvorili sme robotické rameno DIY Pick and Place pomocou mikrokontroléra ARM7. Znovu použijeme rovnaké 3D tlačené robotické rameno na výrobu robotického ARM ovládaného gestom ruky pomocou Arduino Nano, gyroskopu MPU6050 a snímača ohybu.
Táto poloha robotického ramena vytlačená pomocou 3D sa ovláda cez ručné rukavice pripevnené k gyroskopu MPU6050 a k ohybnému senzoru. Senzor Flex sa používa na ovládanie serva chapadla Robotic Arm a MPU6050 sa používa na pohyb robotického robota v osi X a Y. Ak nemáte tlačiareň, môžete si vytvoriť ruku pomocou jednoduchej lepenky, tak ako sme ju vytvorili pre náš projekt robotického ramena Arduino. Pre inšpiráciu si môžete tiež pozrieť Robotické rameno Record and Play, ktoré sme vytvorili skôr pomocou Arduina.
Predtým, ako pôjdeme do podrobností, najskôr sa poďme dozvedieť niečo o snímačoch MPU6050 a Flex.
Senzor gyroskopického a akcelerometra MPU6050
MPU6050 je založený na technológii Micro-Mechanical Systems (MEMS). Tento snímač má 3-osový akcelerometer, 3-osový gyroskop a zabudovaný teplotný snímač. Môže byť použitý na meranie parametrov ako zrýchlenie, rýchlosť, orientácia, posunutie atď. Predtým sme prepojili MPU6050 s Arduino a Raspberry pi a tiež sme pomocou neho vytvorili niekoľko projektov ako - Self Balancing robot, Arduino Digital Protractor a Arduino Inclinometer.
Funkcie snímača MPU6050:
- Komunikácia: protokol I2C s konfigurovateľnou adresou I2C
- Vstupné napájanie: 3-5V
- Zabudovaný 16-bitový ADC poskytuje vysokú presnosť
- Zabudovaný DMP poskytuje vysoký výpočtový výkon
- Môže byť použitý na prepojenie s inými zariadeniami I2C, ako je napríklad magnetometer
- Zabudovaný snímač teploty
Podrobné informácie o produkte MPU6050:
Pripnúť | Využitie |
Vcc | Poskytuje napájanie modulu, môže byť + 3 V až + 5 V. Spravidla sa používa + 5 V. |
Uzemnenie | Pripojené k zemi systému |
Sériové hodiny (SCL) | Používa sa na zabezpečenie hodinového impulzu pre komunikáciu I2C |
Sériové údaje (SDA) | Používa sa na prenos údajov prostredníctvom komunikácie I2C |
Pomocné sériové údaje (XDA) | Môže byť použitý na prepojenie iných I2C modulov s MPU6050 |
Pomocné sériové hodiny (XCL) | Môže byť použitý na prepojenie iných I2C modulov s MPU6050 |
AD0 | Ak sa použije viac ako jedna jednotka MPU6050 v jednom MCU, je možné tento kolík použiť na zmenu adresy |
Prerušiť (INT) | Prerušovací kolík označuje, že údaje sú k dispozícii na čítanie MCU |
Flex senzor
Senzory Flex nie sú ničím iným ako variabilným rezistorom. Odpor snímača ohybu sa zmení, keď je snímač ohnutý. Zvyčajne sú dostupné v dvoch veľkostiach 2,2 palca a 4,5 palca.
Prečo v našom projekte používame senzory ohybu?
V tomto robotickom ramene ovládanom gestami sa na ovládanie chápadla robotického ramena používa snímač ohybu. Keď je snímač ohybu na rukavici ohnutý, servomotor pripevnený k chápadlu sa otáča a chápadlo sa otvára.
Senzory Flex môžu byť užitočné v mnohých aplikáciách a pomocou senzora Flex sme vytvorili niekoľko projektov, ako napríklad herný ovládač, generátor tónov atď.
Príprava 3D tlačeného robotického ramena:
3D tlačené robotické rameno použité v tomto výučbe bolo vyrobené podľa vzoru EEZYbotARM, ktorý je k dispozícii v Thingiverse. Celý postup výroby 3D tlačeného robotického ramena a detailu montáže s videom je uvedený v odkaze Thingiverse, ktorý je zdieľaný vyššie.
Hore je obrázok môjho 3D tlačeného Robotického ramena po zostavení so 4 servomotormi.
Požadované komponenty:
- Arduino Nano
- Flex senzor
- 10k rezistor
- MPU6050
- Rukavice na ruky
- Pripojenie drôtov
- Nepál
Schéma zapojenia:
Nasledujúci obrázok ukazuje nasledujúce prúdové dráhy pre Arduino založené gesto kontrolovanej robotické rameno.
Okruhové pripojenie medzi MPU6050 a Arduino Nano:
MPU6050 |
Arduino Nano |
VCC |
+ 5V |
GND |
GND |
SDA |
A4 |
SCL |
A5 |
Okruhové spojenie medzi servomotormi a Arduino Nano:
Arduino Nano |
SERVO MOTOR |
Nabíjačka |
D2 |
Servo 1 oranžová (PWM pin) |
- |
D3 |
Servo 2 oranžové (PWM kolík) |
- |
D4 |
Servo 3 oranžové (PWM kolík) |
- |
D5 |
Servo 4 oranžové (PWM kolík) |
- |
GND |
Servo 1,2,3,4 hnedé (pin GND) |
GND |
- |
Servo 1,2,3,4 červená (+ 5 V kolík) |
+ 5V |
Flex senzor obsahuje dva kolíky. Neobsahuje polarizované vývody. Takže pin jeden P1 je pripojený k analógovému kolíku A0 Arduino Nano s pull-up rezistorom 10k a pin dva P2 je uzemnený k Arduinu.
Montáž senzora MPU6050 a Flex na rukavice
MPU6050 a snímač Flex sme namontovali na rukavicu. Tu sa na pripojenie rukavíc a robotického ramena používa káblové pripojenie, ale je možné ho vyrobiť bezdrôtovo pomocou RF spojenia alebo Bluetooth spojenia.
Po každom pripojení vyzerá konečné nastavenie robotickej ruky ovládanej gestami ako na nasledujúcom obrázku:
Programovanie Arduino Nano pre robotické rameno
Na konci tohto tutoriálu je ako obvykle uvedený kompletný kód spolu s pracovným videom. Tu je vysvetlených niekoľko dôležitých riadkov kódu.
1. Najskôr zahrňte potrebné súbory knižnice. Knižnica Wire.h sa používa na komunikáciu I2C medzi Arduino Nano a MPU6050 a servo.h na riadenie servomotora.
#include
2. Ďalej sú deklarované objekty pre triedu servo. Pretože používame štyri servomotory, vytvárajú sa štyri objekty ako servo_1, servo_2, servo_3, servo_4.
Servo servo_1; Servo servo_2; Servo servo_3; Servo servo_4;
3. Ďalej sa deklaruje adresa I2C MPU6050 a premenné, ktoré sa majú použiť.
const int MPU_addr = 0x68; // Adresa MPU6050 I2C int16_t osa_X, os_Y, os_Z; int minVal = 265; int maxVal = 402; dvojité x; dvojité y; dvojitý z;
4. Ďalej v nastavení neplatnosti je pre sériovú komunikáciu nastavená prenosová rýchlosť 9600.
Serial.begin (9600);
A je nadviazaná komunikácia I2C medzi Arduino Nano a MPU6050:
Wire.begin (); // Inicializácia I2C Communication Wire.beginTransmission (MPU_addr); // Spustiť komunikáciu s MPU6050 Wire.write (0x6B); // Zapisuje do registra 6B Wire.write (0); // Zapíše 0 do registra 6B, aby sa resetoval Wire.endTransmission (true); // Ukončí prenos I2C
Tiež sú definované štyri piny PWM pre pripojenie servomotora.
servo_1.attach (2); // Pohon vpred / vzad_motor servo_2.attach (3); // Hore / Dole_Motor servo_3.attach (4); // Gripper_Motor servo_4.attach (5); // Ľavý / pravý_motor
5. Ďalej vo funkcii neplatnej slučky znovu vytvorte I2C spojenie medzi MPU6050 a Arduino Nano a potom začnite načítať údaje z osí X, Y, Z z registra MPU6050 a uložte ich do zodpovedajúcich premenných.
Wire.beginTransmission (MPU_addr); Wire.write (0x3B); // Začnite s regsiterom 0x3B Wire.endTransmission (false); Wire.requestFrom (MPU_addr, 14, true); // Čítanie 14 registrov axis_X = Wire.read () << 8-Wire.read (); axis_Y = Wire.read () << 8-Wire.read (); axis_Z = Wire.read () << 8-Wire.read ();
Potom zmapujte minimálnu a maximálnu hodnotu údajov osi zo snímača MPU6050 v rozmedzí od -90 do 90.
int xAng = mapa (axis_X, minVal, maxVal, -90,90); int yAng = mapa (os_Y, minVal, maxVal, -90,90); int zAng = mapa (os_Z, minVal, maxVal, -90,90);
Potom pomocou nasledujúceho vzorca vypočítajte hodnoty x, y, z v hodnotách 0 až 360.
x = RAD_TO_DEG * (atan2 (-yAng, -zAng) + PI); y = RAD_TO_DEG * (atan2 (-xAng, -zAng) + PI); z = RAD_TO_DEG * (atan2 (-yAng, -xAng) + PI);
Potom prečítajte analógové výstupné údaje ohybného snímača na kolíku A0 Arduino Nano a podľa digitálnej hodnoty ohybného snímača nastavte uhol serva chápadla. Takže ak sú údaje ohybného snímača väčšie ako 750, uhol servomotora uchopovača je 0 stupňov a ak menej ako 750 je to 180 stupňov.
uchopovač int; int flex_sensorip = analogRead (A0); if (flex_sensorip> 750) { chapadlo = 0; } else { chapadlo = 180; } servo_3.write (chápadlo);
Potom sa pohyb MPU6050 na osi X od 0 do 60 mapuje v rozmedzí 0 až 90 stupňov pre pohyb servomotora vpred / vzad robotickým ramenom.
if (x> = 0 && x <= 60) { int mov1 = mapa (x, 0,60,0,90); Serial.print ("Pohyb vpred / vzad"); Sériová tlač (mov1); Serial.println ((char) 176); servo_1.write (mov1); }
A pohyb MPU6050 na osi X od 250 do 360 je namapovaný v rozmedzí 0 až 90 stupňov pre robotické rameno servomotora UP / DOWN.
else if (x> = 300 && x <= 360) { int mov2 = mapa (x, 360 250,0,90); Serial.print ("Pohyb hore / dole ="); Sériová tlač (mov2); Serial.println ((char) 176); servo_2.write (mov2); }
Pohyb MPU6050 na osi Y od 0 do 60 je mapovaný v rozmedzí 90 až 180 stupňov pre Ľavý pohyb servomotora robotického ramena.
if (y> = 0 && y <= 60) { int mov3 = mapa (y, 0,60,90,180); Serial.print ("Pohyb vľavo ="); Sériová tlač (mov3); Serial.println ((char) 176); servo_4.write (mov3); }
Pohyb MPU6050 v osi Y od 300 do 360 je mapovaný v rozmedzí 0 až 90 stupňov pre pravý pohyb robotického ramena servomotora.
else if (y> = 300 && y <= 360) { int mov3 = mapa (y, 360,300,90,0); Serial.print ("Pohyb vpravo ="); Sériová tlač (mov3); Serial.println ((char) 176); servo_4.write (mov3); }
Fungovanie robotického ramena ovládaného gestami pomocou Arduina
Na záver nahrajte kód do Arduino Nano a noste ručné rukavice pripevnené k senzoru MPU6050 & Flex.
1. Teraz pohybujte rukou nadol, aby ste posunuli robotické rameno dopredu, a posunutím nahor, aby ste posunuli robotické rameno nahor.
2. Potom nakloňte ruku doľava alebo doprava a robotické rameno otočíte doľava alebo doprava.
3. Ohnite ohybný kábel pripevnený prstom rukavice na ruke, aby ste otvorili chápadlo, a potom ho uvoľnite, aby ste ho zatvorili.
Kompletné fungovanie je demonštrované na videu uvedenom nižšie.