Hand manipulator do-it-yourself drawings. Do-it-yourself desktop robotic arm manipulator made of plexiglass on servo drives

Of the features of this robot on the Arduino platform, one can note the complexity of its design. Roboarm consists of many levers that allow it to move in all axes, grab and move various things using just 4 servo motors. Having collected with my own hands such a robot, you will definitely be able to surprise your friends and loved ones with the possibilities and pleasant appearance this device! Remember that you can always use our RobotON Studio graphical environment for programming!

If you have any questions or comments, we are always in touch! Create and share your results!

Peculiarities:

To assemble a DIY robotic arm, you will need quite a few components. The main part is occupied by 3D printed parts, there are about 18 of them (it is not necessary to print a slide). If you have downloaded and printed everything you need, then you will need bolts, nuts and electronics:

5 bolts M4 20mm, 1 x 40mm and matching anti-rotation nuts
6 bolts M3 10mm, 1 x 20mm and matching nuts
Breadboard with connecting wires or shield
Arduino Nano
4 servo motors SG 90

After assembling the housing, it is IMPORTANT to ensure that it can move freely. If the key components of the Roboarm move with difficulty, the servo motors may not be able to handle the load. When assembling electronics, it must be remembered that it is better to connect the circuit to power after a complete check of the connections. To avoid damage to the SG 90 servos, you do not need to turn the motor itself by hand, if not necessary. In case you need to develop SG 90, you need to smoothly move the motor shaft in different directions.

Specifications:

Simple programming due to the presence of a small number of motors, and of the same type
The presence of dead zones for some servos
Wide applicability of the robot in daily life
Interesting engineering work
The need to use a 3D printer

MeArm Robot Arm - Pocket Version industrial manipulator. MeArm is an easy to assemble and control robot, mechanical arm. The manipulator has four degrees of freedom, which makes it easy to grab and move various small objects.

This product is presented as an assembly kit. Includes the following parts:

a set of parts made of transparent acrylic for assembling a mechanical manipulator;
4 servos;
a control board containing an Arduino Pro micro microcontroller and a Nokia 5110 graphic display;
joystick board containing two two-coordinate analog joysticks;
USB power cable.

Before assembling a mechanical manipulator, it is necessary to calibrate the servos. For calibration we will use the Arduino controller. Connecting servos to Arduino board(requires external power supply 5-6V 2A).

Servo middle, left, right, claw ; // create 4 Servo objects

Void setup()
{
Serial.begin(9600);
middle.attach(11); // connects a servo to pin 11 for platform rotation
left.attach(10); // connects a servo to pin 10 on the left shoulder
right.attach(9); // connects a servo to pin 11 on the right shoulder
claw.attach(6); // attach servo to pin 6 claw (capture)
}

Void loop()
{
// sets the position of the servo by value (in degrees)
middle.write(90);
left.write(90);
right.write(90);
claw.write(25);
delay(300);
}
Using a marker, draw a line through the servomotor housing and spindle. Connect the plastic rocker from the kit to the servo as shown below using the small screw from the servo mounting kit. We will use them in this position when assembling the mechanical part of the MeArm. Be careful not to move the spindle position.

Now you can assemble the mechanical manipulator.
Take the base and attach the legs to its corners. Then we install four 20 mm bolts and screw nuts on them (half of the total length).

Now we attach the center servo with two 8mm bolts to a small plate, and fix the resulting structure to the base with 20mm bolts.

We assemble the left section of the structure.

We assemble the right section of the structure.

Now you need to connect the left and right sections. First I go to the adapter plate

Then the right one, and we get

Connecting the structure to the platform

And we collect the "claw"

We fasten the "claw"

For assembly, you can use the following manual (in English) or the assembly manual for a similar manipulator (in Russian).

Pinout

