1
$\begingroup$

I want to build a robot arm that'll be approximately 1.25 meter long and will be able to lift up to 2 kilograms. It'll have 6 dof and it is an expensive project. And most importantly, i am the only programmer in this brand new robotics facility of ours. :)

The robot that i want to build will be led by Inverse Kinematics, so with all these parameters and matrices, i think that i'll need a tough processor (Not so sure).

Assuming that my robots control interface will be on an Android tablet, i thought that i also could develop my program for Android, and send necessary commands to the control chip via RS-232 interface.

So, my question is, are standart 1 GHz Android tablets suitable for these tasks? If not, has anybody got an advice for me?

$\endgroup$
  • 1
    $\begingroup$ There is no way to answer this question with the information given! My advice, like for most performance questions, is profile it. The only way you can know how your code and work load will perform on any given hardware is to try it and measure the performance. $\endgroup$ – Mark Pitchless Nov 13 '12 at 11:26
  • $\begingroup$ have a google? see what others have done $\endgroup$ – Mark W Nov 13 '12 at 11:35
  • $\begingroup$ Yeah, well, i'm afraid the others haven't done anything alike. Even tough there are some usage of Android on some robot arm projects, none of them are beyond hobby projects. They don't need too much current, they don't have 6 dof, etc. And for this reason, they're not hard enough to compare. $\endgroup$ – 3yanlis1bos Nov 13 '12 at 12:59
  • $\begingroup$ @Mark i think that you've got a point. I should give more details, you're right. The problem is, it's the only detail that i have right now. So, it could help a lot more, if you could tell me how to make a more clear profile of my robot. $\endgroup$ – 3yanlis1bos Nov 13 '12 at 13:03
  • $\begingroup$ I think you need to focus this question more. The physical dimensions are independent of the computing requirements, so don't include them. The computing requirements are flexible too; the faster your processor, the more movements per second/minute you'll be able to plan out. Can you provide more details on what you require for that? Also, is there a specific need to use a tablet computer instead of a desktop computer for this? If so, why? $\endgroup$ – Ian Nov 13 '12 at 16:27
1
$\begingroup$

This is a much bigger project than you think, and processing power is the least of your concerns. You may want to skip straight to step #9. Otherwise, here are some questions you need to ask yourself, based on my experience of building something very similar as a hobby project (I used a desktop PC for processing):

1: Exactly how far should the robot reach? You say 1.25 meters - but at what height, and in what direction? If it absolutely must reach anything within a 1.25 meter dome around its base, then either it's maximum reach must be longer, or you have a very big engineering challenge. Look at some of the robots from Fanuc or Kuka; their online catalogs have cutout views that show how far the arm will reach in each direction, and those areas are never perfect domes. Also, how close to the base must the robot reach? If the first arm (from the base) is significantly longer than the 2nd arm, then it won't be able to reach anything close to the base. Also, 6 DOF DOESN'T MEAN IT CAN HAVE ANY POSITION WITH ANY MOVEMENT! The shoulder and elbow joints of robot arms are almost always in the same DOF (and sometimes the wrist too). You can move the arm in any direction or hold the grasper in any orientation, but you can't do both at the same time. If you look at the human arm, the shoulder has 3 DOF, the elbow has one, the forearm has one, and the wrist has two. That's 7 in total, and that's what you need for total flexibility. If you search for 7 DOF, you'll see examples showing how they can move in ways that 6 DOF arms can't. This may not be important for your project, but it's important to know because otherwise you may do a lot of needless debugging.

2: Start with the grasper first. There are companies that make these specially, and it's best to look at their work to see what you might need. These can be very expensive parts if they need motors or sensors. This is the most important part of the arm, and fortunately it's the first part you can prototype and test. Figure out what you want, cheaply and quickly fabricate a version yourself, and move it around by hand to ensure it actually does what you want it to do. You may find that it needs to do more or less than you expected. I've seen people learn a lot simply by using a pair of popsickle sticks.

