Kinematics is about how you convert the position and velocity of an end effector (e.g. gripper, robotic hand, etc.) to position and velocity of the joints (i.e. the servo motors along a robotic arm), and vice-versa. 

Let’s take a look at the vocabulary of that sentence.

An end effector is the component on a robot arm that has an effect on the environment. For example, consider this robotic arm below. The end effector is the silver robotic gripper.

An end effector could also be a robotic hand or a vacuum gripper.

A joint on a robot is like a joint on the human body (shoulder, elbow, et.). A joint is the moveable part of a robot. 

For a typical robotic arm, a joint is a motor that connects one link to another link. To continue the analogy of the human body, the lower arm and upper arm links are connected by the elbow joint.

In the photo of the robotic arm above, there are 6 joints (i.e. 6 motors). Going from the base of the robot to the gripper, you have a:

• Base joint (Motor 0)
• Shoulder joint (Motor 1)
• Elbow joint (Motor 2)
• Wrist joint (Motor 3)
• Hand joint (Motor 4)
• Gripper Joint (i.e. the silver claw) (Motor 5)

Links (i.e. the black brackets in the robotic arm above) are the stiff components that connect the joints (i.e. servo motors) together.

In this tutorial, we will build a robotic arm with a vacuum suction cup that can enable you to pick up items in one location and place them in another.

Our goal is to build an early prototype of a product that can make it easier and faster for factories and warehouses to do their work.

Real-World Applications

Robotic arm systems have a number of real-world applications. Here are just a few examples: 

• Warehouses and Logistics (the largest market for this kind of robot): 
  • Picking items off shelves and placing them into boxes for shipping (e.g. IAM Robotics, Order fulfillment at Amazon, Covariant.ai’s pick and place robot – see below, Nomagic’s robot).
  • Stacking boxes (e.g. Boston Dynamics)
  • Automated storage and retrieval of items. 
  • Removing defective products off conveyor belts (i.e. quality control).
• Grocery Stores
  • Grocery picking and packing system using computer vision (e.g. British online supermarket, Ocado).
  • Restocking shelves.
• Hospitals and Medical Centers (the second largest market for professional service robots):
  • Perform ultrasounds, take mouth swabs, and listen to sounds made by a patient’s organs in order to prevent frontline medical professionals from getting infected (e.g. Beijing’s Tsinghua Changgung Hospital).
• Military
  • Disarm explosives.
• Food Processing Plants
  • Here is a link to a YouTube video of a sandwich factory that processes 3 million sandwiches every week.

Not only do robotic arms help solve labor shortages, but they also help increase productivity when they work alongside humans. In this video from The Wall Street Journal, you can see how robotic arms working side-by-side with humans can enhance productivity.

We will build an early prototype of the products you see above. Let’s get started!

Prerequisites

• You have the Arduino IDE (Integrated Development Environment) installed on your PC (Windows, MacOS, or Linux).
• You have experience controlling multiple motors using Arduino (helpful but not required).

You Will Need

This section is the complete list of components you will need for this project: 

Robot Arm Kit (Assembled) – Go to ebay and type “Air Pump Robotic Arm Kit” or go to Aliexpress and type “Robotic arm vacuum suction pump”

• 2 x KS-3620 180° Servo (Suitable Voltage: 4.8 – 6.6V; No-load Current: 80-100mA)
• 1 x KS-3620 270° Servo  (Suitable Voltage: 4.8 – 6.6V; No-load Current: 80-100mA)
• 1 x Micro Air (Vacuum) Pump (Suitable Voltage: 3.7V – 6V; Rated current: <0.4A)
• 1 x Solenoid Valve – Electrically controlled valve that opens up and lets air through when it receives the proper voltage – (Suitable Voltage 3V – 6V; Rated current: 0.14A)
• 1 x Silicone Tubing Hose (2mm inner diameter)

Robot Suction Cup Vacuum Pump Kit For 25T (i.e. 25 Teeth Servo Spline) Servos (check ebay or Aliexpress)

• 1 x Set of Silicone Suction Cup (Dual)
• 2 x PWM Electronic Switches
• 1 x Vacuum Pump
• 1 x 800mm Silicone Hose
• 1 x Tee-Joint Electronic Valve (also known as Solenoid Valve)

Extra Components You’ll Need

• 1 x Arduino Mega 2560 Rev 3 (Recommended Voltage: 7V – 12V, Voltage Range: 6-20V)
• 3 x 10K Ohm Potentiometer with Knobs
• 2 x On Off Mini Rocker Switch
• 1 x Momentary Push Button Switch
• 1 x 9V Battery Clip with 2.1 x 5.5 mm Male DC Power Plug
• 1 x 9V Battery (to plug into the Arduino board)
• 1 x 3m Length Food Grade Translucent Silicone Tubing Hose 2mm ID x 4mm OD 
• 3 in 1 Jumper Wires
• 2 x 400-Point Solderless Breadboards (Stick two of them together to create a large breadboard)
• Alligator Clip to Male and Female Jumper Wires
• 1 x DC Adjustable Power Supply Capable of 30V/10A (This will power everything but the Arduino and potentiometers…you could also use a 4 x AA Battery Holder With Wires or a 6V, 2800mAh, NiMH Battery Pack. Just be aware that these batteries will drain really quickly).
• 2 x C Shape Desk Table Mount Clamp (to secure the arm to a table)
• Fender Washers 18-8 Stainless Steel Large Diameter Washers – Size: 1/2 in. Inner Diameter x 2 in. Outer Diameter (search on ebay)
• 1x Force-Sensitive Resistor
• 1 x 10k Ohm Resistor
• 1 x Heat Insulation Silicone Repair Mat
• 1 x 40-Watt Soldering Station
• 1 x 63-37 Tin Lead Rosin core solder wire
• 1 x Damp sponge
• 1 x Roll of Scotch Tape
• 1 x Roll of Scotch Permanent Mounting Tape, 1 Inch x 125 Inches
• 1 x Spiral Wire Wrap (Optional. For organizing the wires.)
• 1 x Acrylonitrile Butadiene Styrene (ABS) Plastic Dustproof Waterproof Box (Optional. I won’t use this in this project, but you would use this to house all the electronics.)
• 1 x Cordless Power Drill Set (Optional. To drill holes in the waterproof box).