Now you can start writing Arduino code. To control the manipulator, along with the ability to control the control using a joystick, it would be nice to direct the manipulator to some specific point of Cartesian coordinates (x, y, z). There is a corresponding library that can be downloaded from github - https://github.com/mimeindustries/MeArm/tree/master/Code/Arduino/BobStonesArduinoCode .
Coordinates are measured in mm from the center of rotation. The home position is at (0, 100, 50), i.e. 100 mm forward from the base and 50 mm from the ground.
An example of using the library to set the manipulator at a specific point in Cartesian coordinates:

#include "meArm.h"
#include

Void setup() (
arm.begin(11, 10, 9, 6);
arm.openGripper();
}

void loop() (
// up and left
arm.gotoPoint(-80,100,140);
// capture
arm.closeGripper();
// down, harm and right
arm.gotoPoint(70,200,10);
// release grip
arm.openGripper();
// return w starting point
arm.gotoPoint(0,100,50);
}

meArm class methods:

void begin(int pinBase, int pinShoulder, int pinElbow, int pinGripper) - start meArm, connection pins for middle, left, right, claw servos are indicated. Must be called in setup();
void openGripper() - open capture;
void closeGripper() - capture;
void gotoPoint(float x, float y, float z) - move the manipulator to the position of Cartesian coordinates (x, y, z);
float getX() - current X coordinate;
float getY() - current Y coordinate;
float getZ() - current Z coordinate.

Assembly manual

Hello everyone!
A couple of years ago, a very interesting project from uFactory appeared on kickstarter - a desktop robo-arm uArm. They promised to eventually make the project open source, but I couldn't wait and got into reverse engineering from photographs.
Over the years, I made four versions of my vision of this manipulator and eventually developed this design:
It is a robotic arm with an integrated controller, driven by five servos. Its main advantage is that all the details can either be bought, or cheaply and quickly cut out of plexiglass with a laser.
Since I took an open sorce project as a source of inspiration, I share all my results in full. You can download all the sources from the links at the end of the article and, if you wish, compile the same one (all links at the end of the article).

But it’s easier to show it at work once than to tell for a long time what it is:

So, let's move on to the description.
Specifications

Height: 300mm.
Working area (with arm fully extended): 140mm to 300mm around the base
Maximum load capacity on an outstretched arm, not less than: 200g
Consumed current, no more than: 6A

I would also like to point out some design features:

Bearings in all moving parts of the manipulator. There are eleven in total: 10 pieces for a 3mm shaft and one for a 30mm shaft.
Easy assembly. I paid a lot of attention to ensuring that there was such a sequence of assembly of the manipulator in which it was extremely convenient to screw all the details. It was especially difficult to do this for the powerful servo nodes at the base.
All powerful servos are located at the base. That is, the "lower" servos do not drag the "upper".
Parallel hinges keep the tool always parallel or perpendicular to the ground.
The position of the manipulator can be changed by 90 degrees.
Ready-made Arduino-compatible software. Right collected hand can be controlled by the mouse, and using code examples, you can create your own movement algorithms

Design description
All parts of the manipulator are cut from Plexiglas 3 and 5 mm thick:

Pay attention to how the swivel base is assembled:
The most difficult one is the node at the bottom of the manipulator. In the first versions, it took me a lot of effort to assemble it. Three servos are connected in it and forces are transmitted to the grip. The parts rotate around a pin with a diameter of 6mm. The grip is held parallel (or perpendicular) working surface due to additional traction:

The manipulator with the shoulder and elbow installed is shown in the photo below. The claw and thrust for it have yet to be added to it:

The claw is also mounted on bearings. It can shrink and rotate around its axis:
The claw can be installed both vertically and horizontally:

Controlled by all Arduino-compatible board and shield for it:

Assembly
It will take about two hours and a bunch of fasteners to assemble the manipulator. I made the assembly process itself in the form of instructions in photographs (carefully, traffic!) With detailed comments on each operation. Also I made a detailed 3D model in a simple and free program sketch up. So you can always turn it before your eyes and see incomprehensible places:

Electronics and programming
I made a whole shield on which I installed, in addition to the servo and power connectors, variable resistors. For ease of debugging. In fact, it is enough to bring signals to the engines with the help of a breadboard. But I ended up with such a shield, which (it so happened) I ordered at the factory:

Actually I did three different programs under Arduino. One for PC control, one for demo operation and one for button and variable resistor control. The most interesting of them is, of course, the first one. I won't post the entire code here - it's available online.
To manage, you need to download a program for your computer. After launching it, the mouse enters hand control mode. Movement is responsible for moving along XY, the wheel changes the height, LMB / RMB - capture, RMB + wheel - rotation of the manipulator. And it's really convenient. It was in the video at the beginning of the article.
Project sources

Hey Geektimes!

The uArm project from uFactory raised funds on kickstarter more than two years ago. They said from the start that it would be open project, but immediately after the end of the company, they were in no hurry to upload the source code. I just wanted to cut the plexiglass according to their drawings and that's it, but since there were no source codes and it was not foreseen in the foreseeable future, I began to repeat the design from photographs.

Now my robo arm looks like this:

Working slowly in two years, I managed to make four versions and got a lot of experience. Description, project history and all project files you can find under the cut.

trial and error

When I started working on the blueprints, I wanted to not just repeat the uArm, but improve it. It seemed to me that in my conditions it is quite possible to do without bearings. I also did not like the fact that the electronics rotated with the entire arm and wanted to simplify the design of the lower part of the hinge. Plus I started to draw him immediately a little less.

With such input parameters I drew the first version. Unfortunately, I did not have any photos of that version of the manipulator (which was made in yellow). Mistakes in it were just epic. First, it was almost impossible to assemble. As a rule, the mechanics that I drew before the manipulator were quite simple, and I did not have to think about the assembly process. But still, I collected it and tried to run it, And the hand hardly moved! All the parts revolved around the screws and if I tightened them so that there was less play, she could not move. If I loosened it so that it could move, incredible backlash appeared. As a result, the concept did not live even three days. And I started working on the second version of the manipulator.

Red was already quite fit for work. He normally assembled and could move with lubrication. I was able to test the software on it, but still the lack of bearings and large losses on different rods made it very weak.

Then I abandoned the project for a while, but soon decided to bring it to mind. I decided to use more powerful and popular servos, increase the size and add bearings. And I decided that I would not try to make everything perfect at once. I drew the drawings for hastily, without drawing beautiful mates, and ordered cutting from transparent plexiglass. On the resulting manipulator, I was able to debug the assembly process, identified places that needed additional reinforcement, and learned how to use bearings.

After playing around with the transparent manipulator to my heart's content, I sat down to draw the final white version. So, now all the mechanics are fully debugged, suits me and is ready to declare that I don’t want to change anything else in this design:

It depresses me that I could not bring anything fundamentally new to the uArm project. By the time I started drawing the final version, they had already rolled out 3D models on GrabCad. In the end, I just simplified the claw a little, prepared the files in a convenient format and used very simple and standard components.

Features of the manipulator

Before the advent of uArm, desktop manipulators of this class looked rather dull. They either had no electronics at all, or they had some kind of control with resistors, or they had their own proprietary software. Secondly, they usually did not have a system of parallel hinges and the grip itself changed its position during operation. If we collect all the advantages of my manipulator, we get a rather long list:

A system of rods that allows you to place powerful and heavy engines in the base of the manipulator, as well as holding the gripper parallel or perpendicular to the base
A simple set of components that are easy to buy or cut from plexiglass
Bearings in almost all nodes of the manipulator
Easy assembly. It turned out to be true challenging task. It was especially difficult to think over the process of assembling the base
The grip position can be changed by 90 degrees
Open source and documentation. Everything is prepared in accessible formats. I will give download links for 3D models, cutting files, material list, electronics and software
Arduino compatible. There are many opponents of Arduino, but I believe that this is an opportunity to expand the audience. Professionals can easily write their software in C - it's a regular controller from Atmel!