3: Exactly how much force should the arm lift? Start with the outermost part, the end effector (aka grasper/gripper/whatever). That needs to have a grip capable of holding 2kg, or roughly 20 newton-meters (you'll be doing all forces in newton-meters now; it's a lot easier than foot-pounds because 1kg is 9.8NM, and it's best to round up). How does it hold it? Does it pinch sideways? If so, it needs to have some amount of grip. If it lifts from the bottom like a fork, it needs to have a certain amount of torque in the last up/down DOF. We'll come back to this.

4: (AKA #3 part 2) Now that you know what the end effector needs to do, you can get a better idea of how it should be shaped and how much it will weigh. And after going through step 1 and lots of graph paper, you may know how long each segment of the arm needs to be. With this knowledge, you can start calculating how much each segment will weigh and therefore how much force each DOF needs to support. It's safest to calculate this with each segment fully outstretched, but for the lowest 2 joints you may be able to estimate that they will always be at an angle and therefore don't need quite as much force.

5: Time to look at motors, the beautiful yet evil Medusa of robotics. Again, what does the robot need to do? Does it need to be fast, or powerful, or precise? If it needs precision but can be slow, you may need geared stepper motors. If it needs to be fast or powerful, you may need geared DC or AC motors. Speaking of which, DC motors will probably be easier to control. But each of these options have problems; stepper motors are quite weak and they don't know their position, while DC and AC motors simply don't know their positions. You'll need rotary encoders for DC/AC motors (incremental encoders at minimum), and may need absolute encoders no matter which motor type you choose. Absolute encoders tell you the exact angle of the arm, incremental ones will only tell you the change in angle. So, absolute encoders are better, but they are also much more expensive. You can avoid this problem by purchasing industrial servo motors (which look a lot like the stepper motors), but those are much more expensive because they have rotary encoders already built in. But those servos may be worth it just for the easier integration, if the maker has a nice software package that you can use.

6: You'll need to power all these motors (probably through drivers, which are another piece of hardware), and also power all the sensors and controllers, and they probably won't require the same voltage. Hopefully your motors can at least share a single voltage. You can buy velcro loops and labels in bulk.

7: Don't forget the weight of the motors in the arm; you'll need to include that when calculating the torque required for the next motor.

8: Make sure you have some arrangement for fast and cheap shipping of new components, and whatever discounts possible.

9: Realize this is way too complicated, and look up a robot refurbisher/supplier in your area. Retired industrial robots are much cheaper than new ones, and they can help you get set up and figure out what adjustments you need.

$\endgroup$
2
$\begingroup$

This project sounds quite plausible. The question is, where do the servo loops happen? Does it go through the Android Tablet, or just the control chip? What chip is this?

If the servo loops go through the tablet, then be warned that the tablet needs to be able to process that servo loop in good time each cycle. No being late, or missing cycles. No sudden waiting for a WiFi connection, or spending too much time doing voice recognition. It doesn't need to be hard real time (ROS isn't for example) but it should be fairly reliable.

If the servo loop goes only through the control chip, whatever that is, then that would be much better. The tablet would just send demand values to the control chip, and it wouldn't matter so much if these were a bit late or were skipped.

Your robot arm is only 6 degrees of freedom, meaning the Inverse Kinematics function can be solved analytically every control cycle, and will be very fast. 1GHz is actually quite a fast processor. I used to do IK on a 12 DOF simulation in QBASIC on an old 486, and could easily get 30 FPS.

$\endgroup$
  • $\begingroup$ What i call as the chip turns out to be a MAXON EPOS 2, but i'm not really sure about the cycles. My first thought was leaning on Android in all our needs. So, because of my lack of knowledge about this controller, i'll continue with my first approach for now. But thanks a lot for your comprehensive support. :) $\endgroup$ – 3yanlis1bos Nov 13 '12 at 14:49
  • $\begingroup$ @3yanlis1bos - Given that the EPOS is going to do all of your low level hard real-time servo loop control, your tablet is going to be doing just the soft real-time motion planning, kinematics and GUI, so this is more a user experience issue. You may even be able to use OpenCL to get the GPU to accelerate the kinematic modelling. $\endgroup$ – Mark Booth Nov 15 '12 at 0:49
0
$\begingroup$

It looks like you are implementing Inverse kinematics(IK) control of robot manipulator for first time. I would suggest you to start of inverse kinematics control program in regular computer. Once you have implemented stable IK control program, you can implement the same same for Android tablet.

Please don't complicate the task which is already complicated! Best way start is to keep building of arm and developing IK control for the arm as separate modules and integrate them once both modules are working properly. For IK control program you can start off with simulated robot arm. Building reliable 6 DoF arm of reach 1.25 meter is definitely not easy job, especially if you are doing it for first time. It would be good idea to start with smaller prototype and later scale it up required size.

$\endgroup$
  • $\begingroup$ Mythoughts exactly, about programming on tablet. I'm planning to develop it on my PC with java first, then i'll do the same for Android like you said. But for arm, i have a companion who is an expert at mechanics, so, the metal part will be a lot easier. (Won't be alone at least.) Even tough there are two of us in this business, we'll use some second hand material to prevent bigger financial losses. But i'll consider your prototype advice as well. $\endgroup$ – 3yanlis1bos Nov 13 '12 at 14:36
0
$\begingroup$

How many degrees of freedom do you plan to implement?

I use Arduino Mega for my arm with 4 axis and plan to use simple ARM processor instead it.

$\endgroup$
  • $\begingroup$ You may be able to improve your answer by linking your experience to the question asked, whether the 1 GHz tablet is suitable for the task. $\endgroup$ – ronalchn Nov 14 '12 at 7:20
  • $\begingroup$ Like i said, it'll have 6 dof. $\endgroup$ – 3yanlis1bos Nov 14 '12 at 8:23

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.