Getting Started

Test the Servo Motors

The first thing we need to do is to test the three servo motors. 

Here is the wiring diagram in pdf format. 

We need to power the servo motors with an external power supply because they draw a lot of current…so much current that it would damage your Arduino Mega if you were to connect the power leads directly.

Here are two different programs you can use to test. The first program enables you to control the position of the servos directly using the potentiometers. The second program sweeps each motor back and forth.

When you launch these programs on the robot, I recommend you turn on the external power first. Then plug the 9V battery into the Arduino.

/*
Program: Control 3 Servos Using Arduino and Potentiometers
File: control_3_servos_with_potentiometer_varspeedservolib.ino
Description: Turn the knob of the potentiometers 
             to control the angle of the 3 servos.
             This program enables you to control the speed of the servos
             as well.
Author: Addison Sears-Collins
Website: https://automaticaddison.com
Date: July 10, 2020
*/
 
#include <VarSpeedServo.h> 

// Define the number of servos
#define SERVOS 3

// Create the servo objects.
VarSpeedServo myservo[SERVOS]; 

// Speed of the servo motors
// Speed=1: Slowest
// Speed=255: Fastest.
const int desired_speed = 255;

// Attach servos to digital pins on the Arduino
int servo_pins[SERVOS] = {3,5,6};

// Analog pins used to connect the potentiometers
int potpins[SERVOS] = {A0,A1,A2}; 

// Variables to read the value from the analog pin
int potpin_val[SERVOS]; 

void setup() {
  
  for(int i = 0; i < SERVOS; i++) {
    
    // Attach the servos to the servo object 
    // attach(pin, min, max  ) - Attaches to a pin 
    // setting min and max values in microseconds
    // default min is 544, max is 2400 
    myservo[i].attach(servo_pins[i], 544, 2400);  
  }
}
 
void loop() {  

  // Update servo position
  for(int i = 0; i < SERVOS; i++) {
    potpin_val[i] = analogRead(potpins[i]);
    potpin_val[i] = map(potpin_val[i], 0, 1023, 0, 180);
    myservo[i].write(potpin_val[i], desired_speed, true);
  }
}    

/*
Program: Control 3 Servos Using Arduino and Sensor Shield v5.0
File: move_3_servo_motors_to_angle.ino
Description: Move servo motors to a specific angle
Author: Addison Sears-Collins
Website: https://automaticaddison.com
Date: July 10, 2020
*/
 
#include <VarSpeedServo.h> 

// Define the number of servos
#define SERVOS 3

// Create the servo objects.
VarSpeedServo myservo[SERVOS]; 

// Speed of the servo motors
// Speed=1: Slowest
// Speed=255: Fastest.
const int desired_speed = 25;

// Attach servos to digital pins on the Arduino
int servo_pins[SERVOS] = {3,5,6};

void setup() {
  
  for(int i = 0; i < SERVOS; i++) {
    
    // Attach the servos to the servo object 
    myservo[i].attach(servo_pins[i]);  
  }
}
 
void loop() {  

  // Move each servo back and forth
  for(int i = 0; i < SERVOS; i++) {
    myservo[i].write(60, desired_speed, true); 
    myservo[i].write(120, desired_speed, true);   
    myservo[i].write(60, desired_speed, true); 
    delay(250);
  }
  delay(250); 
}     

Connect the Components

Now that you’ve tested the motors, it is time to connect everything else.

Get all the components that you need to build this project, and lay them out on a table. Now is a good time to double check that you have everything you need.

Wire up all the components. You can use either this diagram or this diagram depending on your preference. 

I suggest downloading the wiring diagram and then zooming in so you can see everything. 

Don’t be intimidated by all the connections. Just go one part and one wire at a time. Take it slowly so that you wire everything up correctly.

For the two solenoid wires and the momentary push button switch, it doesn’t matter which one is Ground and which one is VCC (i.e. positive voltage).

Launch Manual Suction Control

We will control our robot manually using the three potentiometers. Load the control_3_servos_with_potentiometer_varspeedservolib.ino program (you made earlier) to your Arduino.

Now plug in everything so that your program is running. The power supply I’m using is 6V for the voltage with a 3A current limit.

You may notice in the beginning that the servos jump a bit when you first launch the program. That’s totally normal.

In a real-world setting, you would want to consider programming the robot so that you can press a button and return the servos to the home position before you shut it down. Then, when you restart the program, the robotic arm will initialize in the home position. This way, you won’t have an arm flying around when you launch the arm. 

