Robot Not a Dev? Pre-order Now
Not a Dev?

Robot Arm for Misty II

robots

#1

Continuing the discussion from Misty Robotics blog: Who will win the robot "arms" race?:

Continuing the discussion from Snap-on/Slide-in body

Speaking of the snap-on body parts and the “arms” race, what kind of motors do you think would work for a Misty II arm? Currently we have one degree of freedom from the shoulder joint, and are experimenting with at least one more in the actual arm design. The clear options are servo and regular brush-less dc, but stepper motors are cheaper and just as accurate. What would you recommend?

We’re performing preliminary calculations this weekend to get torque estimates and preparing to 3D print our initial prototypes. Will keep updating as progress is made.


#2

This is an excellent question for @steven


#3

Greetings group. I’m looking forward to seeing more of your design and how you choose to handle some of the challenges that come with building a robot arm. Plenty of different ways to do it, each with its advantages and disadvantages. Similarly, motors each come with advantages and disadvantages, and the choice highly depends on the rest of your arm’s design and other constraints like time and cost.

First some general thoughts on motors. Because this is an arm project, I’m referencing everything below to position control of the motor, not speed control.

  • Servos are likely going to be the easiest motor to integrate into your project, both structurally and electrically. The advantage to servos is they have all the gearing, position sensing, and position control built right into the unit. While you’ll pay more for it, you’ll be able to get it done in less time. Its also likely that it will have better position control than you could do yourself with the other motors (unless you’ve been doing position control for awhile). They are usually light enough that it can likely be integrated right in at the joint of the arm and still be lifted by the actuators controlling anything higher up on the arm (like the shoulder motor).

  • Stepper motors will likely have as good as or even better accuracy in position as the servos. Because you control the steps, you’ll inherently know your relative position, but you’ll have to add an absolute encoder to know exactly where you are. After servos, they’ll have the easiest control algorithm. They do have the disadvantage of having the highest power draw, especially while holding a position. Because of this, they are also the heaviest motor you could choose, and it is less likely you’ll be able to put them right at the joint without working the shoulder motor extra hard.

  • Regular brushed DC motors are small and light and with the right gearbox could provide the same torque as a stepper, but they will require a more complex control algorithm, and without spending a LOT of time tuning that algorithm, the accuracy in position won’t be quite as good. They are as easy to integrate electrically as the stepper motor, though likely harder to integrate structurally (depends on which DC motor you buy) and mechanically (because of the complex gearbox). Again you’ll also need your absolute position sensing for feedback. These are generally the cheapest option, especially when including the driver electronics.

  • Brushless DC have better torque than brushed DC and can be stepped for position control. They aren’t optimized for stepping, so the control algorithm is a bit more complex and you won’t get quite as good accuracy as with the stepper motor. They have high enough torque that you might not need a gearbox, depending on the mechanics of your arm and the load you plan on carrying. They have a slightly more complex electrical need (as they require 3 phase control rather than 2 of the stepper and 1 of the brushed DC). BLDC motors are almost always the motor of choice in unmanned aircraft camera gimbals because of their light weight and high torque. You’ll just spin with this motor unless, once again, you have your absolute position sensing.

Both brushed and brushless DC motors will require more complex motor control algorithms than servo or stepper motors.

Its a hard thing to recommend motor selection without understanding your design. However given your circumstances I’ll give you this peice of advice: the greatest learning comes from the hardest projects. The more you push yourselves, the more you’ll learn. As this is a project for school, where you have more resources to help you, and learning is your primary goal, you should consider taking a harder path that will lead to the greatest learning (obviously keeping cost and time constraints in mind). Keep that in mind as you make your choices. I took that approach through school and I am always very glad that I did.

I’m definitely a resource you can use on this project. Don’t hesitate to use me if you need greater clarity on any of this to make your selection easier. If you are willing to share your design with me I can definitely help guide you or make recommendations on motor selection for your particular case. Or if you have any other questions concerning your arm design. I am eager to see some skills run on Misty once your arm is integrated!


#4

You should check out the XL-320 servos from ROBOTIS. Best all-round servo for it’s price, size and performance.


#5

Hey everyone,

Thank you for the advice and recommendations! I did not get back to everyone last week because we are figuring some more things out before definitive torque calculations. We have decided on using servos (thank you @steven for your post and @moverstreet007 for the recommendation on motors) for our general movement and a brushless dc motor for one of our prototypes to move a rack. With this in mind, we’re picking our micro-controller to have servo and regular dc motor control, but are pondering which language it should be programmable in. Arduino is relatively easy, embedded C is pretty common, but since we do not fully know the Misty community this is something we thought to bring up here. What language(s) would be comfortable for the developer community?


#6

Heya ya’ll.

@moverstreet007, thanks for the recommendation! Thats a good servo, in large part because you can communicate with it to get its actual position, which is crucial if the arm is going to have more than a single joint. You’ll need that information to do your kinematic equations.

As for the language…our community is pretty diverse, we’ll range from developers with only Javascript experience to programmers with various levels of C++/Python/Javascript to embedded hardware folks with lots of embedded C experience. Its likely that all of them will have had experience in Arduino, or been exposed to it in some way.

If you’re not planning on making the code open, and just letting people work through the robot’s backpack API, then writing it in C gives you more flexibility and control. If you plan on opening the code up to let people muck around in it, then writing it in Arduino is likely going to make it useable by a wider group of skill-sets.

Ultimately there are no wrong answers here, so also consider how much time you have to dedicate to your project and which languages you’re most comfortable with.

Just my two cents anyway. :slight_smile:


#7

My take on the language is that you can always wrap an easier library around a C core library, and C gives you most control for an embedded device. So my recommendation would be to go for C and then wrap that later if you want to make it more accessible, once it’s all working.

But I am heavily biased :smiley:


#8

I like both takes, and @Vlad C definitely is something we are more comfortable with. @steven our plan is to let people have access to the code to do what they want, so arduino is certainly the safer choice there. I’ve uploaded the block diagram of what we’re working for microcontrollers on to show you guys what the basic design is. We’re definitely going to need a motor controller because we have 4-10 servos based on which design prototype we end up going with.


#9

Keep in mind that, as Vlad says, you can do the bulk of your low-level work in C, then write it into an Arduino library wrapper to be used by those that don’t want the super low-level work but still want to do something different with the arm. Best of both worlds kinda thing. If you’re comfortable in C, write it in C.

On the high level, if you’re using servos you can get rid of the Motor Driver block, as they have that built in. If you use the ones recommended above, its even easier as you can daisy-chain all of them and use just a single UART line on your MCU.

I was picturing a single elbow joint arm. I’m even more eager to see this final product now that you mentioned more motors! :slight_smile: