- MPU6050 Gyroscopic & Accelerometer Sensor
- Flex Sensor
- Paghahanda ng 3D naka-print na Robotic ARM:
- Kinakailangan ang Mga Bahagi:
- Diagram ng Circuit:
- Pag-mount ng MPU6050 at Flex Sensor sa Mga Guwantes
- Programming Arduino Nano para sa Robotic Arm
- Kinokontrol ng Paggawa ng kilos ang Robotic Arm gamit ang Arduino
Ang Robotic Arms ay isa sa mga kamangha-manghang mga nilikha sa engineering at palaging kaakit-akit na panoorin ang mga bagay na ikiling at i-pan upang makagawa ng mga kumplikadong bagay tulad ng gagawin ng isang bisig ng tao. Ang mga sandatang robotic na ito ay maaaring matagpuan sa mga industriya sa linya ng pagpupulong na gumaganap ng matinding gawaing mekanikal tulad ng hinang, pagbabarena, pagpipinta, atbp. Dati nag-print kami ng 3D ng isang robotic Arm at nagtayo ng isang DIY Pick and Place Robotic arm gamit ang ARM7 Microcontroller. Gagamitin namin muli ang parehong 3D naka-print na Robotic Arm upang makagawa ng isang kilos ng Kamay na kontrolado ng robotic ARM gamit ang Arduino Nano, MPU6050 Gyroscope at flex sensor.
Ang naka-print na posisyon ng robotic arm na 3D na ito ay kinokontrol sa pamamagitan ng isang guwantes na naka-attach sa isang MPU6050 Gyroscope at isang flex sensor. Ginagamit ang sensor ng Flex upang makontrol ang gripper servo ng Robotic Arm at ang MPU6050 ay ginagamit para sa paggalaw ng robotic sa X at Y-axis. Kung wala kang isang printer, maaari mo ring buuin ang iyong braso gamit ang simpleng karton habang itinayo namin para sa aming Arduino Robotic Arm Project. Para sa inspirasyon, maaari ka ring mag-refer sa Record at Play Robotic Arm na itinayo namin kanina gamit ang Arduino.
Bago magpunta sa detalye, una, alamin natin ang tungkol sa MPU6050 sensor at flex sensor.
MPU6050 Gyroscopic & Accelerometer Sensor
Ang MPU6050 ay batay sa teknolohiya ng Micro-Mechanical Systems (MEMS). Ang sensor na ito ay mayroong 3-axis accelerometer, isang 3-axis gyroscope, at isang built-in na sensor ng temperatura. Maaari itong magamit upang sukatin ang mga parameter tulad ng Acceleration, Velocity, Orientation, Displaced, atbp. Nauna kaming nakipag-interfaces sa MPU6050 sa Arduino at Raspberry pi at nagtayo din ng ilang mga proyekto gamit ito tulad ng- Self Balancing robot, Arduino Digital Protractor, at Arduino Inclinometer.
Mga tampok sa MPU6050 Sensor:
- Pakikipag-usap: I2C protocol na may maisasaayos na I2C Address
- Input na Power Supply: 3-5V
- Ang built-in na 16-bit ADC ay nagbibigay ng mataas na kawastuhan
- Ang Built-in DMP ay nagbibigay ng mataas na kapangyarihan sa computational
- Maaaring magamit upang mag-interface sa iba pang mga aparato ng I2C tulad ng isang magnetometer
- In-built sensor ng temperatura
Mga detalye ng Pin-Out ng MPU6050:
| Pin | Paggamit |
| Vcc | Nagbibigay ng lakas para sa module, maaaring maging + 3V hanggang + 5V. Kadalasan ginagamit ang + 5V |
| Lupa | Nakakonekta sa Ground ng system |
| Serial Clock (SCL) | Ginamit para sa pagbibigay ng pulso ng orasan para sa I2C Communication |
| Serial Data (SDA) | Ginamit para sa paglilipat ng Data sa pamamagitan ng komunikasyon ng I2C |
| Auxiliary Serial Data (XDA) | Maaaring magamit upang i-interface ang iba pang mga module ng I2C sa MPU6050 |
| Auxiliary Serial Clock (XCL) | Maaaring magamit upang i-interface ang iba pang mga module ng I2C sa MPU6050 |
| AD0 | Kung higit sa isang MPU6050 ang ginamit isang solong MCU, kung gayon ang pin na ito ay maaaring magamit upang maiiba ang address |
| Makagambala (INT) | Makagambala pin upang ipahiwatig na ang data ay magagamit para mabasa ng MCU |
Flex Sensor
Ang Flex Sensors ay walang iba kundi isang variable risistor. Nagbabago ang paglaban ng flex sensor kapag ang sensor ay baluktot. Sila ay karaniwang magagamit sa dalawang mga laki ng 2.2 pulgada at 4.5 pulgada.
Bakit gumagamit kami ng mga flex sensor sa aming proyekto?
Sa kontrol ng Gesture na Robotic Arm na ito, ginagamit ang isang flex sensor upang makontrol ang gripper ng robotic arm. Kapag ang flex sensor sa guwantes ng kamay ay baluktot, ang servo motor na nakakabit sa gripper ay umiikot at ang gripper ay bubukas.
Ang mga Flex sensor ay maaaring maging kapaki-pakinabang sa maraming mga application at nagtayo kami ng ilang mga proyekto gamit ang Flex sensor tulad ng isang game controller, Tone generator, atbp.
Paghahanda ng 3D naka-print na Robotic ARM:
Ang 3D na naka-print na Robotic Arm na ginamit sa tutorial na ito ay ginawa sa pamamagitan ng pagsunod sa disenyo na ibinigay ng EEZYbotARM na magagamit sa Thingiverse. Ang kumpletong pamamaraan para sa paggawa ng naka-print na robotic arm na 3D at ang detalye ng pag-iipon sa video ay naroroon sa link na Thingiverse, na ibinahagi sa itaas.
Sa itaas ay ang imahe ng aking 3D na naka-print na Robotic Arm pagkatapos ng assembling sa 4 Servo Motors.
Kinakailangan ang Mga Bahagi:
- Arduino Nano
- Flex Sensor
- 10k Resistor
- MPU6050
- Guwantes
- Mga Koneksyon sa Mga Wires
- Breadboard
Diagram ng Circuit:
Ipinapakita ng sumusunod na imahe ang mga koneksyon sa circuit para sa kilos na batay sa Arduino na kinokontrol ang Robotic Arm.
Koneksyon sa Circuit sa pagitan ng MPU6050 at Arduino Nano:
|
MPU6050 |
Arduino Nano |
|
VCC |
+ 5V |
|
GND |
GND |
|
SDA |
A4 |
|
SCL |
A5 |
Koneksyon ng Circuit sa pagitan ng Servo Motors at Arduino Nano:
|
Arduino Nano |
SERVO MOTOR |
Power Adapter |
|
D2 |
Servo 1 Orange (PWM Pin) |
- |
|
D3 |
Servo 2 Orange (PWM Pin) |
- |
|
D4 |
Servo 3 Orange (PWM Pin) |
- |
|
D5 |
Servo 4 Orange (PWM Pin) |
- |
|
GND |
Servo 1,2,3,4 Brown (GND Pin) |
GND |
|
- |
Servo 1,2,3,4 Pula (+ 5V Pin) |
+ 5V |
Ang isang flex sensor ay naglalaman ng dalawang mga pin. Hindi ito naglalaman ng mga naka-polar na terminal. Kaya't ang pin one P1 ay konektado sa Analog Pin A0 ng Arduino Nano na may pull-up resistor na 10k at ang pin na dalawang P2 ay ibinagsak kay Arduino.
Pag-mount ng MPU6050 at Flex Sensor sa Mga Guwantes
Na-mount namin ang MPU6050 at Flex Sensor sa isang kamay na guwantes. Dito ginagamit ang isang wired na koneksyon upang ikonekta ang Glove at robotic arm ngunit maaari itong gawin nang wireless sa pamamagitan ng paggamit ng isang koneksyon sa RF o isang koneksyon sa Bluetooth.
Matapos ang bawat koneksyon, ang pangwakas na pag-set up para sa kilos na kinokontrol ng kilos na Robotic Arm ay katulad ng imahe sa ibaba:
Programming Arduino Nano para sa Robotic Arm
Tulad ng dati, ang kumpletong code kasama ang isang gumaganang video ay ibinibigay sa pagtatapos ng tutorial na ito. Narito ang ilang mahahalagang linya ng code ay ipinaliwanag.
1. Una, isama ang mga kinakailangang file ng library. Ang Wire.h library ay ginagamit para sa komunikasyon ng I2C sa pagitan ng Arduino Nano & MPU6050 at servo.h para sa pagkontrol sa motor na servo.
# isama
2. Susunod, idineklara ang mga bagay para sa servo ng klase. Habang gumagamit kami ng apat na servo motor, nilikha ang apat na bagay tulad ng servo_1, servo_2, servo_3, servo_4.
Servo servo_1; Servo servo_2; Servo servo_3; Servo servo_4;
3. Susunod, ang I2C address ng MPU6050 at ang mga variable na gagamitin ay idineklara.
const int MPU_addr = 0x68; // MPU6050 I2C Address int16_t axis_X, axis_Y, axis_Z; int minVal = 265; int maxVal = 402; doble x; doble y; double z;
4. Susunod sa walang bisa na pag-setup , isang baud rate na 9600 ay nakatakda para sa Serial na komunikasyon.
Serial.begin (9600);
At ang komunikasyon ng I2C sa pagitan ng Arduino Nano at MPU6050 ay itinatag:
Wire.begin (); // Initilize I2C Communication Wire.beginTransmission (MPU_addr); // Simulan ang komunikasyon sa MPU6050 Wire.write (0x6B); // Nagsusulat upang Magrehistro 6B Wire.write (0); // Nagsusulat ng 0 sa 6B Magrehistro upang I-reset ang Wire.endTransmission (totoo); // Nagtatapos sa paghahatid ng I2C
Gayundin, ang apat na mga pin ng PWM ay tinukoy para sa mga koneksyon sa servo motor.
servo_1.attach (2); // Forward / Reverse_Motor servo_2.attach (3); // Up / Down_Motor servo_3.attach (4); // Gripper_Motor servo_4.attach (5); // Kaliwa / Kanan_Motor
5. Susunod sa pag- andar ng void loop , muling itaguyod ang koneksyon ng I2C sa pagitan ng MPU6050 at Arduino Nano at pagkatapos ay simulang basahin ang data ng X, Y, Z-Axis mula sa rehistro ng MPU6050 at iimbak ang mga ito sa kaukulang variable.
Wire.beginTransmission (MPU_addr); Wire.write (0x3B); // Magsimula sa regsiter 0x3B Wire.endTransmission (false); Wire.requestFrom (MPU_addr, 14, totoo); // Basahin ang 14 Mga Rehistro axis_X = Wire.read () << 8-Wire.read (); axis_Y = Wire.read () << 8-Wire.read (); axis_Z = Wire.read () << 8-Wire.read ();
Pagkatapos nito, i-mapa ang min at max na halaga ng data ng axis mula sa sensor ng MPU6050 sa saklaw na -90 hanggang 90.
int xAng = mapa (axis_X, minVal, maxVal, -90,90); int yAng = mapa (axis_Y, minVal, maxVal, -90,90); int zAng = mapa (axis_Z, minVal, maxVal, -90,90);
Pagkatapos ay gamitin ang sumusunod na formula upang makalkula ang mga halagang x, y, z sa mga tuntunin ng 0 hanggang 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);
Pagkatapos basahin ang data ng flex sensor Analog output sa A0 pin ng Arduino Nano at alinsunod sa digital na halaga ng flex sensor itakda ang anggulo ng servo ng gripper. Kaya't kung ang data ng flex sensor ay mas malaki sa 750 ang servo motor na anggulo ng gripper ay 0 degree at kung mas mababa sa 750 ito ay 180 degree.
int gripper; int flex_sensorip = analogRead (A0); kung (flex_sensorip> 750) { gripper = 0; } iba pa { gripper = 180; } servo_3.write (gripper);
Pagkatapos ang paggalaw ng MPU6050 sa X-axis mula 0 hanggang 60 ay nai-map sa mga tuntunin ng 0 hanggang 90 degree para sa Forward / Reverse paggalaw ng servo motor ang braso ng Robotic.
kung (x> = 0 && x <= 60) { int Mov1 = mapa (x, 0,60,0,90); Serial.print ("Kilusan sa F / R ="); Serial.print (Mov1); Serial.println ((char) 176); servo_1.write (Mov1); }
At ang paggalaw ng MPU6050 sa X-axis mula 250 hanggang 360 ay nai-mapa sa mga tuntunin ng 0 hanggang 90 degree para sa UP / Down na paggalaw ng Robotic arm ng motor.
iba pa kung (x> = 300 && x <= 360) { int Mov2 = mapa (x, 360,250,0,90); Serial.print ("Kilusan sa Paitaas / Pababa ="); Serial.print (Mov2); Serial.println ((char) 176); servo_2.write (Mov2); }
Ang paggalaw ng MPU6050 sa Y-axis mula 0 hanggang 60 ay nai-mapa sa mga tuntunin ng 90 hanggang 180 degree para sa Left Movement ng Robotic arm ng servo motor.
kung (y> = 0 && y <= 60) { int Mov3 = mapa (y, 0,60,90,180); Serial.print ("Kilusan sa Kaliwa ="); Serial.print (Mov3); Serial.println ((char) 176); servo_4.write (Mov3); }
Ang paggalaw ng MPU6050 sa Y-axis mula 300 hanggang 360 ay nai-map sa mga tuntunin ng 0 hanggang 90 degree para sa Right Movement ng Robotic arm ng servo motor.
kung hindi man kung (y> = 300 && y <= 360) { int Mov3 = mapa (y, 360,300,90,0); Serial.print ("Kilusan sa Kanan ="); Serial.print (Mov3); Serial.println ((char) 176); servo_4.write (Mov3); }
Kinokontrol ng Paggawa ng kilos ang Robotic Arm gamit ang Arduino
Panghuli, i-upload ang code sa Arduino Nano at isusuot ang guwantes na kamay na naka-mount sa MPU6050 & Flex Sensor.
1. Ngayon ilipat ang kamay pababa upang ilipat ang robotic braso pasulong at ilipat pataas upang ilipat ang robotic braso pataas.
2. Pagkatapos ikiling ang kamay pakaliwa o pakanan upang paikutin o pakanan ang robotic arm.
3. Bend ang flex cable na nakakabit sa daliri ng gwantes ng kamay upang buksan ang gripper at pagkatapos ay pakawalan ito upang isara ito.
Ang kumpletong pagtatrabaho ay ipinakita sa video na ibinigay sa ibaba.