The goal of this project was to use ROS with Gazebo and MoveIt to write my initials in space with a simulated UR5e robotic arm. The project was an exercise in motion planning and a gentle introduction to the MoveIt Python interface. At a high level, the approach was to:
- Establish a connection to the robot using the Python interface for MoveIt
- Define the initials of my name as a series of poses
- My initials are TEO; for the T and E, I manually found points in space that create the desired path
- For the O, I used sine/cosine to calculate points around an ellipse that fits within my workspace
- Move to each pose in my plan
- For the T and E, set each pose in my path as the robot’s move group’s pose goal, then execute a trajectory to that pose, which is automatically planned by MoveIt
- For the O, use a cartesian path planner to calculate my path and set each pose as a waypoint, which allows the robot to move smoothly between the points around the ellipse of the O without stopping at each point
Here's a video of the final result!
As part of the project write-up, I also completed some basic kinematic analysis of the UR5e robot and several of the key poses I used to create my initials. First, here's the robot's DH table, which describes the configuration of its joints and links:
I also analyzed three key poses that I used for my initials. I won't include them all here, but here's a sample of the kind of work that involved:
For the most part, the biggest challenge with this project was the learning curve. It took me a long time, at first, to figure out how all the parts connected and how to even get started and set up my planning script. However, once I figured it out and got it working, creating the actual trajectories and doing the coding wasn’t too difficult.
One other small issue I faced was that if I made my movements too big, the planning would fail or give me some very wacky trajectories/my robot would shake itself to death. I got around this problem by keeping my movements small and limiting my workspace to an area I knew I could get away with.
If I had more time, I could add to this project by generating my poses programmatically based on the robot’s environment, in some way. For example, I could try to program the robot to be gesture-controlled and try to match your hand’s movements. I could even try to do some tasks with the end-effector, like picking up a cup or block on a table and moving it somewhere else.
For the final project, I think it’d be really cool to program a robot like this to play a game against you. That might involve moving around checkers, drawing on a piece of paper (for tic-tac-toe or similar) or something of the sort.
Two of my biggest takeaways from this project were:
- Writing your code so it’s reusable is so incredibly helpful. Spending the time up-front to define helper functions or data structures that simplify your workflow is such a good idea. Especially when you have to repeat a task 10 or 20 times, it’s a lot better than copying/pasting the code. This also goes for calculating A matrices/Jacobians in Maple — I defined functions to do it and then was just able to plug in my joint angles for each pose, which made my life so much easier.
- Read the documentation! If you understand what’s going on it’s so much easier to figure out what’s wrong and to debug. Also, if you try to cobble together a solution from example code you find online, it might work sometimes, but it also might fail catastrophically and you’ll spend forever debugging. If you just read the documentation in the first place and know what your code does, it’s much easier to build something robust and extensible.