DIY Arduino-robotarm – bestuurd door handgebaren

Over dit project

Introductie van de doe-het-zelf-robotarm die wordt bestuurd door menselijke gebaren.

Blockbuster-films zoals Pacific Rim, Avatar en andere Sci-Fi-films hebben gesuggereerd dat er synergie mogelijk is met robots, waarbij je bewegingen kunnen worden verbeterd met robotassistentie.

Wat als we dezelfde industriële robot zouden kunnen bouwen, maar op een kleinere schaal?

Dit project is een poging om dit te bereiken.

Dit is een Arduino-robotarm die kan worden geprogrammeerd of zelfs met handgebaren kan worden bestuurd.

Trouw blijvend aan de pakconventie van Iron man, zou elke iteratie bekend staan ​​​​als Mark. Dit prototype zou bekend staan ​​als MARK 1. We kunnen meer iteraties verwachten om de originele robotarm te verbeteren.

Bekijk hier de volledige zelfstudie Robotarm (bestuurd door handgebaren)

Overzicht

In deze zelfstudie bouwen we een robot met zes assen die wordt bestuurd door handgebaren met een robothandschoen. En door natuurlijke menselijke gebaren na te bootsen, zoals een knijpen of een polsrotatie naar links, kunt u de robotarm respectievelijk naar links en rechts openen/sluiten of draaien. In feite is het handmatig besturen van een robotarm.

Vind meer details over het originele artikel

MARK 1-functies:

• 6-assige rotatie
• Draagbaar
• Bedien de robot met menselijke gebaren
• Kan voorgeprogrammeerd worden om basisfuncties uit te voeren
• Kan draadloos worden bediend vanuit een bereik
• Kan een laadgewicht van 600 g dragen (max. belasting 1 kg)

Onderdelenlijst

De robotarm is volledig aanpasbaar. U kunt deze zelf kopen of zelf 3D-printen. Als je ervoor kiest om te 3D-printen, maak je dan geen zorgen. Er is een lijst met verschillende robots die servomotoren gebruiken, dus de theorie van wat we aan het bouwen zijn, is nog steeds van toepassing.

Voor dit project zou dit prototype (Mark 1) worden 3D-geprint omdat het me meer ruimte geeft om aangepaste onderdelen te maken.

Robotarm: Thingiverse 3D-geprinte robotarm (credits:Wonder Tiger):

• Deel 1:Grijperonderdelen
• Deel 2:Basis en draaitafel
• Deel 3:Robotische kernarm

U kunt meer informatie over deze build vinden, samen met de schroeftypes van de bovenstaande onderdelen. De tijd die nodig is om af te drukken kan oplopen tot 40 uur. Dit verlaagt echter de kosten van het kopen van een robotarm.

Robothandschoen : De Robotic Glove.STL-bestanden (credits:Roman 13)

De robothandschoen was een esthetische toevoeging aan het project, maar je kunt net zo goed een bouwhandschoen gebruiken om de robotarm te implementeren.

Opmerking: voor grotere handen, print op een schaal van 105%

Hoe het werkt

Over het algemeen sturen we een signaal (via Bluetooth) van de robothandschoen naar de servomotor. Wanneer een waarde is ontvangen, stuurt de servodriver een signaal naar een specifieke servomotor die de robotarm beweegt.

Als we nu meerdere servo's en meer sensoren toevoegen, kunnen we elke motor besturen. `

Als we een robotarm zien als een reeks servomotoren die met elkaar samenwerken om een ​​functie uit te voeren, kunnen we een robotarm maken die wordt bestuurd door een robothandschoen.

De Arduino van de Robotic Glove gebruikt sensoren om te communiceren met de Robotic Arm Arduino en stuurt gegevens om een ​​servo naar de gewenste hoek te verplaatsen.

Je vraagt ​​je misschien af, welke sensoren gebruikt de robothandschoen?

Voor MARK 1 zouden we Flex Sensors en een accelerometer (MPU6050) gebruiken

• Flex-sensoren - Op basis van de mate van buiging van dit plastic stuk, verandert de weerstand, waardoor de stroom wordt beïnvloed. Deze meting wordt vervolgens gebruikt om veranderingen in handbewegingen te detecteren.
• Versnellingsmeters – Voor natuurlijkere gebaren kan een versnellingsmeter een verandering in de arm- en polsrotatie detecteren.

We gebruiken deze sensoren om een ​​verandering in een gebaar te detecteren. We kunnen dan een specifieke waarde van een gebaar naar de robotarm sturen om een ​​servomotor via Bluetooth te besturen. En met genoeg gebaren komt de robotarm tot leven!

Robotarm in kaart brengen

Het volgende vertegenwoordigt een toewijzingstabel van de waarden die door de handschoen naar de robotarm worden gestuurd. Dit is te vinden op het originele artikel. Met elk een sleutel om zijn functie te karakteriseren. (P – Pinkie, L – Rechts, enz.)

Opmerking: Hoofdletter "F" (vinger) vertegenwoordigt de tegenovergestelde richting van de rotatie van de servomotor

Montage van onderdelen

Robotarm – Montage

De aanschaf van een robotarm kan behoorlijk duur zijn. Om deze robotarm binnen Budget te houden, was het 3D printen van een Robotarm de beste optie.

Dit helpt op de lange termijn, aangezien er veel voorbeelden zijn van een 3D-geprinte robotarm die kan worden aangepast, bijvoorbeeld door een LED toe te voegen, een camerastandaard te creëren Klem:

Zoals eerder vermeld, was de robotarm gemodelleerd rond de robotarm op Thingyverse. Ik heb dit voorbeeld gekozen omdat het een uitstekend ontwerp was met zes assen, goed gedocumenteerd en sterk/robuust was. Je hebt toegang tot Wonder Tiger's robotarm vanuit de onderdelenlijst.

Je kunt ook mijn remixen vinden voor een Robotic Arm Camera Stand. We zullen hier meer over vertellen in een toekomstige release. Het kan echter minstens 40 uur duren voordat de onderdelen zijn verzameld om alle onderdelen af ​​te drukken.

Je kunt ook veel andere Robotic Arm 3D Printed-alternatieven vinden.

Introductie van de servomotor en driver

Aangezien de robotarm idealiter een reeks motoren is die samen worden gecoördineerd, kunnen we in theorie verschillende motoren aansluiten die allemaal kunnen worden aangedreven door de Arduino. In dit project gebruiken we de PCA9685 Servo Driver om de MG966R Servo van stroom te voorzien.

Opmerking: Gebruik een externe voeding bij het voeden van elke motor. De Arduino kan niet genoeg stroom leveren om alle motoren aan te sturen. In dit project werd een 5V, een 2200 mAh RC-batterij gebruikt.

De bedrading van het Arduino-diagram moet er als volgt uitzien:

NEMA-17 voor basisrotatie

Omdat de Robotic een beetje zwaarder begon te worden en de MG966R-servomotor niet krachtig genoeg was om de Robotarm aan de basis te draaien. Om de robotarm te draaien, zou een robuustere motor dan een servomotor moeten worden gebruikt

Een stappenmotor (NEMA-17) kan worden gebruikt vanwege de precisie en het hoge koppel, waardoor de robotarm naadloos kan draaien voor gebarenbedieningen.

De NEMA-17 en de A4988 Driver werden gebruikt om de richting van de motor te regelen, zoals u kunt zien in het onderstaande diagram:

En tot slot toont het volgende diagram het uiteindelijke bedradingsschema van de complete robotarm.

Montage van circuits

Het onderstaande bedradingsschema toont de uiteindelijke montage van alle elektronische onderdelen om een ​​robotarm te maken, inclusief de Bluetooth-module. We behandelen het koppelproces hieronder.

Menselijke Flex-sensor

Om trouw te blijven aan de esthetiek van de robotarm, kun je een 3D-geprinte exoskelethandschoen printen om te gebruiken als je robothandschoen.

U kunt echter wel een standaard bouwhandschoen . gebruiken voor het prototypen van de robothandschoen. Dit 'Robot Glove Exoskeleton'-ontwerp past gewoon goed bij het ontwerp van de robotarm.

De robothandschoen bestaat uit de volgende onderdelen:

• Flex-sensor –  Op basis van de buiging van de vinger verandert de stroom die we zouden kunnen gebruiken om een ​​signaal naar de motor te sturen
• Versnellingsmeter (MPU6050 .) ) – We kunnen de motor besturen door menselijke gebaren in kaart te brengen vanuit het X-, Y-, Z-vlak
• LED - De LED gaat branden wanneer een menselijke bewegingsbesturing naar de Arduino is verzonden
• Bluetooth (HC-05)-module – Gegevens verzenden naar de robotarm HC-05-ontvanger
• Arduino Nano – De microcontroller zou fungeren als het brein van de robothandschoen

