As noted in the piktul Pick'N'Place adventure, the value of a robotic arm is in its ability to perform repetitive movements with high precision. While the Lynx-6 is probably more inaccurate than the piktul given that it must contend with gravity effects that impact the joint space, it should perform well enough to reliably pick up an object at the desired configuration with parallel plate grippers (like those of the piktul and most of the Lynx-6 robots).

Since the Lynx-6 is a full 3D robotic arm, the pick and place end-effector configurations will be given as $SE(3)$ elements. The procedure should go more or less the same with the pick and place routine commanding the manipulator to specific end-effector $SE(3)$ configuration and gripper opening. At that pick configuration it then lowers the arm to the height of the object to grasp it. Once there, the gripper should close enough to grab it (but not to stress and break the motor gears). The manipulator arm raises, moves to be “above” the place $SE(3)$ configuration, then lowers. The gripper is opened to release the object, then raised. Once raised, it returns to the home position.

Since the Lynx-6 cannot raise of lower directly in the $z$-direction, the best thing is to simply “raise” and “lower” by using the second joint variable which causes the end-effector to follow an arc up and down. It you are adventurous enough to work out the math, you can convert the desired vertical movement at the desired end-effector configuration into a desired changed in joint angle $d\alpha_2$ based on the relationship $dz \approx R\, d\alpha_2$ where $R$ is the distance from the axis of rotation for $\alpha_2$ to the end-effector position.

In the first version, as is typically for many factory automation processes, the pick and place configurations are known in advance. Thus, all that is needed is to program the robot to execute the maneuver, then to set the program in an infinite loop to forever repeat the action. Since they are known, the initial and final configurations are actually determined beforehand as joint angle, then entered into the program. Here, your task is to flesh out such a pick-n-place routine for the joint angles specified.

In the second version, the configurations may change over time. Such would be the case when a flexible or adaptive (manufacturing) process is needed. Rather than specify the joint configurations then, the end-effector configurations are given. Internally, the robot's program should use inverse kinematics to establish what the pick and place end-effector configurations are, then execute the operation (again, in an infinite loop or until the configurations change). Here, your task is to modify the original hard-coded pick-n-place routine to be more flexible. Really, you will most likely create a new routine that takes in end-effector configurations first, converts them to joint configurations, then calls the former pick-n-place routine.

The member function code created for this should be somewhat generic. I would recommend creating a pick and place routine for the joint angles that takes the pick and place revolute joint angles (each a 1×6 vector), the target upper and lower delta heights (1×2 vector), the gripper widths (2 vector), and a timing vector specifying how long each part of the sequence should take, then creates the execution sequence and executes. If the timing sequence is missing, then some default timing should be applied.

The pick and place routine for end-effector configurations should have a similar set of arguments and solve the inverse kinematics part to get the joint angles, then invoke the pick and place routine for joint angles.

The solution should not be hard-coded for the actual tasks given. The scripts you've been given should act as a good starting point for how the pick and place functions should work. The demo will involve assessing both execution of the task, as well as ability to actually grip, pick up, and place the object.

Here is how the pick and place program will work, given initial and final end-effector configurations,

1. Given initial and final end-effector configurations, the program will compute then output the expected initial and final joint configurations of the manipulator are. Use pause command to wait for user to hit Return. Make sure to respect actuator limits when considering which of the possible inverse kinematics solutions to use.
2. Goto the initial joint configuration specified but with $\alpha_2$ changed so that the second joint rotates up a little bit and $\alpha_6$ so that the gripper is fully open. Do this to take about 2-3 seconds using the pause command to wait for the specified amount of time.
3. Goto the joint configuration requested by setting $\alpha_2$ to its desired value. This should lower the end-effector to the predicted configuration. If the prediction is correct, then the gripper will be around an object that I have placed near the initial location. Do this to take two seconds and pause in Matlab for that amount of time.
4. Close the gripper to the desired length thereby grabbing the object (The desired length is given as a part of the joint configuration). Do this to take two seconds, pausing in Matlab.
5. Lift the gripper to the configuration from step 2, but keeping the gripper closed. One to two second motion here.
6. Move the arm to the final joint configuration, but changing $\alpha_2$ so that the arm is still elevated from the final end-effector configuration that would normally have been realized. Four seconds for this movement.
7. Now, modify the second joint so that it lowers the end-effector to the desired position in two seconds.
8. Open the gripper in one second.
9. Lift the gripper by changing $\alpha_2$; take two seconds.
10. Goto your sleep position.

Ideally, the program should pre-compute all of the joint configuration and timings, place them in a matrix and a vector, respectively, then just execute in a for loop. that's really the easiest as it recycles a lot of prior code.

Demo movie here. You may have to download to play, until I figure out how to embed. In the movie, I place a block at the initial location, a Kroger plus card at the final location, then let the manipulator do its thing. If you programmed it right and calibrated it properly, your program should execute like mine. Good luck!

A former student from the first time that the manipulation track was included in the course uploaded onto YouTube his own version of pick and place with three stacked blocks. Even gave it a soundtrack!

Back – Main