Using the potentiometers to control the angles of the servos, move the suction cup to a specific object you want to pick up.

When the suction cup reaches the object, push and hold down quickly on the object in order to pick it up.

Then move the servos to your desired drop location.

When ready, release the suction by pushing the momentary push button switch.

Launch Automatic Suction Control

We will now use a force sensitive resistor to control when to deactivate suction. A force sensitive resistor detects physical pressure, squeezing, and weight.

We will use this resistor to automatically detect when the suction cup has made contact with an object. This component will therefore help us automate the process of picking and placing an object.

Test the Force Sensitive Resistor

Let’s begin by writing a small program to test the force sensitive resistor.

Here is the wiring diagram in pdf format.

Here is the code. I saved the file as test_force_sensitive_resistor.ino:

/* FSR simple testing sketch. 
 
Connect one end of FSR to power, the other end to Analog 5.
Then connect one end of a 10K resistor from Analog 5 to ground 
 
For more information see www.ladyada.net/learn/sensors/fsr.html */
 
int fsrPin = A5;     // the FSR and 10K pulldown are connected to A5
int fsrReading;     // the analog reading from the FSR resistor divider
 
void setup(void) {
  // We'll send debugging information via the Serial monitor
  Serial.begin(9600);   
}
 
void loop(void) {
  fsrReading = analogRead(fsrPin);  
 
  Serial.print("Analog reading = ");
  Serial.print(fsrReading);     // the raw analog reading
 
  // We'll have a few threshholds, qualitatively determined
  if (fsrReading < 10) {
    Serial.println(" - No pressure");
  } else if (fsrReading < 200) {
    Serial.println(" - Light touch");
  } else if (fsrReading < 500) {
    Serial.println(" - Light squeeze");
  } else if (fsrReading < 800) {
    Serial.println(" - Medium squeeze");
  } else {
    Serial.println(" - Big squeeze");
  }
  delay(200);
} 

For a full description of the force sensitive resistor, check out this post on Adafruit.com. 

Load the code to your Arduino.

With your USB still plugged in, run the code, and open the Serial Monitor in the Arduino IDE. You will need to click the green magnifying glass in the upper-right of the IDE.

Press the round part of the force sensitive resistor with your finger, and observe the output on the Serial Monitor.

I highly recommend soldering the Force Sensitive Resistor to male-to-male solder wires. 

If you’ve never soldered before, there are a ton of good YouTube videos on how to do it. You can also check this link where I did some soldering for a robotic car.

Install the Force Sensitive Resistor on the Robot

Cover the head (round part) of the force sensitive resistor in order to protect it. I used some cling wrap and tape to protect it.

Secure the cling wrap over the force sensitive resistor using some scotch tape.

Now grab one of the big washers (with 1/2 in. inner diameter and 2 in. outer diameter).

Cut some small pieces of Scotch permanent mounting tape, and place it around the hole.

Slide the washer over the tube until it sits on top of the nut above the suction cup.

Now grab the other big washer (with 1/2 in. inner diameter and 2 in. outer diameter).

Tape it to the end-effector of the robotic arm using Scotch permanent mounting tape.

Grab the force sensitive resistor and tape it to the big washer that is attached to the robotic arm (i.e. the upper washer). The two wires should flow out through the back of the robotic arm.

The front of the force sensitive resistor should face upward right against the tape.

Take the tube and thread it through the hole in the robotic arm.

Place a washer and then a nut down over the tube so that both sit on top of the end effector.

Using your fingers, secure the nut on top of the washer. Do not secure it tightly…just enough so that it isn’t loose (We’ll come back to this screw in the next section)

Pictures are worth 1000 words, so here is how the setup should look when you’re done.

Calibrate the Robotic Arm With Force Sensitive Resistor

Now, we need to adjust the nut that sits on top of the end effector to the appropriate tightness.

Connect the force sensitive resistor according to the wiring diagram here in pdf format.

Load test_force_sensitive_resistor.ino to your Arduino.

With your USB still plugged in, run the code, and open the Serial Monitor in the Arduino IDE. You will need to click the green magnifying glass in the upper-right of the IDE.

You should see the reading “no pressure” on your Serial Monitor.

Tighten the nut until you see a reading of “Light touch,” “Light squeeze,” or “Medium squeeze.” 

Now, loosen the nut until you see the first reading of “No pressure”. 

To test to see if everything is working properly, with your hand (no need to turn on the motors), guide the robotic arm towards an object. 

Press the suction cup down on an object and then pull it off the object. 

1. Each time you press the suction cup down on an object you should see either “Light touch,” “Light squeeze,” “Medium squeeze,” or “Big squeeze.”
2. When the suction cup isn’t touching anything, you should see “No pressure.”

Once you’ve got 1 and 2 above, your robotic arm with force sensitive resistor is calibrated properly.

Have patience. It takes a while to secure the nut to just the right tightness. You want it not too tight but not too loose.

Test the Solenoid Valve With PWM Electronic Switch 

Let’s test our solenoid valve to see if it is working properly. You will need to wire everything up like you see in this diagram.

If you are using a DC variable power supply, like I am, set it for 0.5A for the current limit and 6V for the voltage.

