ROS MoveIt robotarm deel 2: robotcontroller - Ajarnpa

2024 Auteur: John Day | [email protected]. Laatst gewijzigd: 2024-01-30 11:17

github.com/AIWintermuteAI/ros-moveit-arm.git

In het vorige deel van het artikel hebben we URDF- en XACRO-bestanden voor onze robotarm gemaakt en RVIZ gelanceerd om onze robotarm in een gesimuleerde omgeving te besturen.

Deze keer doen we het met de echte robotarm! We zullen de grijper toevoegen, een robotcontroller schrijven en (optioneel) IKfast inverse kinematics solver genereren.

Geronimo!

Stap 1: De grijper toevoegen

Het toevoegen van grijper was in het begin wat verwarrend, daarom heb ik dit onderdeel in het vorige artikel overgeslagen. Het bleek uiteindelijk niet zo moeilijk te zijn.

U moet uw URDF-bestand aanpassen om grijperkoppelingen en verbindingen toe te voegen.

Het gewijzigde URDF-bestand voor mijn robot is bij deze stap gevoegd. In principe volgt het dezelfde logica als het armgedeelte, ik heb zojuist drie nieuwe links toegevoegd (claw_base, claw_r en claw_l) en drie nieuwe gewrichten (joint5 is vast en joint6, joint7 zijn revolute gewrichten).

Nadat u uw URDF-bestand hebt gewijzigd, moet u ook het door MoveIt gegenereerde pakket en xacro-bestand bijwerken met behulp van de MoveIt-configuratie-assistent.

Start setup-assistent met de volgende opdracht:

roslaunch moveit_setup_assistant setup_assistant.launch

Klik op Bestaande MoveIt-configuratie bewerken en kies de map met uw MoveIt-pakket.

Voeg een nieuwe planningsgroepgrijper toe (met schakels en verbindingen voor de grijper) en ook een eindeffector. Mijn instellingen staan in de screenshots hieronder. Merk op dat je geen kinematics solver kiest voor de grijper, dat is niet nodig. Genereer het pakket en overschrijf de bestanden.

Loop

katjes maken

commando in uw catkin-werkruimte.

Oké, nu hebben we een arm met een grijper!

Stap 2: De arm bouwen

Zoals ik al eerder zei, is het 3D-model van de arm gemaakt door Juergenlessner, bedankt voor het geweldige werk. De gedetailleerde montage-instructies zijn te vinden als u de link volgt.

Wel moest ik het besturingssysteem aanpassen. Ik gebruik Arduino Uno met Sensor Shield voor het aansturen van servo's. Sensorschild helpt veel bij het vereenvoudigen van de bedrading en maakt het ook gemakkelijk om de externe voeding aan servo's te leveren. Ik gebruik 12V 6A voedingsadapter bedraad via step-down module (6V) naar Sensor Shield.

Een opmerking over servo's. Ik gebruik MG 996 HR-servo's die ik bij Taobao heb gekocht, maar de kwaliteit is echt slecht. Het is zeker een goedkope Chinese knock-off. Die voor het ellebooggewricht leverde niet genoeg koppel en begon zelfs een keer te roken onder zware belasting. Ik moest de ellebooggewrichtservo vervangen door MG 946 HR van een fabrikant van betere kwaliteit.

Om een lang verhaal kort te maken - koop servo's van hoge kwaliteit. Als er magische rook uit je servo's komt, gebruik dan betere servo's. 6V is een zeer veilige spanning, verhoog deze niet. Het verhoogt het koppel niet, maar kan de servo's beschadigen.

Bedrading voor servo's als volgt:

basis 2

schouder2 4schouder1 3

elleboog 6

grijper 8

pols 11

Voel je vrij om het te veranderen, zolang je er ook aan denkt om de Arduino-schets te veranderen.

Nadat u klaar bent met hardware, laten we eens kijken naar het grotere geheel!

Stap 3: MoveIt RobotCommander-interface

Dus wat nu? Waarom heb je MoveIt en ROS eigenlijk nodig? Kun je de arm niet gewoon rechtstreeks via Arduino-code besturen?

Ja, dat kan.

Oké, hoe zit het nu met het gebruik van GUI of Python/C++ code om een robothouding aan te bieden om naar toe te gaan? Kan Arduino dat?

Soort van. Daarvoor moet je een inverse kinematica-oplosser schrijven die een robothouding aanneemt (vertaal- en rotatiecoördinaten in 3D-ruimte) en deze omzet in gezamenlijke hoekberichten voor servo's.

Ondanks dat je het zelf kunt doen, is het ontzettend veel werk om te doen. Dus, MoveIt en ROS bieden een mooie interface voor IK (inverse kinematics) solver om al het zware trigonometrische tillen voor je te doen.

Kort antwoord: Ja, je kunt een eenvoudige robotarm maken die een hardgecodeerde Arduino-schets uitvoert om van de ene pose naar de andere te gaan. Maar als u uw robot intelligenter wilt maken en computer vision-mogelijkheden wilt toevoegen, zijn MoveIt en ROS de juiste keuze.