Mechanics

For assembly, it is necessary to cut parts from 5mm plexiglass:

They charged me about $10 for cutting all these parts.

The base is mounted on a large bearing:

It was especially difficult to think of the base from the point of view of the assembly process, but I was peeping at the engineers from uArm. Rocking chairs sit on a pin with a diameter of 6mm. It should be noted that the thrust of my elbow rests on a U-shaped holder, and for uFactory on an L-shaped one. It's hard to explain what the difference is, but I think I did better.

Capture is collected separately. It can rotate around its own axis. The claw itself sits directly on the motor shaft:

At the end of the article, I will give a link to super-detailed assembly instructions in photos. In a couple of hours, you can confidently twist it all, if everything you need is at hand. I also prepared a 3D model in the free program SketchUp. You can download it, twist it and see what and how it is collected.

Electronics

To make the arm work, all you need to do is connect five servos to the Arduino and supply power to them with good source. uArm has some kind of feedback motors. I put three conventional motor MG995 and two small metal gear motors to control the grip.

Here my story is closely intertwined with previous projects. For some time now, I have started teaching Arduino programming and even prepared my own Arduino-compatible board for this purpose. On the other hand, once I got the opportunity to make boards cheaply (which I also wrote about). In the end, it all ended with the fact that I used my own Arduino-compatible board and a specialized shield to control the manipulator.

This shield is actually very simple. It has four variable resistors, two buttons, five servo connectors, and a power connector. This is very convenient from a debugging point of view. You can upload a test sketch and write some kind of macro to control or something like that. I will also give a link for downloading the board file at the end of the article, but it is prepared for manufacturing with hole plating, so it is not very suitable for home production.

Programming

The most interesting thing is the control of the manipulator from the computer. uArm has handy application to control the manipulator and the protocol for working with it. The computer sends 11 bytes to the COM port. The first one is always 0xFF, the second one is 0xAA and some of the rest are servo signals. Further, these data are normalized and given to the engines for testing. I have servos connected to digital I/O 9-12, but this can easily be changed.

The terminal program from uArm allows you to change five parameters when controlling the mouse. When moving the mouse over the surface, the position of the manipulator in the XY plane changes. Rotate the wheel - change the height. LMB / RMB - squeeze / unclench the claw. RMB + wheel - grip rotation. Actually very convenient. If you wish, you can write any terminal software that will communicate with the manipulator using the same protocol.

I will not give sketches here - you can download them at the end of the article.

Video of work

And, finally, the video of the operation of the manipulator itself. It shows the control of the mouse, resistors and according to a pre-recorded program.

Links

Plexiglas cutting files, 3D models, shopping list, board drawings and software can be downloaded at the end of my

Connection:

If you have assembled the parts of the manipulator in accordance with the instructions, then you can start assembling the electronic circuit. We suggest connecting the manipulator servos to the Arduino UNO via Trerma-Power Shield, and control the servos using Trema-potentiometers.

Turning the knob on the first Trema pot will cause the base to turn.
Turning the knob of the second Trema potentiometer will cause the left shoulder to turn.
Turning the knob on the third Trema potentiometer will cause the right shoulder to turn.
Turning the knob on the fourth Trema potentiometer will move the gripper.

The program code (sketch) provides protection for servos, which consists in the fact that their rotation range is limited by the interval (two angles) of free play. The minimum and maximum angle of rotation are specified as the last two arguments of the map() function for each servo. And the value of these angles is determined during the calibration process, which must be performed before starting work with the manipulator.

Program code:

If you apply power before calibration, the manipulator may begin to move inadequately! Complete all calibration steps first.