Where did I get 0.5A from? I know the current ratings for the vacuum pump and the solenoid, so I’m considering a 0.3A max for the vacuum pump and 0.2A max for the solenoid so that I don’t destroy them by allowing too much current to flow through them.

Now, write the following code and upload it to your Arduino. This code makes the vacuum suction cup turn ON for five seconds and then turn OFF for five seconds. 

/*
Program: Test Solenoid Valve With PWM Electronic Switch
File: test_solenoid_valve.ino
Description: This program tests a solenoid valve 
  with electronic switch to see if it is working
  properly.
Author: Addison Sears-Collins
Website: https://automaticaddison.com
Date: July 29, 2020
*/

#include <VarSpeedServo.h> 

// Create a solenoid valve control object
VarSpeedServo my_solenoid_valve;

// Attach solenoid to digital pin on the arduino
int solenoid_pin = 9;

void setup() {
  // Attach the solenoid to the solenoid valve control object
  my_solenoid_valve.attach(solenoid_pin);

  // We assume the vacuum pump is turned ON
  // When the vacuum pump is ON, and the solenoid valve OFF:
  // --Suction is ON
  // When the vacuum pump is ON, and the solenoid valve ON:
  // --Suction is OFF
  // Start with solenoid valve OFF (0 is OFF, 180 is ON)
  my_solenoid_valve.write(0);
}

// The vacuum suction cup turns ON for five seconds and then 
// turns OFF for five seconds. 
void loop() {
  my_solenoid_valve.write(0); // Turn the solenoid valve OFF (Suction is ON)
  delay(5000); // Wait five seconds
  my_solenoid_valve.write(180); // Turn the solenoid valve OFF (Suction is OFF)
  delay(5000); // Wait five seconds
  
}

Test the Vacuum Pump With PWM Electronic Switch 

Let’s test our vacuum pump to see if it is working properly. You will need to wire everything up like you see in this diagram.

If you are using a DC variable power supply, like I am, set it for 0.5A for the current limit and 6V for the voltage. 

Now, write the following code and upload it to your Arduino. This code makes the vacuum suction cup turn ON for five seconds and then turn OFF for five seconds. 

/*
Program: Test Vacuum Pump With PWM Electronic Switch
File: test_vacuum_pump.ino
Description: This program tests a vacuum pump 
  with electronic switch to see if it is working
  properly.
Author: Addison Sears-Collins
Website: https://automaticaddison.com
Date: July 29, 2020
*/

#include <VarSpeedServo.h> 

// Create a vacuum pump control object
VarSpeedServo my_vacuum_pump;

// Attach vacuump pump to digital pin on the arduino
int vacuum_pump_pin = 10;

void setup() {
  // Attach the vacuum pump to the vacuum pump control object
  my_vacuum_pump.attach(vacuum_pump_pin);

  // Start with vacuum pump ON (0 is OFF, 180 is ON)
  my_vacuum_pump.write(180);
}

// The vacuum suction cup turns ON for five seconds and then 
// turns OFF for five seconds. 
void loop() {
  my_vacuum_pump.write(180); // Turn the vacuum pump ON (Suction is ON)
  delay(5000); // Wait five seconds
  my_vacuum_pump.write(0); // Turn the vacuum pump OFF (Suction is OFF)
  delay(5000); // Wait five seconds
  
}

Test the Vacuum Pump and Solenoid Valve With PWM Electronic Switches

Let’s test our vacuum pump and solenoid valve together to see if they work properly as a unit. You will need to wire everything up like you see in this diagram.

If you are using a DC variable power supply, like I am, set it for 0.5A for the current limit and 6V for the voltage. 

Now, write the following code and upload it to your Arduino. This code makes the vacuum suction cup turn ON for five seconds and then turn OFF for five seconds. 

/*
Program: Test Vacuum Pump and Solenoid Valve With PWM Electronic Switches
File: test_vacuum_pump_and_solenoid.ino
Description: This program tests the vacuum pump and solenoid valve 
  together to see if they work properly as a unit. 
Author: Addison Sears-Collins
Website: https://automaticaddison.com
Date: July 29, 2020
*/

#include <VarSpeedServo.h> 

// Create a solenoid valve control object
VarSpeedServo my_solenoid_valve;

// Create a vacuum pump control object
VarSpeedServo my_vacuum_pump;

// Attach solenoid to digital pin on the arduino
int solenoid_pin = 9;

// Attach vacuump pump to digital pin on the arduino
int vacuum_pump_pin = 10;

void setup() {
  // Attach the solenoid to the solenoid valve control object
  my_solenoid_valve.attach(solenoid_pin);

  // Attach the vacuum pump to the vacuum pump control object
  my_vacuum_pump.attach(vacuum_pump_pin);

  // We assume the vacuum pump is turned ON
  // When the vacuum pump is ON, and the solenoid valve OFF:
  // --Suction is ON
  // When the vacuum pump is OFF, and the solenoid valve ON:
  // --Suction is OFF
  // Start with vacuum pump ON (0 is OFF, 180 is ON)
  my_vacuum_pump.write(180);
  // Start with solenoid valve OFF (0 is OFF, 180 is ON)
  my_solenoid_valve.write(0);
}

// The vacuum suction cup turns ON for five seconds and then 
// turns OFF for five seconds. 
void loop() {

  // Suction is ON
  my_solenoid_valve.write(0); 
  my_vacuum_pump.write(180); 
  
  delay(5000); // Wait five seconds

  // Suction is OFF
  my_solenoid_valve.write(180);
  my_vacuum_pump.write(0); 
  
  delay(5000); // Wait five seconds  
}