Het volgende diagram is geweldig om de flexsensor en de versnellingsmeter te testen.

Belangrijk: De robotarm zal alleen zo nauwkeurig zijn als de robothandschoenbedieningen, dus het is de moeite waard om dit goed te doen.

De Bluetooth configureren (master en ontvanger)

De Arduino Robotic Arm communiceert via Bluetooth met behulp van de HC-05-modules. Markeer hieronder de kritieke informatie.

Module

Configuratie

Robothandschoen HC-05   Master Robotarm HC-05  Slave

Opmerking:

Baudrate is ingesteld op 4800

Arduino-programmering

U kunt de volgende code hieronder downloaden:

Opmerking: Alle andere testcodes en de nieuwste versie zijn te vinden op de Arduino Robotic Arm Git Repo

De robotarm programmeren

De Robotic Arm-code maakt gebruik van de HCPCA9685-bibliotheek (voor de servodriver). Op deze manier kunnen we meerdere servomotoren aansturen, allemaal aangestuurd door een Arduino. In de code kunnen we beginnen met het toevoegen van deze bibliotheek en het declareren van de servovariabelen.

De volgende variabelen worden gebruikt om de vorige/toename te vinden en de huidige positie van de servo te krijgen.

* Voeg de HCPCA9685-bibliotheek toe */
#include "HCPCA9685.h"
/* I2C-slaveadres voor het apparaat/de module. Voor de HCMODU0097 is het standaard I2C-adres
0x40 */
#define I2CAdd 0x40
/* Maak een instantie van de bibliotheek */
HCPCA9685 HCPCA9685(I2CAdd);
//initiële parkeerpositie van de motor
const int servo_joint_L_parking_pos =60;
//Graad van robotservogevoeligheid - Intervallen
int servo_joint_L_pos_increment =20;
//Houd de de huidige waarde van de motorposities
int servo_joint_L_parking_pos_i =servo_joint_L_parking_pos;
//Minimale en maximale hoek van servomotor
int servo_joint_L_min_pos =10;
int servo_joint_L_max_pos =180; 

Initialiseer de seriële poort op baudrate 4800 om de Bluetooth-communicatie te starten

Serial.begin(4800); // Initialiseer de standaard communicatiesnelheid van de Bluetooth-module 

In de loop()-sectie controleren we constant of er gegevens van de robothandschoen komen. Als dit waar is, slaan we de binnenkomende gegevens op in de variabele 'state'. En afhankelijk van het gegeven karakter gebruiken we dit om de motor(en) te verplaatsen.

Het volgende gedeelte beschrijft de code:

De Robotic Arm-code kan worden gezien als een reeks servomotoren die samenwerken om menselijke bewegingen te simuleren. De code is hetzelfde, waarbij servo's worden aangedreven door een servostuurprogramma op basis van Bluetooth-waarden.

//Definiëren van de servo-driver. 0x40-adres is het standaard I2C-adres.
#define I2CAdd 0x40
int response_time =5; //Waarden ontvangen van het robothandschoeninterval
// Controleert of gegevens afkomstig zijn van de seriële poort

if (Serial.available()> 0) {
state =Serial .lezen(); // Leest de gegevens van de seriële poort
Serial.print(state); // Drukt de verzonden waarde af
//Codeblok motorfunctionaliteit
} 

Op basis van de huidige 'statuswaarde' zou de servodriver een signaal naar de respectievelijke motor sturen.

Bijvoorbeeld als we onze vingers buigen. De waarde 'f' zou worden verzonden door de robothandschoen (via Bluetooth), waarbij de robotarm deze gegevens zou lezen en een functie zou activeren om de respectieve servomotor te draaien. Dit proces wordt herhaald in een oneindige lus.

if (Serial.available()> 0) { // Controleert of gegevens van de seriële poort komen
state =Serial.read(); // Leest de gegevens van de seriële poort
Serial.print(state); // Drukt de verzonden waarde af
//Raadpleeg voor de naamgeving van de motoren het artikel / tutorial
//Move (Base Rotation) Stepper Motor Left
if (state ==' S') {
baseRotateLeft();
delay(response_time);
}
} 

