Published June 3, 2021 © GPL3+

Robotic Arm (with linear actuators)

I have made a different type of design than the normal robotic arms, based on linear actuators.

IntermediateFull instructions provided1,316

Early Bird - US Based Project

2021 China-US Young Maker Competition

Things used in this project

Hardware components

Arduino Nano R3

DRV8835 Dual Motor Driver Carrier

10k rotary potentiometer

Optional

GA12-N20 100 RPM Micro Metal Gearmotor

HC-05 Bluetooth Module

Resistor 1k ohm

Breadboard (generic)

SparkFun Pushbutton switch 12mm

Optional

Battery (generic)

The battery voltage depends on motor voltage. Also, consider that this should be in the motor driver input voltage parameters (2 - 11V).

Software apps and online services

Arduino IDE

SketchUp

Ultimaker Cura

Hand tools and fabrication machines

Soldering iron (generic)

Hot glue gun (generic)

Story

Robotic arms are used in many applications, ranging from heavy-duty assembly lines and warehouse logistics to precise equipment for fine operations. There are many types of such machinery, based on the application, they can be operated with hydraulics, pneumatics, electrical or mechanical power sources.

About this project

This project is rather a concept in which I combined a side of mechanics (linear actuators) with a simple robot - a robotic arm. This model is far from perfect, but it is a robot that is flexible and can lift weights to 100 grams. Therefore, any improvement of this project is welcome. :)

Linear Actuators

In this project, I've made a unique design of this type of robot, which is based on a form of movement using linear actuators. An actuator transforms circular motion into linear motion. So, the motor is connected to a threaded rod that screws or unscrews a nut. As a result, the nut moves on a linear trajectory alongside the thread.

Figure 1 - linear actuator

The advantage of using a threaded rod and nut is that it locks in position when applied force stops. It significantly reduces the stress on the motor, resulting in less energy consumption.

The downside is the need for mobility. During operation, the angle between rod, arm and support varies, meaning that both nut support and motor must be put on joints. Also, the movement is very slow.

3D Modelling & Design

Figure 2 - 3D Model

As seen in Figure 2, most elements are connected with mobile constraints. For the actuator to work, the motor and nut must be on two separate components. Motor 1 is fixed in Joint A on the lower support. The nut is fixed in Joint C on the arm’s frame while the arm itself and support are connected in Joint B. The same thing happens with arm-boom articulation (Joint E) and its Motor 2 (Joint D) with corresponding nut (Joint F).

Figure 3 - Robotic Claw Gripper

The claw’s components (figure 3) are entirely designed by us. Similar to the other two actuators, the difference is that the motor is fixed and the nut can move only along the thread. Nut support, arms and forearms are connected with articulated joints too, resulting in a parallel movement that widens the gap between the arms’ tips if the nut unscrews and vice versa. It is designed to hold anything from 1 to 60 millimetres.

1 / 3 • Figure 4 - LEGO worm gear

Moving on, to control the overall claw’s inclination I added another DC motor. Considering the small space at the top of the boom, another actuator wasn’t practical. So I implemented a LEGO worm gear (figure 4), mounted on the motor’s shaft, which turns a spur gear fixed on the Motor4 Bracket, having the same effect of locking in place once the motor stops. This gearing has a 1:8 ratio, it takes 8 turns for the worm to fully revolve the spur gear once.

3D Printing

In total, there are 27 elements. It required me 43 hours to print them. I have used PLA as filament, and the total cost of all printing, if you use your 3D printer, should be around 6 € (where the filament roll costs 20 €). So even if the printing time takes too long, the price is much better than if you print it at your 3D printer.

Joystick Android App

Figure 5 - User interface

As for the software, I designed an Android app (figure 5) with two joysticks, each with its XY axis. Every axis controls the direction and the speed of one motor. When the user moves the joysticks, the app sends the instructions to the Arduino, which interprets them and sends the correspondent signal to the motor drivers.