Test Force Sensitive Resistor With Vacuum Pump and Solenoid Valve

Let’s add our force sensitive resistor to our setup.

You will need to wire everything up like you see in this diagram.

If you are using a DC variable power supply, like I am, set it for 0.5A for the current limit and 6V for the voltage. 

Now, write the following code and upload it to your Arduino. This code runs in two stages:

• Stage 0 (Pick up object)
  • Starts with the suction turned OFF (i.e. vacuum is OFF and solenoid is ON)
  • Gives you time to move the robotic arm in position so that the vacuum suction cup is touching the object you want to pick up.
  • Checks to see if the vacuum suction cup is touching the object you want to pick up.
  • If the vacuum suction cup is touching the object you want to pick up, suction is turned ON (i.e. vacuum is switched ON and solenoid is switched OFF).
• Stage 1 (Place object)
  • Gives you time to move the robotic arm in position to place the object in your desired location.
  • Suction is turned OFF, and the object is released.

/*
Program: Test Force Sensitive Resistor With Vacuum Pump and Solenoid Valve
File: test_vacuum_solenoid_force_sensor.ino
Description: This program tests the vacuum pump, solenoid valve, and 
  force sensitive resistor to see if they work properly as a unit. 

  Connect one end of FSR to power, the other end to Analog 5.
  Then connect one end of a 10K resistor from Analog 5 to ground.
Author: Addison Sears-Collins
Website: https://automaticaddison.com
Date: July 29, 2020
*/

#include <VarSpeedServo.h> 

// Create a solenoid valve control object
VarSpeedServo my_solenoid_valve;

// Create a vacuum pump control object
VarSpeedServo my_vacuum_pump;

// Attach solenoid to digital pin on the arduino
int solenoid_pin = 9;

// Attach vacuum pump to digital pin on the arduino
int vacuum_pump_pin = 10;

int fsrPin = A5;     // the FSR and 10K pulldown are connected to A5
int fsrReading = 0;     // the analog reading from the FSR resistor divider
int stage = 0; // Keep track of the stage we are in

void setup() {
  
  // Attach the solenoid to the solenoid valve control object
  my_solenoid_valve.attach(solenoid_pin);

  // Attach the vacuum pump to the vacuum pump control object
  my_vacuum_pump.attach(vacuum_pump_pin);

  // When the vacuum pump is ON, and the solenoid valve OFF:
  // --Suction is ON
  // When the vacuum pump is OFF, and the solenoid valve ON:
  // --Suction is OFF
  // Start with Suction OFF
  my_solenoid_valve.write(180); // 0 is OFF, 180 is ON
  my_vacuum_pump.write(0); // 0 is OFF, 180 is ON
}

void loop() {

  /* Stage 0 - Pick up an object */
  while(stage == 0) {

    // Check to see if contact has been made with an object
    fsrReading = analogRead(fsrPin);
    fsrReading += analogRead(fsrPin);
    fsrReading += analogRead(fsrPin);
    fsrReading = fsrReading / 3;
    if (fsrReading > 300) {
      // Suction is ON
      my_solenoid_valve.write(0); 
      my_vacuum_pump.write(180); 
      stage = 1;
    }
  }

  // Move the robotic arm into position to place the object.
  // Delay is in milliseconds. Change this value as you see fit.
  delay(3000); 

  /* Stage 1 - Place an object */
  // Suction is OFF
  my_solenoid_valve.write(180); 
  my_vacuum_pump.write(0); 
  stage = 0;
}

Putting It All Together for Pick and Place

Now, to finish off all this, let’s add the servo motors so that we can control the robotic arm with the potentiometers.

You will need to wire everything up like you see in this diagram.

If you are using a DC variable power supply, like I am, set it for 3.5A for the current limit and 6V for the voltage. 

Now, write the following code and upload it to your Arduino. Control the robotic arm using the three potentiometers. The code is similar to the code from the last section with just a few new lines of code.

/*
Program: Robot With Vacuum Pump and Automatic Suction Control
File: automatic_suction_control.ino
Description: This program uses a vacuum pump, solenoid valve, and 
  force sensitive resistor to create automatic suction control. 

  Connect one end of FSR to power, the other end to Analog 5.
  Then connect one end of a 10K resistor from Analog 5 to ground.
Author: Addison Sears-Collins
Website: https://automaticaddison.com
Date: July 30, 2020
*/

#include <VarSpeedServo.h> 

/********************** SERVOS ***********************/
// Define the number of servos
#define SERVOS 3

// Create the servo objects.
VarSpeedServo myservo[SERVOS]; 

// Speed of the servo motors
// Speed=1: Slowest
// Speed=255: Fastest.
const int desired_speed = 255;

// Attach servos to digital pins on the Arduino
int servo_pins[SERVOS] = {3,5,6};

// Analog pins used to connect the potentiometers
int potpins[SERVOS] = {A0,A1,A2}; 

// Variables to read the value from the analog pin
int potpin_val[SERVOS]; 

/****************** SOLENOID VALVE *******************/

// Create a solenoid valve control object
VarSpeedServo my_solenoid_valve;

// Attach solenoid to digital pin on the arduino
int solenoid_pin = 9;