Ik heb een zeer vereenvoudigd diagram gemaakt waarin wordt uitgelegd hoe het MoveIt-framework werkt. In ons geval wordt het nog eenvoudiger, omdat we geen feedback van onze servo's hebben en het onderwerp /joint_states gaan gebruiken om de robotcontroller de hoeken voor servo's te geven. We missen slechts één onderdeel en dat is de robotcontroller.

Waar wachten we op? Laten we wat robotcontrollers schrijven, zodat onze robot … je weet wel, beter bestuurbaar zou zijn.

Stap 4: Arduino-code voor robotcontroller

In ons geval zal Arduino Uno met een ROS-knooppunt met rosserial de robotcontroller zijn. De Arduino-schetscode is bij deze stap gevoegd en is ook beschikbaar op GitHub.

Het ROS-knooppunt dat op Arduino Uno draait, onderschrijft in feite het /JointState-onderwerp dat is gepubliceerd op de computer waarop MoveIt draait en converteert vervolgens de gezamenlijke hoeken van de array van radialen naar graden en geeft deze door aan servo's met behulp van de standaard Servo.h-bibliotheek.

Deze oplossing is een beetje hacky en niet hoe het wordt gedaan met industriële robots. Idealiter zou je het bewegingstraject op /FollowJointState-onderwerp moeten publiceren en vervolgens de feedback op /JointState-onderwerp ontvangen. Maar in onze arm kunnen de hobbyservo's de feedback niet geven, dus we zullen ons gewoon direct abonneren op /JointState-onderwerp, gepubliceerd door FakeRobotController-knooppunt. In principe gaan we ervan uit dat alle hoeken die we aan servo's hebben doorgegeven, ideaal worden uitgevoerd.

Voor meer informatie over de werking van de rosserial kun je de volgende tutorials raadplegen:

wiki.ros.org/rosserial_arduino/Tutorials

Nadat je de schets naar Arduino Uno hebt geüpload, moet je deze met de seriële kabel aansluiten op de computer waarop je ROS-installatie draait.

Voer de volgende opdrachten uit om het hele systeem te openen:

roslaunch my_arm_xacro demo.launch rviz_tutorial:=true

sudo chmod -R 777 /dev/ttyUSB0

rosrun rosserial_python serial_node.py _port:=/dev/ttyUSB0 _baud:=115200

Nu kunt u interactieve markeringen in RVIZ gebruiken om de robotarm in een pose te brengen en vervolgens op Plan and Execute drukken om de robotarm daadwerkelijk in de positie te brengen.

Magie!

Nu zijn we klaar om Python-code te schrijven voor onze ramptest. Nou bijna…

Stap 5: (Optioneel) IKfast-plug-in genereren

Standaard stelt MoveIt voor om KDL kinematics solver te gebruiken, wat niet echt werkt met minder dan 6 DOF-armen. Als je deze tutorial nauwlettend volgt, zul je merken dat het armmodel in RVIZ niet in sommige houdingen kan gaan die door de armconfiguratie zouden moeten worden ondersteund.

De aanbevolen oplossing is om een aangepaste kinematica-oplosser te maken met behulp van OpenRave. Het is niet zo moeilijk, maar je zult het moeten bouwen en het is afhankelijk van de bron of gebruik de docker-container, wat je maar wilt.

De procedure is zeer goed gedocumenteerd in deze tutorial. Het is bevestigd dat het werkt op VM's met Ubuntu 16.04 en ROS Kinetic.

Ik heb de volgende opdracht gebruikt om de oplosser te genereren:

openrave.py --database inversekinematics --robot=arm.xml --iktype=translation3d --iktests=1000

en toen rende

rosrun moveit_kinematics create_ikfast_moveit_plugin.py test_robotarm my_arm_xacro ikfast0x1000004a. Translation3D.0_1_2_f3.cpp

om MoveIt IKfast plug-in te genereren.

De hele procedure is een beetje tijdrovend, maar niet erg moeilijk als je de tutorial goed volgt. Als je vragen hebt over dit onderdeel, neem dan contact met me op in de comments of PM.

Stap 6: De hellingstest

Nu zijn we klaar om de ramp-test uit te proberen, die we zullen uitvoeren met behulp van de ROS MoveIt Python API.

De Python-code is aan deze stap gekoppeld en is ook beschikbaar in de github-repository. Als je geen helling hebt of een andere test wilt proberen, moet je de robothoudingen in de code wijzigen. Voor die eerste uitvoering

rostopic echo /rviz_moveit_motion_planning_display/robot_interaction_interactive_marker_topic/feedback

in de terminal wanneer RVIZ en MoveIt al worden uitgevoerd. Verplaats vervolgens de robot met interactieve markeringen naar de gewenste positie. De positie- en oriëntatiewaarden worden in de terminal weergegeven. Kopieer ze gewoon naar de Python-code.

Om de ramptestrun uit te voeren:

rosrun my_arm_xacro pick/pick_2.py

met RVIZ en rosserial node al actief.

Blijf op de hoogte voor het derde deel van het artikel, waar ik een stereocamera zal gebruiken voor objectdetectie en een pick-and-place-pijplijn zal uitvoeren voor eenvoudige objecten!