#include // Connect the Servo library to work with servo drives Servo servo1; // Declare a servo1 object to work with the base servo Servo servo2; // Declare a servo2 object to work with the left arm servo Servo servo3; // Declare a servo3 object to work with the right arm servo Servo servo4; // Declare a servo4 object to work with the capture servo int valR1, valR2, valR3, valR4; // Declare variables to store potentiometer values // Assign pins: const uint8_t pinR1 = A2; // Define a constant with the output number of the control potentiometer. base const uint8_t pinR2 = A3; // Define a constant with the output number of the control potentiometer. left shoulder const uint8_t pinR3 = A4; // Define a constant with the output number of the control potentiometer. right shoulder const uint8_t pinR4 = A5; // Define a constant with the output number of the control potentiometer. capture const uint8_t pinS1 = 10; // Define a constant with the base servo pin # const uint8_t pinS2 = 9; // Define a constant with the number of output of the left arm servo const uint8_t pinS3 = 8; // Define a constant with the right arm servo pin # const uint8_t pinS4 = 7; // Define a constant with the pin number of the capture servo void setup()( // The setup function code is executed once: Serial.begin(9600); // Initiate data transfer to the serial port monitor servo1.attach(pinS1); // Assign servo1 to the object control servo 1 servo2.attach(pinS2); // Assign servo2 object control servo 2 servo3.attach(pinS3); // Assign servo3 object control servo 3 servo4.attach(pinS4); // Assign servo4 object control servo 4 ) void loop()( // The loop function code is executed constantly: valR1=map(analogRead(pinR1), 0, 1024, 10, 170); servo1.write(valR1); // Rotate the base The angles specified in this line: 10 and 170 may need to change (calibrate) valR2=map(analogRead(pinR2), 0, 1024, 80, 170); servo2.write(valR2); // Control the left shoulder The angles specified in this line: 80 and 170 may need to be changed (calibrated ) valR3=map(analogRead(pinR3), 0, 1024, 60, 170);servo3.write(valR3) ; // Control the right shoulder The angles specified in this line: 60 and 170 may need to be changed (calibrated) valR4=map(analogRead(pinR4), 0, 1024, 40, 70); servo4.write(valR4); // Controlling the capture The angles specified in this line: 40 and 70 may need to be changed (calibrated) Serial.println((String) "A1 = "+valR1+",\t A2 = "+valR2+", \t A3 = "+valR3+ ", \t A4 = "+valR4); // Display angles on the monitor )

Calibration:

Before you start working with the manipulator, you need to calibrate it!

Disconnect all servos from the Trema-Power Shield, upload the sketch and reconnect power.
Open the serial port monitor.
The monitor will display the rotation angles of each servo (in degrees).
Connect the first servo (controlling the rotation of the base) to pin D10.
Turning the knob of the first Trema-potentiometer (pin A2) will turn the first servo (pin D10), and the value of the current angle of this servo will change in the monitor (value: A1 = ...). The extreme positions of the first servo will lie in the range from 10 to 170 degrees (as written in the first line of the loop code). This range can be changed by replacing the values of the last two arguments of the map() function in the first line of the loop code with new ones. For example, changing 170 to 180 will increase the servo's end position in that direction. And by replacing 10 with 20, you will reduce the other extreme position of the same servo.
If you changed the values, then you need to reload the sketch. Now the servo will rotate within the new limits you set.
Connect the second servo (controlling the rotation of the left arm) to pin D9.
Turning the knob of the second Trema-potentiometer (pin A3) will turn the second servo (pin D9), and the value of the current angle of this servo will change in the monitor (value: A2 = ...). The extreme positions of the second servo will lie in the range from 80 to 170 degrees (as written in the second line of the sketch's loop code). This range changes in the same way as for the first servo.
If you changed the values, then you need to reload the sketch.
Connect the third servo (controlling the rotation of the right arm) to pin D8. and calibrate it in the same way.
Connect the fourth servo (controlling the gripper) to pin D7. and calibrate it in the same way.

Calibration is enough to perform 1 time, after assembling the manipulator. The changes you made (the values of the limit angles) will be saved in the sketch file.