if (val > 100) { //if val on the OX/OY axis has a positive value ≈ val > 100
    int x = map(val, 100, 200, 0, 255); //motor spins forward
}
else {
    int x = map(val, 100, 0, 0, 255); //motor spins backward
}

In other words, depending on the position of the joystick, it sends a value for each axis from 0 (down) to 200 (up). Thus, the position with the value 100 represents the value of the centre. The Arduino receives these values and sends an analog signal (from 0 to 255, backward and forward) to the motor via the motor driver.

Optional - potentiometers

This model was originally intended to be implemented with object detection, but I abandoned the idea due to a long time it would have taken for this project. Thus, supports for a linear potentiometer module remained implemented (figure 6). These potentiometers have the role of rendering the value of the angle formed by the components, to be able to implement a program that makes the claw gripper parallel to the ground. In addition to this, they also have the role of stopping the engines if the moving parts do not move.

I also implemented a button when opening the claw gripper so that the engine does not rotate when the device arms reach the maximum angle.

Schematics

Code

Robotic Arm Code

/*
 * Code made by Bot Reboot
 * For further explanation for phase, enbl and mode,
 * see the Polulu DRV8835 Dual Motor Driver Carrier
 */
struct Motor {
  int nrMotor;
  int phase; //GPIO input
  int enbl; //PWM input
}m1, m2, m3, m4;

int val, cnt = 0, v[3];
int mode1 = 7;
int mode2 = 8;

void setup() {
  // put your setup code here, to run once:
  Serial.begin(9600);
  
  m1.nrMotor = 1;
  m2.nrMotor = 2;
  m3.nrMotor = 3;
  m4.nrMotor = 4;
  m1.phase = 4;
  m2.phase = 6;
  m3.phase = 10;
  m4.phase = 12;
  m1.enbl = 3;
  m2.enbl = 5;
  m3.enbl = 9;
  m4.enbl = 11;
  
  pinMode(m1.phase, OUTPUT);
  pinMode(m1.enbl, OUTPUT);
  pinMode(m2.phase, OUTPUT);
  pinMode(m2.enbl, OUTPUT);
  pinMode(m3.phase, OUTPUT);
  pinMode(m3.enbl, OUTPUT);
  pinMode(m4.phase, OUTPUT);
  pinMode(m4.enbl, OUTPUT);
  pinMode(mode1, OUTPUT);
  pinMode(mode2, OUTPUT);

  delay(50);
  digitalWrite(mode1, HIGH);
  digitalWrite(mode2, HIGH);
}

////////////Bluetooth Communication
void valuesread() {
  val = Serial.read();
  cnt++;
  v[cnt] = val;
  if (cnt == 3)
    cnt = 0;
}
void processing() {
  int a = v[1];
  if (a == 1) { //left joystick 
    motor_controler(m2, v[2]); //OX axis
    motor_controler(m1, v[3]); //OY axis
  }
  if (a == 2) { //right joystick
    motor_controler(m4, v[2]); //OX axis
    motor_controler(m3, v[3]); //OY axis
  }
}

void loop() {
  // put your main code here, to run repeatedly:
  if (Serial.available()) {
    while(Serial.available() == 0);
    valuesread(); 
  }
  processing();
}

////////////Motor Control

void forward_brake(Motor m, int val) {
  digitalWrite(m.phase, HIGH);
  analogWrite(m.enbl, val);
}

void backward_brake(Motor m, int val) {
  digitalWrite(m.phase, LOW);
  analogWrite(m.enbl, val);
}

void motor_controler(Motor &m, int val) {
  if(val == 100) {
    forward_brake(m, 0);
  }
  else {
    if (val > 100) {
      int x = map(val, 100, 200, 0, 255);
      forward_brake(m, x);
    }
    else {
      int x = map(val, 100, 0, 0, 255);
      backward_brake(m, x);
    }
  }
}

Credits

Bot Reboot

3 projects • 37 followers

Student in the first year at CSE TU Delft.

Comments

Awards

Early Bird - US Based Project

2021 China-US Young Maker Competition

Robotic Arm (with linear actuators)