Hand manipulator do it yourself drawings. Do-it-yourself tabletop robotic arm manipulator made of plexiglass on servos

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

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

Peculiarities:

To assemble a robotic arm with your own hands, you will need quite a few components. The main part is occupied by 3D printed parts, there are about 18 of them (printing the slide is optional). If you downloaded and printed everything you need, then you will need bolts, nuts and electronics:

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

After assembling the body, it is IMPORTANT to make sure it is free to move. If the key parts of the Robohand are difficult to move, the servo motors may not be able to handle the load. When assembling the electronics, it must be remembered that it is better to connect the circuit to the power supply after a complete check of the connections. To avoid damage to the SG 90 servo drives, you do not need to turn the motor by hand if not necessary. If 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
Dead spots for some servo drives
Wide applicability of the robot in daily life
Interesting engineering work
The need to use a 3D printer

Robot manipulator MeArm - pocket version industrial manipulator... MeArm is an easy-to-assemble and operate robot, mechanical arm... The manipulator has four degrees of freedom, which makes it easy to grip 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;
the control board, which houses the Arduino Pro micro microcontroller and the Nokia 5110 graphic display;
joystick board containing two x-axis analog joysticks;
USB power cable.

Before assembling the mechanical arm, it is necessary to calibrate the servos. For calibration we will use an Arduino controller. We connect servos to Arduino board(external power supply 5-6V 2A is required).

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

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

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

The mechanical arm can now be assembled.
Take the base and attach the legs to its corners. Then install four 20mm bolts and screw nuts on them (half of the total length).

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

Putting together the left section of the structure.

Putting together the right section of the structure.

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

Then the right one, and we get

We connect the structure to the platform

And we collect the "claw"

We fix the "claw"

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

Pinout diagram

Now you can start writing Arduino code. To control the manipulators, along with the ability to control the joystick control, it would be nice to direct the manipulator to some specific point in the Cartesian coordinates (x, y, z). There is a related 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 starting position is at the point (0, 100, 50), that is, 100 mm forward from the base and 50 mm from the ground.
An example of using the library to set a 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);
// grab
arm.closeGripper ();
// down, harm and right
arm.gotoPoint (70,200,10);
// release the capture
arm.openGripper ();
// return w to start point
arm.gotoPoint (0,100,50);
}

Methods of the meArm class:

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

Assembly Guide

Hello everyone!
A couple of years ago, a very interesting project from uFactory appeared on kickstarter - the uArm desktop robot arm. They promised to make the project open over time, but I could not wait and started reverse engineering from photographs.
Over the years, I have made four versions of my vision of this manipulator, and as a result I have developed the following design:
It is a robotic arm with an integrated controller, driven by five servos. Its main advantage is that all parts can either be bought, or cheaply and quickly be removed from 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, collect the same one (all links at the end of the article).

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

So let's move on to the description.
Specifications

Height: 300mm.
Working area (arm fully extended): 140mm to 300mm around base
Maximum lifting capacity at outstretched arm, not less: 200g
Consumption current, no more: 6A

I would also like to note some design features:

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

Description of the structure
All parts of the manipulator are cut from plexiglass with a thickness of 3 and 5 mm:

Notice how the swivel base is assembled:
The most difficult one is the knot at the bottom of the manipulator. In the first versions, it took me a lot of effort to put it together. It connects three servos and transfers the gripping forces. The parts rotate around a 6mm diameter pin. The grip is held parallel (or perpendicular) work surface due to additional rods:

A manipulator with an attached shoulder and elbow is shown in the photo below. A 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:

Everything is controlled by an Arduino-compatible board and a shield for it:

Assembly
It will take about two hours to assemble the manipulator and a bunch of fasteners. The assembly process itself was formulated in the form of instructions in the photographs (carefully, traffic!) With detailed comments on each operation. Also I made a detailed 3D model in a simple and free program SketchUp. So you can always turn it over in front of 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 apply signals to the motors using a breadboard. But in the end I got this shield, which (it just so happened) I ordered at the factory:

I actually did three different programs for Arduino. One for control from a computer, one for working in demo mode and one for controlling buttons and variable resistors. The most interesting of them, of course, is the first one. I will not provide the entire code here - it is available online.
To control, you need to download a program for your computer. After launching it, the mouse enters the hand control mode. Movement is responsible for moving in XY, the wheel changes the height, LMB / RMB - grip, RMB + wheel - rotate the manipulator. And it's actually convenient. It was in the video at the beginning of the article.
Project sources

Hello giktimes!

UArm project from uFactory raised funds on kickstarter for more than two years ago. They said from the start that it would be open project, but immediately after the end of the campaign, 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 was not foreseen in the foreseeable future, I began to repeat the design from the photographs.

My robotic arm now looks like this:

Working slowly over the course of two years, I managed to make four versions and gained quite a lot of experience. Description, project history and all project files can be found under the cut.

Trial and error

When I started working on the drawings, I wanted not just to repeat uArm, but to 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 rotate with the entire manipulator and I wanted to simplify the design of the lower part of the hinge. Plus, I started painting it a little smaller right away.

With such input parameters I drew the first version. Unfortunately, I have not preserved any photographs of that version of the manipulator (which was made in yellow). The mistakes in it were simply epic. First, it was almost impossible to assemble it. 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 all the same, I assembled it and tried to start it, And the hand almost did not move! All the parts were spinning around the screws and if I tightened them so that there was less backlash, it could not move. If I weakened so that she could move, incredible backlash appeared. As a result, the concept did not live even three days. And he started working on the second version of the manipulator.

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

