Project Goal
Original Plan
CAD Design
Design
Circuit Diagram
3D Printing
The Assembly Process
Possible improvements and suggestions
Lessons Learnt

Published July 21, 2024 © GPL3+

Arduino Robot Arm Project [V2]

My second and more advanced attempt at creating an Arduino-operated robot arm.

IntermediateShowcase (no instructions)12 hours369

Things used in this project

Hardware components

Arduino UNO

SG90 Micro-servo motor

Rotary potentiometer (generic)

Male-Header 5 Position- 1 Row- Long (0.1")

Female/Female Jumper Wires

Male/Female Jumper Wires

Software apps and online services

Arduino IDE

Autodesk Fusion

Creality Slicer

Hand tools and fabrication machines

3D Printer (generic)

Soldering iron (generic)

Story

Project Goal

This wasn't my first attempt at building a robot arm, but this time I had some cool new tools at my disposal: a 3D printer and Fusion 360. Like my Bluetooth car project, my goal was to push myself and get better at using these tools. I also wanted to learn more about how robot arms work and how to tackle any challenges that might come up.

Original Plan

The original plan for this project was to design a robot arm using CAD (Computer-Aided Design), 3D print it, and equip it with the necessary electronics. My main goals were to make the robot arm look aesthetically pleasing, integrate the circuitry, and ensure it was fully functional.

CAD Design

Why is it needed?

Unlike my previous projects, I was determined to make the most of my 3D printer for this one. I had two options: follow instructions and use an existing design from another maker, or design the whole project from scratch without any limitations. I chose the latter because I wanted creative freedom and the chance to add a new tool to my skill set.

Using CAD for my project design gave me several advantages. I could 3D print all the parts, ensuring they were precise and customized. CAD also made it easy to spot and fix mistakes in the design, saving me from having to start over and wasting time and resources.

With CAD, I could check if the moments exerted on the servos would cause stalling before printing. The software let me verify the total length of the model and use the formula [M = Fd] to evaluate potential moments and make informed design decisions. I used the Creality slicer to find the mass of the entire arm, which helped me calculate the force requirements.

Having this info was crucial for the project's success. Without it, I wouldn't have known if I needed to reduce the weight of the parts. The ability to print custom parts accurately was vital for ensuring the robot arm's overall functionality and performance.

Design

The Arm itself:

1 / 3

The arm design was based on two main requirements:

It had to be lightweight.
It had to look good.

In my opinion, the arm met both of these criteria pretty well.

Two servos are attached to the first and second parts of the arm to improve smoothness and response. They also help handle any extra load the arm might pick up. If the servos struggled to carry the arm's weight, the robot arm wouldn't be very useful for any tasks.

The box:

1 / 2

The purpose of this box was to keep all the components organized and in one place, making it portable and tidy. Unfortunately, I couldn't include it in the final design because of the wiring issues.

The box was also meant to act as a counterweight for the robot arm. Without a heavy counterweight, the arm could easily topple over when fully extended. So, while the arm needed to be light, the box/base was designed to be dense and sturdy.

Movement:

1 / 3

The servo motor responsible for rotating about the x and y-axis (the first image) is crucial for rotating the entire robot arm from 0 to 180 degrees. This key movement lets the arm pick up an item from one box and move it to another box on the opposite side.

However, it’s worth noting that when two servos are positioned opposite each other, one must move in the opposite direction to the other. You can see this setup in the code below.

The Claw:

1 / 3

To simplify controlling the claw movement, I opted for a design with just one servo instead of two separate servos. This setup allowed me to synchronize the movement of both jaws. I used a system of gears to transfer motion from the servo to the second jaw. To keep both jaws stable and aligned, I added four holes in the design. These holes acted as attachment points for connectors, helping to securely position and maintain the jaws. The design of the claw itself was inspired by insects.

Cable Organization:

My main concern was that these wires might interfere with the robot arm's motion or get tangled. To address this, I designed a hole under the base of the arm, allowing the servo wires to be routed underneath and out of the way. Additionally, I added openings along the walls of the base so the wires could be strapped down, making them less obtrusive, as shown in the second image.

Optimizing Weight:

For this project, the servos used each have a torque of 1.6kg.cm, which isn't actually much when considering the length of our arm, but still impressive for their small size. Knowing this limit, I had to minimize weight to prevent the first two servos from stalling when picking up an item. The closer the servos are to the claw, the less torque is needed because their moment decreases. That's why there's a reduction from two servos to one servo between the second and last joint, which saves another 9g of weight.

By cutting down on the overall weight, I aimed to keep the servos running smoothly and avoid any performance problems.

While weight reduction was key to stopping the servos from stalling, I also had to make sure the parts were strong enough to handle the job and any external forces. Finding the right balance between reducing weight and keeping everything sturdy was crucial for the robot arm's performance.

I looked at the engineering principles employed by military bridges for inspiration, using their techniques to guide my approach. You’ll see how I applied these ideas, along with a reference image. Additionally, architecture provided great ideas. I created many empty spaces on the flat pieces of the arm while incorporating arches to maintain strong resistance to external forces.

1 / 2

Calculations:

Calculating the maximum load for each servo can seem a bit pointless, but it’s important to measure the maximum load for the first two servos since they experience the most stress and play a crucial role in the arm's movement.

Each servo can handle a load of 1.6kg, or a perpendicular force of 16N, when the load is 1cm away (assuming g = 10). The arm's length is approximately 30cm, so the new maximum load it can handle would be 16N x 1 = Fn (N for new) x 30. Rearranging this, the load capacity is about 53g ((16N/30)/10) * 1000. Therefore, the maximum theoretical load the arm can handle without stalling when moving in the Z direction is approximately 106g.

Keep in mind, these calculations might be flawed since I'm only an A-level student and there's not much information I can find online on how to calculate this precisely.

Circuit Diagram

Made With EasyEDA

The circuit schematic is pretty straightforward. Each of the seven servos and five potentiometers are connected to their respective GPIO (General Purpose Input/Output) pins and a 5V power supply. Three potentiometers control one servo, while two potentiometers control two servos. This is because certain parts of the arm need two servos to meet the torque requirements.

1 / 2 • Before all the cable Management

Building the circuit turned out to be quite a challenge due to the sheer number of wires needed to connect all the components.

Soldered board

To accommodate my choice of using the Arduino Uno as the power source, I had to solder a circuit that would enable me to power 12 different components using a single 5V pin. The circuit operates by utilizing a single male input pin to receive the power, which is then distributed in parallel (by each component having an individual wire for itself) to the other output pins. This parallel distribution ensures that each component has the same amount of voltage intake. (This was not illustrated in the circuit diagrams, as it would have made it harder to understand). Fortunately no problems arose with this power distribution configuration for the circuit. However, there was a potential concern that each component might not receive enough current to operate since, in a parallel circuit, current is divided among the parallel segments.

3D Printing

Yeah, that's all I have..

The Assembly Process

Step 1: Servos were screwed to each of their designated parts.

Step 2: The moving piece of the servo was securely glued to the other side of the component. This configuration allowed for a strong connection between the piece and the servo motor. Additionally, I ensured further stability by screwing the assembly tightly to the servo. This arrangement facilitated the effective rotation of the piece, enabling the servo to exert its intended motion on the component.

1 / 2

Step 3: Once all the servos were securely connected to each piece, all the parts were then pieced together. The model I had designed in Fusion360 acted as a reference point, to ensure no mistakes were made during the assembly process.

1 / 3

Step 4: All the servos were then wired up to the Arduino and circuit.

1 / 2

Possible improvements and suggestions

Realizing that using stronger servo motors could make a big difference for this project showed me how much better the robot arm could be. With more powerful servos, I could have made the arm bigger and improved its performance, leading to smoother and more predictable movements. The extra torque and power from stronger servos would have made the arm more stable and precise, allowing it to handle heavier loads and tackle more complex tasks with greater efficiency.
Looking back, I see that better cable management would have really improved both the functionality and look of the project. If I had thought about cable management from the start, I could have planned better routes for the cables, used cable clips or channels, and made sure there was enough space to keep everything tidy and tangle-free. This would have made assembly and maintenance easier and given the robot arm a cleaner, more organized appearance.
Going forward, I plan to carefully integrate the necessary hardware and software to let the robot perform pre-programmed tasks, which is a key feature for most robotic arms. This step will help the robot carry out a range of actions on its own, without needing constant manual control.
I also want to upgrade the control system by adding a Bluetooth receiver. This would let me control the robot arm directly from my phone, making it much easier to use. With Bluetooth, I can connect my phone to the robot arm wirelessly and control it through a mobile app. This addition will simplify the control interface and make the system more user-friendly, so it's accessible to a broader range of users.

Lessons Learnt

Through this project, I’ve learned how to effectively combine CAD software with 3D printing. This new skill lets me integrate the design process with practical 3D printing, making it easier to bring my ideas to life in a customized way. The combo of CAD’s precise modeling and 3D printing’s versatility has opened up tons of possibilities for future projects.
I’ve also discovered some really useful tools in Fusion 360 that I think will be great for my future work. On the software side, I still have a lot to learn, but this project has definitely improved my C++ skills and made me more comfortable with it.
Using gears in this project was a great learning experience. It gave me a deeper understanding of how gears work and how they can be used to control motion and improve efficiency. This knowledge will be a valuable tool for future projects where gears can help with functionality and precision.
I also faced a challenge with the weight capacity of my servos, which pushed me to dive deeper into the physics of moments. This helped me figure out if my arm’s weight was within a safe range or if I needed to make adjustments. Understanding moments better has not only boosted my physics knowledge but also given me the confidence to use physics more often in other projects.
Overall, this project has been a major learning experience in engineering, design, and construction. I’ve picked up a lot of valuable lessons and skills that will definitely influence my future work. Engaging in hands-on problem-solving has expanded my technical abilities and deepened my understanding of building and engineering.

Code

Main Code

#include <Servo.h>


 Servo servo1; // Creating objects
 Servo servo2;
 Servo servo3;
 Servo servo4;
 Servo servo5;
 Servo servo6;
 Servo servo7; 
 
 const int pot1 = A1; // Setting Analog pins for the potentiometers
 const int pot2 = A2;
 const int pot3 = A3;
 const int pot4 = A4;
 const int pot5 = A5;


 int pot1Ang; // Setting up a variable to store the angles
 int pot2Ang;
 int pot3Ang;
 int pot4Ang;
 int pot5Ang;


 int pot1Val; // For future variations 
 int pot2Val;
 int pot3Val;
 int pot4Val;
 int pot5Val;
 
void setup() {
 
 servo1.attach(2); // Telling the servo class what pins each one is attached to.
 servo2.attach(3);
 servo3.attach(4);
 servo4.attach(5);
 servo5.attach(6);
 servo6.attach(7);
 servo7.attach(8);


 Serial.begin(9600); // To read data from the serial logger.
}


void loop() {
 
  pot1Val = analogRead(pot1); // Reading the Analog values of the potentiometers.
  pot2Val = analogRead(pot2);
  pot3Val = analogRead(pot3);
  pot4Val = analogRead(pot4);
  pot5Val = analogRead(pot5);


  pot1Ang = map(pot1Val, 0, 1023, 0, 180); // Transforming the Analog data into         something the servo motors can understand.(Digital data) 


  pot2Ang = map(pot2Val, 0, 1023, 0, 180);  
  pot3Ang = map(pot3Val, 0, 1023, 0, 180);
  pot4Ang = map(pot4Val, 0, 1023, 120, 180);  
  pot5Ang = map(pot5Val, 0, 1023, 0, 180);


  servo1.write(pot1Ang);
  servo2.write(180 - pot1Ang); // Servo has to go the opposite direction of the other
  servo3.write(pot2Ang);
  servo4.write(180 - pot2Ang); // Servo has to go the opposite direction of the other
  servo5.write(pot3Ang);
  servo6.write(pot4Ang);
  servo7.write(pot5Ang);


}

Credits

Paul Vincent Bezzina

5 projects • 7 followers

Aspiring electronics enthusiast and sixth form student. Always eager to learn and experiment with new technologies and hands-on creations.

Thanks to Eben Kouao, Unsure, and Uladz.

Arduino Robot Arm Project [V2]