/******************* VACUUM PUMP *********************/

// Create a vacuum pump control object
VarSpeedServo my_vacuum_pump;

// Attach vacuum pump to digital pin on the arduino
int vacuum_pump_pin = 10;

/*************** FORCE SENSITIVE RESISTOR *************/

int fsrPin = A5;     // the FSR and 10K pulldown are connected to A5
int fsrReading = 0;     // the analog reading from the FSR resistor divider
int stage = 0; // Keep track of the stage we are in

void setup() {

  // Set up servos
  for(int i = 0; i < SERVOS; i++) {
    
    // Attach the servos to the servo object 
    // attach(pin, min, max  ) - Attaches to a pin 
    // setting min and max values in microseconds
    // default min is 544, max is 2400 
    myservo[i].attach(servo_pins[i], 544, 2400);  
  }
  
  // Attach the solenoid to the solenoid valve control object
  my_solenoid_valve.attach(solenoid_pin);

  // Attach the vacuum pump to the vacuum pump control object
  my_vacuum_pump.attach(vacuum_pump_pin);

  // When the vacuum pump is ON, and the solenoid valve OFF:
  // --Suction is ON
  // When the vacuum pump is OFF, and the solenoid valve ON:
  // --Suction is OFF
  // Start with Suction OFF
  my_solenoid_valve.write(180); // 0 is OFF, 180 is ON
  my_vacuum_pump.write(0); // 0 is OFF, 180 is ON

}

void loop() {

  /* Stage 0 - Pick up an object */
  while(stage == 0) {

    // Move the robotic arm into position to pick up the object
    // Modify the number of time steps as you see fit.
    for(int j = 0; j < 50; j++) {

      // Update servo position
      for(int i = 0; i < SERVOS; i++) {
        potpin_val[i] = analogRead(potpins[i]);
        potpin_val[i] = map(potpin_val[i], 0, 1023, 0, 180);
        myservo[i].write(potpin_val[i], desired_speed, true);
      }
    }

    // Check to see if contact has been made with an object
    fsrReading = analogRead(fsrPin);
    fsrReading += analogRead(fsrPin);
    fsrReading += analogRead(fsrPin);
    fsrReading = fsrReading / 3;
    if (fsrReading > 300) {
      // Suction is ON
      my_solenoid_valve.write(0); 
      my_vacuum_pump.write(180); 
      stage = 1;
    }
  }

  // Move the robotic arm into position to place the object
  // Modify the number of time steps as you see fit.
  for(int j = 0; j < 3000; j++) {
    
    // Update servo position
    for(int i = 0; i < SERVOS; i++) {
      potpin_val[i] = analogRead(potpins[i]);
      potpin_val[i] = map(potpin_val[i], 0, 1023, 0, 180);
      myservo[i].write(potpin_val[i], desired_speed, true);
    }
  }

  /* Stage 1 - Place an object */
  // Suction is OFF
  my_solenoid_valve.write(180); 
  my_vacuum_pump.write(0); 
  stage = 0;
}

In this tutorial, we will build a robotic arm with six degrees of freedom from scratch. A degree of freedom is the number of variables needed to fully describe the position and orientation of a system (e.g. x, y, z, and rotation about each of those axes in the case of our robotic arm).

Our goal is to build an early prototype of a product to make it easier and faster for factories, warehouses, and food processing plants to pick up objects and place them into boxes (i.e. pick and place).

I modeled the robot in a CAD (Computer-aided design) program called Creo Parametric. Here are the STL files.

Real-World Applications

Robotic arm systems have a number of real-world applications. Here are just a few examples: 

• Warehouses and Logistics
• Grocery Stores
• Hospitals and Medical Centers
• Military
• Food Processing Plants
• And more…

Let’s get started!

Prerequisites

• No prior knowledge necessary. We’ll build everything from the ground up.

You Will Need

This section is the complete list of components you will need for this project.

• 6DOF Robotic Arm Kit with MG996R Servos (Robotic arm)
• Phillips Screwdriver
• 7/32 Wrench
• 9/32 Wrench
• Needle-nose Pliers
• Wire cutters
• 1 Male-to-Female, Female-to-Female, and Male-to-Male Jumper Wires Kit
• 1 6-Channel Digital Servo Tester
• 4xAA Battery Holder with On Off Switch
• 4 AA Batteries
• 1 x DC Adjustable Power Supply Capable of 30V/10A (You could also use a 4 x AA Battery Holder With Wires or a 6V, 2800mAh, NiMH Battery Pack. Just be aware that these batteries will drain really quickly).

Directions

Let’s assemble the robotic arm. Follow the steps carefully, and take your time to make sure everything is set up properly. It took me almost a week to assemble the arm. Go slowly.

The instructions for assembling the arm come inside the package, but let’s walk through the process anyways.

Unpack the Robotic Arm Kit

Open the robotic arm kit. Lay out all the components on a table. You should have the following pieces of hardware:

• 1 x Aluminum Clamp Claw
• 1 x L-type Servo Bracket
• 3 x U-type Robot Waist Bracket
• 4 x Long U-type Servo Bracket
• 4 x Miniature Ball Radial Bearing
• 5 x Multi-functional Servo Bracket
• 6 x MG996R Servo
• 6 Sets x Aluminum Servo Horns
• 4 Sets x Round Head M3*10 Screws and M3 Nuts (The 10 means 10mm in length, including the head)
• 20 Sets x Round Head M3*8 Screws and M3 Nuts 
• 24 Sets x Fixed Head M4*10 Screws and M4 Nuts (I never used these)
• 30 Sets x Round Head M3*6 Screws and M3 Nuts
• *Note: The kit that I have didn’t have labels on the screws, making it tricky to figure out what screws to use at what stage. Just use screws and nuts that can fit into the hole when the time comes. Don’t sweat over the exact type of screw I mention in this tutorial. The end goal is to make sure every part is secure.

Assemble the Base

Grab 6 x M3*8 screws and nuts (these are the screws that are 8mm long from the top of the head to the base of the screw)..

Using a screwdriver (helpful to use needle-nose pliers to hold the nut in place as you screw in the screws and nuts), connect two of the U-type robot waist brackets together using the M3*8 screws and nuts.

Grab the third U-type robot bracket, and attach it to one side of the base using six M3*8 screws and nuts.

Install the First Servo Motor

Grab one M3*10 screw, nut, and a bearing.

Grab one Multi-functional servo bracket.

Place a screw through the hole. It might have a bit of trouble fitting through the hole, so make sure you apply enough force to snap it through there.

Insert the bearing over the screw, with the wide end of the bearing touching the Multi-functional servo bracket.

Insert the nut over the screw in order to hold the bearing in place. 

Tighten the screw with a 7/32 inch wrench.

Now we need to attach the Multi-functional servo bracket to that U-type bracket that was mounted on top of the robot base. Use four M3*6 screws and nuts to do this job.

Take one of your servo motors outside of its bag.

Mount it over the two arms of the Multi-functional servo bracket. Make sure the motor is mounted just as you see it here. We will call this servo motor the steering servo.

Get four M3*8 screws and nuts (the fattest screws and nuts in the kit). Use these to secure the steering servo into place. 

I recommend holding the nut in place with one of your fingers or the needle-nose pliers and using a Phillips screwdriver to tighten the screw inside the nut. 

Here is how your setup should look at this stage.

Grab one of the plastic rocker arms. It should be inside the bag that had your servo motor.

Insert the rocker arm on top of the steering servo. The grooves of the steering servo should fit nicely with the grooves of the rocker arm.

The rocker arm should be placed perpendicular across the steering servo axis (i.e. that golden, grooved metal circle on top of the steering servo).

Now take your finger and move the rocker arm to the left and to the right.

Take note of where the rocker stops turning when you twist the rocker arm to the left side with your fingers.

Now take note of where the rocker arm stops turning on the right side.

Reposition the rocker arm so that it is perpendicular across the steering servo when the underlying steering servo axis is exactly at the halfway point between the left and right stopping points that you just marked.

After you have adjusted the angle of the steering servo axis using the rocker arm, grab the servo horn.

Carefully remove the rocker arm by pulling it straight up off the steering servo axis. You want to be careful not to move the steering servo axis.

Fit the servo horn on top of the steering servo axis so that it looks like this. One of the holes of the servo horn should point straight forward.

Twist the servo horn from right to left. The rotation range should be 0-225°.

Once you are sure that the servo horn is positioned properly over the steering servo axis, secure it into place by placing a screw in the center.

Grab one of the long U-type brackets.

Slip the hole of the U-type bracket over the bearing underneath the servo motor.

Slip the other end of the U-type bracket over the top of the servo motor. The big hole of the U-type bracket should be over the screw.

Grab a small screw.

Place the screw in one of the small holes of the long U-type bracket. Don’t tighten too hard at this stage.

Move the U-type bracket from left to right. Make sure it can touch each side of that third U-type robot waist bracket.

Now, remove the screw you just put in.

Install the Second Servo Motor

Grab a bearing, a long screw, and a nut.

Grab a Multi-functional servo bracket.

Secure the bearing on the Multi-functional servo bracket using the screw and the nut.

Grab four M3*6 screws.

Use the screws to secure the Multi-functional servo bracket on top of the long U-type servo bracket.

Grab another servo. This servo will be called the arm servo since it is responsible for raising and lowering the robotic arm.

Place it into the Multi-functional servo bracket.

Secure the servo into place with four fat screws (M3*8) and nuts. I recommend using needle-nose pliers to hold the nut steady while you use a Phillips screwdriver to tighten the screw.

Grab one of the plastic rocker arms. It should be inside the bag that had your servo motor.

Insert the rocker arm on top of the steering servo. The grooves of the steering servo should fit nicely with the grooves of the rocker arm. 

The rocker arm should be placed perpendicular across the steering servo axis (i.e. that golden, grooved metal circle on top of the steering servo).

Now take your finger and move the rocker arm to the left and to the right. 

Take note of where the rocker stops turning when you twist the rocker arm to the left side with your fingers.

Now take note of where the rocker arm stops turning on the right side.

Reposition the rocker arm so that it is perpendicular across the steering servo when the underlying steering servo axis is exactly at the halfway point between the left and right stopping points that you just marked.

After you have adjusted the angle of the steering servo axis using the rocker arm, grab the servo horn.

Carefully remove the rocker arm by pulling it straight up off the steering servo axis. You want to be careful not to move the steering servo axis.

Fit the servo horn on top of the steering servo axis so that it looks like this. One of the holes of the servo horn should point straight forward.