Then I gave up work on the project for a while, but soon made the decision 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 sketched the blueprints on quick hand without drawing beautiful mates and ordered cutting from transparent plexiglass. Using the resulting manipulator, I was able to debug the assembly process, identified places that needed additional reinforcement, and learned how to use bearings.

After I played enough with the transparent manipulator, I sat down to blueprints for the final white version. So, now all the mechanics are completely debugged, it suits me and I'm ready to declare that I don't want to change anything else in this design:

I am depressed by the fact 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 the 3D models on GrabCad. As a result, I only slightly simplified the claw, prepared 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 did not have 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 joints and the gripper itself changed its position during operation. If you collect all the advantages of my manipulator, you get a rather long list:

Linkage system to accommodate powerful and heavy motors in the arm base and to keep 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
Ease of assembly. It turned out really challenging task... It was especially difficult to think through the process of assembling the base.
The gripping position can be changed by 90 degrees
Open source and documentation. Everything is prepared in accessible formats. I will provide download links for 3D models, files for cutting, list of materials, electronics and software
Arduino compatibility. There are many opponents of Arduino, but I believe this is an opportunity to expand the audience. Professionals can easily write their software in C - this is a regular controller from Atmel!

Mechanics

For assembly, it is necessary to cut out parts from plexiglass with a thickness of 5 mm:

I was charged about $ 10 for cutting all these parts.

The base is mounted on a large bearing:

It was especially difficult to think about the foundation in terms of the build process, but I was spying on the engineers at uArm. The rockers sit on a 6mm diameter pin. It should be noted that my elbow pull is held 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.

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

At the end of the article, I will give a link to the 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 SketchUp program. You can download it, spin it and see what and how it is assembled.

Electronics

To make your hand work, you just need to connect five servos to the Arduino and supply them with power from good source... UArm has some kind of feedback motors. I put three conventional engine MG995 and two small metal gear motors to control the gripper.

Here my story is closely intertwined with previous projects. For some time now I started teaching Arduino programming and for this purpose I even prepared my Arduino-compatible board. On the other hand, I once had the opportunity to make cheap boards (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 record some kind of control macro or something like that. I will also give a link to download the PCB file at the end of the article, but it is prepared for manufacturing with metallized holes, 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 convenient application for manipulator control and 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 signals for servos. 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 be easily changed.

Terminal program from uArm allows you to change five parameters with mouse control. Moving the mouse over the surface changes the position of the manipulator in the XY plane. Rotating the wheel - changing the height. LMB / RMB - squeeze / unclench the claw. RMB + wheel - grip rotation. Very convenient, actually. If desired, you can write any terminal software that will communicate with the manipulator using the same protocol.

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

Video of work

And, finally, the very video of the manipulator's work. It shows the control of the mouse, resistors and a pre-recorded program.

Links

Files for cutting plexiglass, 3D models, a purchase 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 propose to connect the servos of the manipulator to the Arduino UNO via the Trerma-Power Shield, and control the servos using the Trema potentiometers.

Turning the knob of the first Trema potentiometer will turn the base.
Turning the knob of the second Trema potentiometer will turn the left shoulder.
Turning the knob of the third Trema potentiometer will turn the right shoulder.
Turning the knob of the fourth Trema potentiometer will set the gripper in motion.

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

Program code:

If you apply power before calibration, the arm may not move properly! Complete all calibration steps first.

#include // Connect the Servo library to work with servo drives Servo servo1; // Declare an object servo1 to work with the base servo Servo servo2; // Declare the servo2 object to work with the left shoulder servo Servo servo3; // Declare the servo3 object to work with the right shoulder servo Servo servo4; // Declare the servo4 object to work with the capture servo int valR1, valR2, valR3, valR4; // Declare variables for storing potentiometer values // Assign pins: const uint8_t pinR1 = A2; // Determine the constant with the pin number of the control potentiometer. base const uint8_t pinR2 = A3; // Determine the constant with the pin number of the control potentiometer. left shoulder const uint8_t pinR3 = A4; // Determine the constant with the pin number of the control potentiometer. right shoulder const uint8_t pinR4 = A5; // Determine the constant with the pin number of the control potentiometer. capture const uint8_t pinS1 = 10; // Define a constant with the pin # of the base servo const uint8_t pinS2 = 9; // Define a constant with the pin # of the left shoulder servo const uint8_t pinS3 = 8; // Define a constant with the pin number of the right shoulder servo const uint8_t pinS4 = 7; // Define a constant with pin # 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 to the object servo1 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 with the base The angles specified in this line are 10 and 170 you may need to change (calibrate) valR2 = map (analogRead (pinR2), 0, 1024, 80, 170); servo2.write (valR2); // Control the left shoulder The angles indicated 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 the corners in the monitor)

Calibration:

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

Disconnect all servos from the Trema-Power Shield, upload your sketch and power up.
Open the serial port monitor.
The monitor will display the angles of rotation of each servo (in degrees).
Connect the first servo (base rotation) to 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 be 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 loop code with new ones. For example, replacing 170 with 180, you will increase the extreme position of the servo in this direction. And by replacing 10 with 20, you will decrease the other extreme position of the same servo.
If you changed the values, then you need to reload the sketch. Now the servo will turn within the new, set by you, limits.
Connect the second servo (control of the left shoulder rotation) 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 be in the range from 80 to 170 degrees (as written in the second line of the loop sketch). 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 shoulder) to pin D8. and calibrate it in the same way.
Connect the fourth servo (control servo) to D7. and calibrate it in the same way.

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