- MPU6050 gyroskopisk & accelerometersensor
- Flex-sensor
- Förbereda den 3D-tryckta robotarmen:
- Komponenter som krävs:
- Kretsschema:
- Montering MPU6050 & Flex Sensor på handskar
- Programmering av Arduino Nano för robotarm
- Arbeta med geststyrd robotarm med Arduino
Robotic Arms är en av de fascinerande tekniska skapelserna och det är alltid fascinerande att se dessa saker luta och panorera för att få komplexa saker gjort precis som en mänsklig arm skulle göra. Dessa robotarmar kan vanligtvis hittas i industrier vid monteringslinjen som utför intensivt mekaniskt arbete som svetsning, borrning, målning etc. Nyligen utvecklas också avancerade robotarmar med hög precision för att utföra komplexa kirurgiska operationer. Tidigare har vi 3D skrivit ut en robotarm och byggt en DIY Pick and Place-robotarm med ARM7 Microcontroller. Vi kommer igen att använda samma 3D-tryckta robotarm för att göra en handstyrd robotarm med Arduino Nano, MPU6050 gyroskop och flex-sensor.
Den här 3D-tryckta robotarmpositionen styrs via en handhandske som är fäst med ett MPU6050-gyroskop och en flexsensor. Flex-sensorn används för att styra griparmsservon på Robotic Arm och MPU6050 används för rörelse av robot i X- och Y-axeln. Om du inte har en skrivare kan du också bygga din arm med enkel kartong som vi byggde för vårt Arduino Robotic Arm Project. För inspiration kan du också hänvisa till Record and Play Robotic Arm som vi byggde tidigare med Arduino.
Innan vi går in i detalj, låt oss först lära oss om MPU6050-sensorn och flex-sensorn.
MPU6050 gyroskopisk & accelerometersensor
MPU6050 är baserad på MEMS-teknik (Micro-Mechanical Systems). Denna sensor har en 3-axlig accelerometer, ett 3-axligt gyroskop och en inbyggd temperatursensor. Den kan användas för att mäta parametrar som acceleration, hastighet, orientering, förskjutning etc. Vi har tidigare gränssnitt MPU6050 med Arduino och Raspberry pi och byggt också några projekt med den som - Självbalanseringsrobot, Arduino Digital Protractor och Arduino Inclinometer.
Funktioner i MPU6050-sensor:
- Kommunikation: I2C-protokoll med konfigurerbar I2C-adress
- Ingångsströmförsörjning: 3-5V
- Inbyggd 16-bitars ADC ger hög noggrannhet
- Inbyggd DMP ger hög beräkningskraft
- Kan användas för gränssnitt med andra I2C-enheter som en magnetometer
- Inbyggd temperaturgivare
Pin-Out-detaljer för MPU6050:
| Stift | Användande |
| Vcc | Ger ström till modulen, kan vara + 3V till + 5V. Vanligtvis används + 5V |
| Jord | Ansluten till systemets jord |
| Seriell klocka (SCL) | Används för att tillhandahålla klockpuls för I2C-kommunikation |
| Seriell data (SDA) | Används för överföring av data via I2C-kommunikation |
| Extra seriell data (XDA) | Kan användas för att ansluta andra I2C-moduler till MPU6050 |
| Extra seriell klocka (XCL) | Kan användas för att ansluta andra I2C-moduler till MPU6050 |
| AD0 | Om mer än en MPU6050 används en enda MCU, kan denna stift användas för att variera adressen |
| Interrupt (INT) | Avbryt stift för att indikera att data är tillgängliga för MCU att läsa |
Flex-sensor
Flex-sensorer är inget annat än ett variabelt motstånd. Flex-sensorns motstånd ändras när sensorn är böjd. De finns vanligtvis i två storlekar 2,2 tum och 4,5 tum.
Varför använder vi flexsensorer i vårt projekt?
I denna geststyrda robotarm används en flexsensor för att kontrollera griparmen på robotarmen. När flex-sensorn på handsken är böjd roterar servomotorn som är fäst vid griparen och griparen öppnas.
Flex-sensorer kan vara användbara i många applikationer och vi har byggt få projekt med Flex-sensor som en spelkontroll, tongenerator etc.
Förbereda den 3D-tryckta robotarmen:
Den 3D-tryckta robotarmen som användes i denna handledning gjordes genom att följa designen från EEZYbotARM som finns i Thingiverse. Den kompletta proceduren för att tillverka den 3D-tryckta robotarmen och monteringsdetaljer med video finns i länken Thingiverse, som delas ovan.
Ovan är bilden av min 3D-tryckta robotarm efter montering med 4 servomotorer.
Komponenter som krävs:
- Arduino Nano
- Flex-sensor
- 10k motstånd
- MPU6050
- Handskar
- Anslutande ledningar
- Bakbord
Kretsschema:
Följande bild visar kretsanslutningarna för Arduino- baserad geststyrd robotarm.
Kretsförbindelse mellan MPU6050 och Arduino Nano:
|
MPU6050 |
Arduino Nano |
|
VCC |
+ 5V |
|
GND |
GND |
|
SDA |
A4 |
|
SCL |
A5 |
Kretsförbindelse mellan Servomotorer och Arduino Nano:
|
Arduino Nano |
SERVOMOTOR |
Strömadapter |
|
D2 |
Servo 1 orange (PWM-stift) |
- |
|
D3 |
Servo 2 Orange (PWM-stift) |
- |
|
D4 |
Servo 3 Orange (PWM-stift) |
- |
|
D5 |
Servo 4 Orange (PWM-stift) |
- |
|
GND |
Servo 1,2,3,4 Brun (GND-stift) |
GND |
|
- |
Servo 1,2,3,4 Röd (+ 5V stift) |
+ 5V |
En flex-sensor innehåller två stift. Den innehåller inte polariserade terminaler. Så pin 1 P1 är ansluten till Arduino Nano Analog Pin A0 med ett uppdragningsmotstånd på 10k och stift två P2 är jordat till Arduino.
Montering MPU6050 & Flex Sensor på handskar
Vi har monterat MPU6050 och Flex Sensor på en handske. Här används en trådbunden anslutning för att ansluta handske och robotarm men den kan göras trådlös med hjälp av en RF-anslutning eller en Bluetooth-anslutning.
Efter varje anslutning ser den slutliga installationen för geststyrd robotarm ut som bilden nedan:
Programmering av Arduino Nano för robotarm
Som vanligt ges komplett kod tillsammans med en fungerande video i slutet av denna handledning. Här förklaras några viktiga rader med kod.
1. Inkludera först nödvändiga biblioteksfiler. Wire.h- biblioteket används för I2C-kommunikation mellan Arduino Nano & MPU6050 och servo.h för styrning av servomotor.
#omfatta
2. Därefter förklaras objekten för klassservon. När vi använder fyra servomotorer skapas fyra objekt som servo_1, servo_2, servo_3, servo_4.
Servo servo_1; Servo servo_2; Servo servo_3; Servo servo_4;
3. Därefter deklareras I2C-adressen för MPU6050 och de variabler som ska användas.
const int MPU_addr = 0x68; // MPU6050 I2C Adress int16_t axel_X, axel_Y, axel_Z; int minVal = 265; int maxVal = 402; dubbel x; dubbel y; dubbel z;
4. Nästa i tomrummet är en baudhastighet på 9600 inställd för seriell kommunikation.
Serial.begin (9600);
Och I2C-kommunikation mellan Arduino Nano och MPU6050 upprättas:
Wire.begin (); // Initiera I2C Communication Wire.beginTransmission (MPU_addr); // Starta kommunikation med MPU6050 Wire.write (0x6B); // Skriver för att registrera 6B Wire.write (0); // Skriver 0 till 6B Registrera för att återställa Wire.endTransmission (true); // Avslutar I2C-överföring
Dessutom är fyra PWM-stift definierade för servomotoranslutningar.
servo_1.attach (2); // Framåt / Reverse_Motor servo_2.attach (3); // Up / Down_Motor servo_3.attach (4); // Gripper_Motor servo_4.attach (5); // Vänster / höger_motor
5. Nästa i tomrumsfunktionen , upprätta igen I2C-anslutningen mellan MPU6050 och Arduino Nano och börja sedan läsa X-, Y-, Z-axeldata från MPU6050-registret och lagra dem i motsvarande variabler.
Wire.beginTransmission (MPU_addr); Wire.write (0x3B); // Börja med regsiter 0x3B Wire.endTransmission (false); Wire.requestFrom (MPU_addr, 14, sant); // Läs 14 Registrerar axel_X = Wire.read () << 8-Wire.read (); axis_Y = Wire.read () << 8-Wire.read (); axis_Z = Wire.read () << 8-Wire.read ();
Karta därefter min- och maxvärdet för axeldata från MPU6050-sensorn i intervallet -90 till 90.
int xAng = karta (axel_X, minVal, maxVal, -90,90); int yAng = karta (axel_Y, minVal, maxVal, -90,90); int zAng = karta (axel_Z, minVal, maxVal, -90,90);
Använd sedan följande formel för att beräkna x-, y-, z-värdena i termer av 0 till 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);
Läs sedan flex-sensorn Analog utdata vid Arduino Nano A0-stift och ställ in greppens servovinkel enligt det digitala värdet på flex-sensorn. Så om flexsensordata är större än 750 är griparens servomotorvinkel 0 grader och om det är mindre än 750 är det 180 grader.
int gripare; int flex_sensorip = analogRead (A0); if (flex_sensorip> 750) { gripper = 0; } annat { gripper = 180; } servo_3.write (gripare);
Sedan mappas MPU6050 på X-axeln från 0 till 60 i termer av 0 till 90 grader för servomotorns framåt- / backrörelse robotarmen.
om (x> = 0 && x <= 60) { int mov1 = karta (x, 0,60,0,90); Serial.print ("Rörelse i F / R ="); Serial.print (mov1); Serial.println ((char) 176); servo_1.write (mov1); }
Och rörelsen av MPU6050 på X-axeln från 250 till 360 kartläggs i termer av 0 till 90 grader för servomotorns UPP / NED-rörelse-robotarm.
annars om (x> = 300 && x <= 360) { int mov2 = karta (x, 360,250,0,90); Serial.print ("Rörelse upp / ner ="); Serial.print (mov2); Serial.println ((char) 176); servo_2.write (mov2); }
Rörelse av MPU6050 på Y-axeln från 0 till 60 kartläggs i termer av 90 till 180 grader för servomotorns vänsterrörelse av robotarmen.
om (y> = 0 && y <= 60) { int mov3 = karta (y, 0,60,90,180); Serial.print ("Rörelse i vänster ="); Serial.print (mov3); Serial.println ((char) 176); servo_4.write (mov3); }
Rörelse av MPU6050 i Y-axeln från 300 till 360 kartläggs i termer av 0 till 90 grader för servomotorns högerrörelse av robotarmen.
annars om (y> = 300 && y <= 360) { int mov3 = karta (y, 360,300,90,0); Serial.print ("Rörelse till höger ="); Serial.print (mov3); Serial.println ((char) 176); servo_4.write (mov3); }
Arbeta med geststyrd robotarm med Arduino
Slutligen laddar du upp koden till Arduino Nano och bär handsken monterad med MPU6050 & Flex Sensor.
1. Flytta nu handen för att flytta robotarmen framåt och flytta upp för att flytta robotarmen uppåt.
2. Luta sedan handen åt vänster eller höger för att vrida robotarmen åt vänster eller höger.
3. Böj flexkabeln som sitter fast med handskens finger för att öppna griparen och släpp den sedan för att stänga den.
Det fullständiga arbetet visas i videon nedan.