Opmerking: De code implementeert een harde stop, om te voorkomen dat de motor zijn maximale hoek overschrijdt, waardoor de motortandwielen kunnen strippen.

HCPCA9685.Servo(0, servo_joint_L_parking_pos_i); // Stuur de servomotor op kanaal 0 naar de gewenste hoek.
//Beweeg de klauwmotor naar beneden
if (state =='f') {
if (servo_joint_3_parking_pos_i HCPCA9685.Servo(4, servo_joint_3_parking_pos_i);
delay(response_time);
Serial.println(servo_joint_3_parking_pos_i);
servo_joint_3_parking_pos_i =servo_joint_3_parking>}
void baseRotateLeft() {
digitalWrite(stepPin, LOW); // Draai in een richting gebaseerd op HOOG, LAAG
delayMicroseconds(stepDelay); // Verander de snelheid van de stappenmotor
} 

Als de waarde van de servomotor kleiner is dan de maximale rotatie, ga dan door met draaien. Als het de maximale rotatie van 180 graden heeft bereikt, stop dan.

servo_joint_3_parking_pos_i  

Waar servo_joint_3_max_pos de maximale positie van de motor is.

Opmerking: De code implementeert een harde stop om te voorkomen dat de motor de maximale hoek overschrijdt, waardoor de motortandwielen kunnen strippen.

Programmeren van de Flex Sensor

De Robotic Arm-code is te vinden op GitHub. Als je aan het project werkt, draag dan je eigen versie bij aan Git Repo. Dit zou helpen bij het opbouwen van een index van verschillende versies en functionaliteiten van de robotarm.

De code is al gedocumenteerd (Ook beschikbaar op Git). We zullen echter de belangrijkste punten behandelen:

We zullen de vijf sensoren definiëren:

//LED AAN PIN 3
int pinkie_Data =A1;
int finger_Data =A2;
int thumb_Data =A3;
//const int MPU_addr =0x68;
const int MPU2 =0x69, MPU1 =0x68; 

Opmerking: 0x68 en 0x69 vertegenwoordigen het I2C-adres van de 2 MPU6050-versnellingsmeters

//Hoe vaak moeten waarden naar de robotarm worden verzonden
int response_time =1000; 

De volgende code geeft een overzicht van de Arduino die de waarden van de sensoren leest:

// lees de waarden van Flex Sensors naar Arduino
pinkie =analogRead(pinkie_Data);
finger =analogRead(finger_Data);
thumb =analogRead(thumb_Data); 

Lees de huidige positie van de versnellingsmeter:

GetMpuValue1(MPU1);
GetMpuValue2(MPU2); 

De waarden kalibreren:

De volgende code kalibreert om de boven- en ondergrens van de flexibele sensor te vinden. Om de flexhandschoen opnieuw te kalibreren, drukt u op de resetknop op de Arduino.

if (bool_caliberate ==false ) {
delay(1000);
thumb_high =(thumb * 1.15);
thumb_low =(thumb * 0.9);
finger_high =(vinger * 1,03);
finger_low =(vinger * 0,8);
pinkie_high =(pinkie * 1,06);
pinkie_low =(pinkie * 0,8);
bool_caliberate =waar;
} 

Op basis van de kalibratie controleren we voortdurend of de huidige waarde de boven- of ondergrens van de gedefinieerde flex heeft overschreden. Als de flexsensor boven of onder deze waarde komt, worden gegevens naar de robotarm gestuurd om een ​​specifieke servomotor in een specifieke richting te bewegen.

// finger 1 - Claw Bend/Open
if (finger>=finger_high) {
Serial.print("F");
delay(response_time);
}
if (vinger <=finger_low) {
Serial.print("f");
delay(response_time);
} 

De robotarm programmeren

Resultaten – Uitbetaling

De robotarm is nauwkeurig genoeg om objecten te verplaatsen. Het zal echter wat werk vergen om complexe objecten te verplaatsen, of zelfs concurreren met de 'miljoen-plus-jaar' die mensen hebben op behendigheid ... hoewel meer tijd besteden aan het werken aan de code, kan de precisie van de robot zijn zoals bedoeld voor MARK 1i . Hoewel de arm kan worden verbeterd, kan deze aanzienlijk worden verbeterd.

Als je de code wilt verbeteren, draag dan bij aan de Arduino Robotarm Git Repo en bouw je arm op. Laten we dit openstellen voor anderen om op voort te bouwen!

Ten slotte kunnen we de robot ook besturen met handgebaren en de robot programmeren om basistaken te automatiseren.

Volgende stappen

En dat is alles voor MARK 1-mensen! Als je dit project leuk vindt, overweeg dan om mijn Patreon-pagina te steunen.

Code

• Codefragment #1
• Codefragment #3
• Codefragment #4
• Codefragment #5
• Codefragment #7
• Codefragment #11
• Codefragment #12

Codefragment #1Platte tekst

* Voeg de HCPCA9685-bibliotheek toe */#include "HCPCA9685.h"/* I2C-slaveadres voor het apparaat/de module. Voor de HCMODU0097 is het standaard I2C-adres 0x40 */#define I2CAdd 0x40/* Maak een instantie van de bibliotheek */HCPCA9685 HCPCA9685(I2CAdd);//initiële parkeerpositie van de motorconst int servo_joint_L_parking_pos =60;//Graad van robotservo gevoeligheid - Intervalsint servo_joint_L_pos_increment =20;//Houd de huidige waarde van de motorposities bij 
Codefragment #3Platte tekst 
 
//Definiëren van de servo-driver. 0x40-adres is het standaard I2C-adres.#define I2CAdd 0x40 int response_time =5; // Waarden ontvangen van het Robotic Glove-interval // Controleert of gegevens afkomstig zijn van de seriële poort if (Serial.available()> 0) { state =Serial.read(); // Leest de gegevens van de seriële poort Serial.print(state); // Drukt de verzonden waarde af // Motorfunctionaliteit codeblok}
 
Codefragment #4Platte tekst 
 
if (Serial.available()> 0) { // Controleert of gegevens afkomstig zijn van de seriële poortstatus =Serial.read(); // Leest de gegevens van de seriële poort Serial.print(state); // Drukt de verzonden waarde af // Raadpleeg voor de naamgeving van de motoren het artikel / tutorial // Move (Base Rotation) Stepper Motor Left if (state =='S') { baseRotateLeft(); vertraging (responstijd); }}
 
Codefragment #5Platte tekst 
 
HCPCA9685.Servo(0, servo_joint_L_parking_pos_i); // Stuur de servomotor op kanaal 0 naar de gewenste hoek.// Beweeg de klauwmotor naar beneden als (state =='f') {if (servo_joint_3_parking_pos_i  
Codefragment #7Platte tekst 
 
//LED AAN PIN 3int pinkie_Data =A1;int finger_Data =A2;int thumb_Data =A3;//const int MPU_addr =0x68;const int MPU2 =0x69, MPU1 =0x68;
 
Codefragment #11Platte tekst 
 
 if (bool_caliberate ==false ) { delay(1000); thumb_high =(duim * 1,15); thumb_low =(duim * 0,9); finger_high =(vinger * 1.03); finger_low =(vinger * 0,8); pinkie_high =(pinkie * 1.06); pinkie_low =(pinkie * 0,8); bool_caliberate =waar; }
 
Codefragment #12Platte tekst 
 
 // vinger 1 - Claw Bend/Open if (finger>=finger_high) { Serial.print("F"); vertraging (responstijd); } if (vinger <=finger_low) { Serial.print("f"); vertraging (responstijd); }
 
Github
 http://github.com/EbenKouao/arduino-robot-armhttp://github.com/EbenKouao/arduino-robot-arm 
Github
 https://github.com/EbenKouao/arduino-robotic-armhttps://github.com/EbenKouao/arduino-robotic-arm

Aangepaste onderdelen en behuizingen

Thingiverse

https://www.thingiverse.com/thing:1748596CAD-bestand op thingiverse.com

Thingiverse

https://www.thingiverse.com/thing:1750025CAD-bestand op thingiverse.com

Thingiverse

https://www.thingiverse.com/thing:1838120CAD-bestand op thingiverse.com

Thingiverse

https://www.thingiverse.com/thing:1982745CAD-bestand op thingiverse.com

Schema's

Robotarm Git Repo

https://github.com/EbenKouao/arduino-robot-arm