Twist the servo horn from right to left. The rotation range should be 0-225°.

Once you are sure that the servo horn is positioned properly over the steering servo axis, secure it into place by placing a screw in the center.

Grab one of the long U-type brackets.

Slip the hole of the U-type bracket over the bearing on one side of the Multi-functional bracket.

Slip the other end of the U-type bracket over the top of the servo motor. The big hole of the U-type bracket should be over the screw.

Grab four M3*6 screws.

Place the four screws over the small holes of the long U-type bracket.

Move the U-type bracket from left to right. Make sure it has a full range of motion. It should hit the first U-type bracket when you twist it to the right. That is fine.

Now, we are going to attach a long U-type servo bracket to the U-type bracket you just secured.

Grab a long U-type servo bracket and four M3*6 screws and nuts.

Your robotic arm should have a full range of motion, backward and forwards.

Install the Elbow

Now, we need to install the elbow.

Grab the L-type servo bracket, a Mult-functional servo bracket, a bearing, an M3*10 screw, and a nut.

Attach the bearing to the Multi-functional servo bracket using the M3*10 screw and nut.

Grab two M3*6 screws and nuts. If you’ve run out of M3*6 screws, just use screws and nuts in the kit that are able to fit through the holes. Sometimes the kits don’t have all the screws you need, and it doesn’t help that the kit that I received came with unlabeled screws.

Attach the L-type servo bracket to the Mult-functional servo bracket as shown in the image below. Use the two screws and nuts.

Grab the last long U-type bracket.

Use two M3*6 screws and nuts to secure the U-type bracket to the L-type bracket.

Grab a servo motor.

Place the servo motor into the Mult-functional servo bracket.

Secure the servo motor into the Multi-functional servo bracket with four M3*8 screws and nuts. Again, don’t worry if you don’t have enough M3*8 screws and nuts. The goal is to use screws and nuts to secure the servo motor into the holder.

Grab one of the plastic rocker arms. It should be inside the bag that had your servo motor.

Insert the rocker arm on top of the steering servo. The grooves of the steering servo should fit nicely with the grooves of the rocker arm. 

Now take note of where the rocker arm stops turning on the right side.

Reposition the rocker arm so that it is perpendicular across the steering servo when the underlying steering servo axis is exactly at the halfway point between the left and right stopping points that you just marked.

After you have adjusted the angle of the steering servo axis using the rocker arm, grab the servo horn.

Carefully remove the rocker arm by pulling it straight up off the steering servo axis. You want to be careful not to move the steering servo axis.

Fit the servo horn on top of the steering servo axis so that it looks like this. 

Twist the servo horn from right to left. The rotation range should be 0-225°.

Once you are sure that the servo horn is positioned properly over the steering servo axis, secure it into place by placing a screw in the center.

Place the Multi-functional servo bracket (with attached servo motor) inside the top U-bracket.

Secure it into place with four screws.

Install the Wrist

Grab two Multi-functional brackets.

Get a bearing, a screw, and a nut. Attach them to one of the Multi-functional brackets.

Grab two M3*6 screws and nuts. Use these screws and nuts to connect the Multi-functional brackets together.

Grab a servo motor, and place it into one of the Multi-functional brackets.

Grab four M3*8 screws and secure the servo motor into place.

Grab the arm rudder and place it over the servo axis.

As we have done with other servo motors, the arm rudder should be straight up and down at the halfway point of the motion of the servo (when you twist to the left and right).

Once you are happy with the angle, take the arm rudder off, and replace it with a servo horn.

Stick a screw in the middle of the servo horn to tighten it.

Place the Mult-functional bracket in the U-type bracket.

Use the servo horn screws to secure the servo horn into place.

Install the Hand Servo

Grab another servo motor.

Place the servo motor into the Multi-functional bracket up top.

Secure the servo motor into the Multi-functional bracket using four screws and nuts.

Add the arm rudder on top of the servo axis, and do the same routing we have done before to find the halfway point. You want the arm rudder to be up and down across the servo motor at the halfway point.

Attach the Claw

Grab a screw and place it in the center of the hand servo horn.

Grab two screws and secure the claw to the hand servo horn.

Grab the last servo and four M3*6 screws.

Attach the last servo to the claw using the screws. If you run out of screws, feel free to pull some screws from the base of the robot.

Grab the arm rudder and place it on top of the servo axis.

Find the halfway point of the servo axis. When you find the halfway point place the arm rudder on top of the axis so that it points straight up and down.

Carefully take the arm rudder off.

Push the servo horn over the servo axis.

Use a small screw to secure the servo horn on the servo axis. The screw that you should use is the one with something that looks like a disk or a washer around the neck near the head. Don’t tighten it too tight.

Arrange the claw in the open position.

Grab two small black screws. 

Secure the loose piece of the claw to the servo horn using the two black screws.

Check that you’re able to open and close the claw. The claw should close completely.

That’s it. If you’ve gotten this far, you have assembled the body of your robotic arm.

Move the Robotic Arm

Your robotic arm has six motors (six degrees of freedom). To move your robotic arm, you can buy a six-channel digital servo tester (you can find them on eBay or AliExpress) and move them like I explain on this post.

All you need to do is connect your digital servo tester to a power source (i.e. 6V…which can be a 4xAA battery pack), and also connect your servos to the tester. You’ll be up and running in just a few minutes.