Published January 8, 2022 © CC0

Robot Arm Automation

This project has been developed for educational purposes and can be used in the field of robot development.

IntermediateFull instructions provided4,513

Things used in this project

Hardware components

Arduino UNO

HC-05 Bluetooth Module

Adafruit PCA9685 16-Channel Servo Driver

AT24C256 Serial EEPROM I2C Interface EEPROM Data Storage Module For Arduino

Arm Robot

You can find this robot for less than 50€ on Aliexpress

Software apps and online services

Arduino IDE

Hand tools and fabrication machines

10 Pc. Jumper Wire Kit, 5 cm Long

Breadboard, 170 Pin

Premium Female/Male Extension Jumper Wires, 40 x 6" (150mm)

Story

This project has been developed for educational purposes and can be used in the field of robot development.

Robotics is becoming accessible and easy to control. Nevertheless, it is necessary to pay particular attention to some technical aspects. Especially the handling of servo-motors.

The project uses components that are easily found on the market. Once the components assembled they will be coordinated by an Arduino program. This program will be the focus of the project.

The robot is an articulated arm that moves on three axes (moved by 6 servos). The arm will be programmed to record its positions. Once recorded, a sequence of positions can be automatically replayed and the arm animated.

The positions will remain stored when the power is cut.

All is controlled by a smartphone using a Bluetooth app.

This project focuses quality of assembly and programming (at least I tried 😉 ). It will develop points of vigilance to ensure optimal operation.

Library calls & Definitions

The program uses three files: a main program and two functions files. The use of functions avoids code repetition and makes reading easier.

Declaration of the LCD display.

If the display is not used, you can leave the declaration (possibly add the library to Arduino even if not used later). The variable " lcdpres " will be initialized to 0.

Declaration of the Eeprom memory.

The address on the I2C bus is 0x50. The table " eprdata " is used as a buffer for exchanges with the memory. It contains 6 bytes corresponding to the 6 servos and to a given position of the arm. The stroke of a servo going from 0 to 180 is stored in a byte. We will thus use 6 bytes per arm position. These 6 values will then be called sequences and will be read or write to the memory.

We use two pointers or sequence numbers. A pointer for the number of the current sequence and a pointer for the number of the last sequence recorded in the Eeprom memory.

The "eptactmax" array contains the values of these two pointers.

Bluetooth declaration.

The module is wired on pin 2 and 3 of the Arduino board. The variable " bluerec " contains the received information (alphabet character). In this project the Remote application will send only one character per action.

Declarations for the servo controller. This part deserves the most attention.

The address on the I2C bus is 0x40. The program uses the rotation angle (0 to 180) for positioning the servos. The rotation is carried out by the PWM controller which uses pulses whose width (500 to 2500µs) varies according to the angle. The communication with the controller is done by the " servowrite " function (will be developed later) which will carry out beforehand an angle-pulse conversion. The MAX and MIN variables are used for this conversion. Depending on the servo model these values can change. In our case the MG996 servos have a rotation angle covering 180°. The replacement servos DS3225 have an angle of 270°. We will keep the 180° rotation because a 270° rotation is not mechanically possible for this arm.

In the assembly some servos cannot rotate over the whole 180° range. They will be mechanically blocked by the supports and will start to heat up. It is therefore necessary to protect them by limiting their stroke. The "tabanglim" table contains the limit values for rotation of each servo (min and max).

The "homepos" table contains the position of the arm at power-up. It is recommended to bring the arm back to this position before switching off. The arm will then already be in position when you restart the program. If the arm is in another position, an abrupt movement will take place on power on. It is advisable to be careful when switching on.

All these values are to be updated if you realize this project!

Structure of the information stored at the beginning of the Eeprom memory: AMHHHHHH1111222222223333334444

Each character represents a byte of memory. "A" is the value of the current sequence pointer (1 to n). "M" is the value of the last recorded sequence (4 in this case). "111111..444444" are the servo positions for the sequence 1...4. "HHHHHH" is sequence 0 and corresponds to the initial position of the arm.

On power-up "HHHHHH" is regraved into the eeprom from the "homepos" table; "A" and "M" are read from the eeprom and stored in the "expactmax" table.

Setup - peripherals initialization

1 / 2

The following functions are used: "lcdw", "readeeprom(x, y)", "writeeeprom(x, y)" and "servomove(a, b)".

"x" represents the address of the starting byte to be read, "y" represents the number of bytes to be read or written, "a" the number of the sequence on the Eeprom, "b" will be explained later.

For easy programming HHHHHH is read back into the eeprom from the "homepos" array; A and M are read from the eeprom and stored in the "expactmax" array. The arm is positioned in its starting position. Here "A" represents the sequence 0 and points toHHHHHH.

Main - several nested loops

The main loop concerns the reception of a character from the Bluetooth. Depending on the character received, an action is performed.

From " A " to " L " we move manually a servo with a left or right rotation (function " servowrite "). We jump now to the "while" loop. The servo rotates until the character " S " is received. "S" is sent when the button on the smartphone is released. Her we control also the servo's course to prevent it from bumping into the support.

Receiving the characters "M" to "9" leads to special operations.

· "M" and "N" act on the sequence pointer by increments or decrements of 1.

· "Y " displays the angle of the 6 servos and the value of the two sequence pointers.

· "Z" moves the arm from its current position to the initial position.

· "1 " to " 4 " move the arm from its current position to the position corresponding to sequences 1 to 4.

· "8 " moves the arm from its current position to the position corresponding to the selected sequence (sequence selected by " M " and " N ").

· "7 " displays the first 100 bytes of the Eeprom on the serial port.

· "9 " records the current position of the arm (sequence selected by " M "and " N ").

· "6 " starts a succession of movements defined in the " prog " table (" scenario " function) and corresponds to playing a scenario.

// Other variables =====================

int prog[2][10] = {{2, 5, 6, 3, 7, 8, 4, 9, 11, 0}, {0, 1, 0, 0, 1, 0, 0, 1, 0, 0}}; // video scenario

In the above example the arm will move successively to the positions indicated by the sequences 2, 5, 6, 3 etc.

Important note :

Before the execution of the sequence the arm will perform an upward movement. This movement can be inhibited. This is the case in the example for sequences 5, 7 and 9 (for this purpose the second part of the "prog" table is used). Sequences 5, 7 and 9 correspond to the closing of the gripper to grasp an object. The arm must remain in place for these operations.

Moving the arm to a destination position

(For a better readability download the.ino program)

The principle of the move is based on the simultaneous (seemingly) rotation of the servos. It would have been simpler to rotate one servo after an other toits destination position. The visual effect is then not smooth and the movement jerky.

The program is therefore a bit more complex. We operate in batches of servos. Each servo is rotated step by step in turn.

1. The servos are numbered from 0 (base) to 5 (clamp). The rotation is done in the following order:

2. The batch consisting of servos 1, 2 is moved upwards independently of the sequence.

3. The batch composed of servos 0, 3, 4 is moved according to the sequence values.

4. The batch composed of servos 1, 2 is moved according to the sequence values.

5. The batch 5 (the clamp) is moved according to the sequence values.

Android application

To control the arm we use a smartphone or a tablet with the "Bluetooth Remote" app. This free app is easy to configure. The app is based on the creation of programmable buttons. For each button we define a sequence of characters to send via Bluetooth. The Arduino equipped with the HC05 module will receive the information and transform them into actions.

The modifications of the panel are done by entering the update mode (1). Each button can be modified in size, position and orientation (2). By clicking on a button we can update the button data (3) or add a new button (4).

Note: The two rows of buttons on the left use the value "S" in the "On Press Up" area. When the button is released "S" is sent to the Arduino (used in CASE "A" to "L" of the program).

Conclusion

Among the files to download is a version using the control of servos by the Arduino board directly (using ports 4 to 9) without the PCA9685 controller. The assembly is more complex because the wiring is important.

This project was developed for educational purposes and can be used as a basis in robots developping. You can now give free rein to your imagination for the modelisation of your robots. Enjoy it !

Code

// Main programm - Robot controler
// LCD ================================= 
#include <LiquidCrystal_PCF8574.h>
#include <Wire.h>
LiquidCrystal_PCF8574 lcd(0x38); // I2C
int lcdpres = 0;                                // to put to 0 if LCD not present
// EEPROM ==============================
#define EEPROM_I2C_ADDRESS 0x50  // I2C
int eprdata[6];                  // data read from eeprom
int epractmax[2];                // cursor position to/from eeprom
// BLUETOOTH ===========================
#include  "SoftwareSerial.h"
SoftwareSerial bluetooth(2, 3);  // RX, TX
int bluerec ;                    // bluetooth reception variable
// SERVOS =======================================================
#include <Adafruit_PWMServoDriver.h>
Adafruit_PWMServoDriver pca= Adafruit_PWMServoDriver(0x40);  // I2C
#define nbPCAServo 6
int MIN_IMP [nbPCAServo] ={500, 500, 500, 500, 500, 500};
int MAX_IMP [nbPCAServo] ={2500, 2500, 2500, 2500, 2500, 2500};
int MIN_ANG [nbPCAServo] ={0, 0, 0, 0, 0, 0} ;
int MAX_ANG [nbPCAServo] ={180,180, 180, 180, 180, 180 };               // servo angle capability
int tabanglim[2][6] = {{0,43,65,0,10,80}, {180,177,180,140,175,116}};   // Limits the servo stroke.
int servodelay(15);              // delay for servo to achieve rotation
int servo;                       // current servo number (from 0 to 5)
int homepos[6] = {93, 124, 115, 118, 83, 80};   // robot home position (will be stored to eeprom on setup
int tabserpos[6] = {90,90,90,90,90,90};  // to store current servo position/angle
String rot;                              // current direction of rotation (L or R)
// Other variables =====================
int prog[2][10] = {{2,5,6,3,7,8,4,9,11,0}, {0,1,0,0,1,0,0,1,0,0}};  // little scenario as an example 

//
// == SETUP ============================================================
void setup() {
// SERIAL init =========================
Serial.begin(9600);
delay(500);
// LCD init ============================ 
Wire.begin();
Wire.beginTransmission(0x38); 
if (lcdpres == 1) {lcd.begin(16, 2); lcdw(0,0,0," "); lcdw(1,0,0," READY TO WORK"); }
// BLUETOOTH init ====================== 
bluetooth.begin(9600);
// SERVOINIT =================================
pca.begin();
pca.setPWMFreq(60);  // Analog servos run at ~60 Hz updates
delay(500);
// EEPROM init =======================
// EEPROM structure : two first bytes contains the current pointer and the max of records
// the a multiple of 6 bytes represending robot positions, one record represents 6 bytes, each for one servo
readeeprom(0,2); epractmax[0] = eprdata[0]; epractmax[1] = eprdata[1]; // pos 0,1 of eeprom indexes
delay(100);
writeeeprom(2,homepos,6); // write robot home position
delay(100);
servomove(0,0); // move robot to home position 
// end EEPROM init
Serial.println(" READY TO WORK");
}
// == LOOP ==============================================================
void loop() {
delay(100);
if (bluetooth.available()) { // Si donne Bluetooth reue...
    bluerec = bluetooth.read();
    switch(bluerec)
      { 
      case 'A': servo = 0;  rot = 'L';  break;
      case 'B': servo = 0;  rot = 'R';  break;
      case 'C': servo = 1;  rot = 'L';  break;
      case 'D': servo = 1;  rot = 'R';  break;
      case 'E': servo = 2;  rot = 'L';  break;
      case 'F': servo = 2;  rot = 'R';  break;
      case 'G': servo = 3;  rot = 'L';  break;
      case 'H': servo = 3;  rot = 'R';  break;
      case 'I': servo = 4;  rot = 'L';  break;
      case 'J': servo = 4;  rot = 'R';  break;
      case 'K': servo = 5;  rot = 'L';  break;
      case 'L': servo = 5;  rot = 'R';  break;
      case 'M': if (epractmax[0] <= (epractmax[1])) {epractmax[0] = epractmax[0] + 1; listpos(); } rot = ' '; break;  // increase eeprom index
      case 'N': if (epractmax[0] > 0)               {epractmax[0] = epractmax[0] - 1; listpos(); } rot = ' '; break;  // decrease eeprom index       
      case 'Y': listpos(); rot = ' '; break;                                          // display robot position
      case 'Z': servomove(0,0); rot = ' '; break;                                     // move robot to home position 
      case '1': servomove(1,0); rot = ' '; break;                                     // move robot to indicated position
      case '2': servomove(2,0); rot = ' '; break;                                     // move robot to indicated position
      case '3': servomove(3,0); rot = ' '; break;                                     // move robot to indicated position
      case '4': servomove(4,0); rot = ' '; break;                                     // move robot to indicated position
      case '6': scenario() ;rot = ' '; break;                                         // move robot to indicated position
      case '7': eeprom_read_test(); rot = ' '; break;                                 // display eeprom content
      case '8': servomove(epractmax[0],0); rot = ' '; break;                          // move robot to home position 
      case '9': writeprom(epractmax[0]); rot = ' '; break;                            // write robot position to eeprom
      default:  rot = ' ';    break; 
      } // end switch(bluerec)
      while((bluerec != 'S') && (rot != " "))
         { 
         if ((rot == "L") && (tabserpos[servo] > tabanglim[0][servo]))   { tabserpos[servo] = tabserpos[servo] - 1; } // decrease servo position and verify servo stroke
         if ((rot == "R") && (tabserpos[servo] < tabanglim[1][servo]))   { tabserpos[servo] = tabserpos[servo] + 1; } // increase servo position and verify servo stroke 
         servowrite(servo, tabserpos[servo]); 
         delay(100);  // to allow slow motion
         bluerec = bluetooth.read(); 
         } // end while(bluerec != 'S')
} // end if (bluetooth.available()
} // end loop

// function for LCD control ============================================
void lcdw (int lcdf, int lcdl, int lcdc, String lcdt) { 

// Setting of the function ====================
//     lcdf : 0=init LCD for void setup/1=write txt/2=clear display,
//     lcdl : for lcdf=1 display line number 0-1,
//     lcdc : for lcdf=1 display column number 0-15,
//     lcdt : for lcdf=1 string to diplay,
// End setting of the function ================

// Function start =============================
//  const static String lcds1 ="                ";
  switch (lcdf) {
    case 0: 
      lcd.setBacklight(255);
      lcd.home();
      lcd.clear();      
      delay(100);                      
    break;
    case 1: 
      lcd.setBacklight(255);         
      lcd.setCursor(lcdc, lcdl);                                 // set start for write
      lcd.print(lcdt);                                           // write info
    break;
    case 2: 
        lcd.clear();                                   // clear LCD
    break;    
    }  
/*  Other LCD functions which can be included in this function to improve it
    lcd.clear(); lcd.print("Cursor Blink"); lcd.noBlink(); lcd.blink(); lcd.noCursor(); lcd.noDisplay(); lcd.display(); lcd.setCursor(0-15, 0-1); 
    lcd.scrollDisplayLeft(); lcd.scrollDisplayRight(); lcd.setBacklight(0-255);  */
}
// =================================== write robot postion to eeprom
void writeprom(int writeprom1){
  int writeprom3[6];
  writeprom3[0] = tabserpos[0]; writeprom3[1] = tabserpos[1]; writeprom3[2] = tabserpos[2]; 
  writeprom3[3] = tabserpos[3]; writeprom3[4] = tabserpos[4]; writeprom3[5] = tabserpos[5]; 
  writeeeprom((writeprom1*6 + 2),writeprom3,6) ; // writes robot position to eeprom
  if (epractmax[0] > epractmax[1]) { epractmax[1] = epractmax[0]; }
  writeeeprom(0,epractmax,2); // writes eeprom pointers to eeprom
  if (lcdpres == 1) {
    lcdw(2,0,0,""); lcdw(1,0,0,"Write OK");   lcdw(1,1,0,String (epractmax[0]) + "-" + String (epractmax[1]));
    }
  Serial.println("Write OK  ");
  listpos();
}
// =================================== eeprom write function
void writeeeprom(int data_addr, int stotab[], int len)
{
  Wire.beginTransmission(EEPROM_I2C_ADDRESS);
  Wire.write((int)(data_addr >>8));
  Wire.write((int)(data_addr & 0xFF));
  for (int i=0;i!=len; i++) {  Wire.write(stotab[i]);} // writes "len number" memory cells 
  Wire.endTransmission();
  delay(5);
}
// =================================== eeprom read function
byte readeeprom(int data_addr, int len)
{
  int i=0;
  Wire.beginTransmission(EEPROM_I2C_ADDRESS);
  Wire.write((int)(data_addr >>8));
  Wire.write((int)(data_addr & 0xFF));
  Wire.endTransmission();
  Wire.requestFrom(EEPROM_I2C_ADDRESS, len); // request to return "len" memory cells 
  delay(10);
  while (Wire.available()){ eprdata[i] = Wire.read(); i=i+1; }
}
// =================================== eeprom read and disply on computer
void eeprom_read_test() 
{
  String str;
 int j, k=0 ,l=0;
 for(int i=2;i<100;i++)
    {
    j = (i-2)/6 ;
    if (k != j) { k = j; l = 0;}
    readeeprom(i,1);  delay(10) ; l = l+1;
    str = "Position - Servo : " + String((i-2)/6) + " - " + String(l) + " value : " + String(eprdata[0]); Serial.println(str) ;
    }
    Serial.println("End list");
}
// =================================== Init 30 firts eeprom cells to 0
void reinitI2CByte() 
{
  int data_addr = 0;
  Wire.beginTransmission(EEPROM_I2C_ADDRESS);
  Wire.write((int)(data_addr >>8));
  Wire.write((int)(data_addr & 0xFF));
  for (int i=0;i < 30; i++) {  Wire.write(0);} // writes 0 to cells
  Wire.endTransmission();
  delay(5);
}

// =================================== move robot to position
void servomove(int li,int sk){ // move the robot in the target position. 
// Setting of the function ====================
//     li : number of stored sequence of robot (example: sequence = 3 will point to address li*6+2 of eeprom)
//     sk : if sk = 0 the arm rise before the programmed move
// End setting of the function ================  
delay(200);  // to be sure last move finished
int bb = 75,cc = 110;
int ind0=1, ind1=1, ind2, ind3, ind4, ind5 ;
if (sk == 1) {ind1 = 0; ind2 = 0;}
while (ind1+ind2 >0)
  {
  if (tabserpos[1] != bb) { ind1 = 1;
    if (tabserpos[1] < bb) { tabserpos[1] = tabserpos[1]+1; } if (tabserpos[1] > bb) { tabserpos[1] = tabserpos[1]-1;  } servowrite(1, tabserpos[1]); }
    else { ind1 = 0 ;} 
  if (tabserpos[2] != cc) { ind2 = 1; 
    if (tabserpos[2] < cc) { tabserpos[2] = tabserpos[2]+1; } if (tabserpos[2] > cc) { tabserpos[2] = tabserpos[2]-1;  } servowrite(2, tabserpos[2]); }
    else { ind2 = 0 ;} 
  } // end while (ind1+ind2 >0)

if (li > epractmax[1]) { li = epractmax[1] ; } 
readeeprom((li*6 + 2),6) ; // in return the eprdata table contains the target positions of the servos
ind0 = 1;
while (ind0+ind3+ind4+ind5 >0)
  {
  if (tabserpos[0] != eprdata[0]) { ind0 = 1; 
    if (tabserpos[0] < eprdata[0]) { tabserpos[0] = tabserpos[0]+1;  } if (tabserpos[0] > eprdata[0]) { tabserpos[0] = tabserpos[0]-1; } servowrite(0, tabserpos[0]) ; } 
    else { ind0 = 0 ;}
  if (tabserpos[3] != eprdata[3]) { ind3 = 1; 
    if (tabserpos[3] > eprdata[3]) { tabserpos[3] = tabserpos[3]-1;  } if (tabserpos[3] < eprdata[3]) { tabserpos[3] = tabserpos[3]+1; } servowrite(3, tabserpos[3]) ; } 
    else { ind3 = 0 ;} 
  if (tabserpos[4] != eprdata[4]) { ind4 = 1;  
    if (tabserpos[4] < eprdata[4]) { tabserpos[4] = tabserpos[4]+1;  } if (tabserpos[4] > eprdata[4]) { tabserpos[4] = tabserpos[4]-1; } servowrite(4, tabserpos[4]) ; } 
    else { ind4 = 0 ;}
  }
ind1 = 1;
while (ind1+ind2 >0)
  {
  if (tabserpos[1] != eprdata[1]) { ind1 = 1; 
    if (tabserpos[1] < eprdata[1]) { tabserpos[1] = tabserpos[1]+1;  } if (tabserpos[1] > eprdata[1]) { tabserpos[1] = tabserpos[1]-1; } servowrite(1, tabserpos[1]) ; } 
    else { ind1 = 0 ;} 
  if (tabserpos[2] != eprdata[2]) { ind2 = 1; 
    if (tabserpos[2] < eprdata[2]) { tabserpos[2] = tabserpos[2]+1;  } if (tabserpos[2] > eprdata[2]) { tabserpos[2] = tabserpos[2]-1; } servowrite(2, tabserpos[2]) ; } 
    else { ind2 = 0 ;} 
  }
ind5 = 1;
while (ind5 >0)
  {
  if (tabserpos[5] != eprdata[5]) { ind5 = 1; 
    if (tabserpos[5] < eprdata[5]) { tabserpos[5] = tabserpos[5]+1;  } if (tabserpos[5] > eprdata[5]) { tabserpos[5] = tabserpos[5]-1; } servowrite(5, tabserpos[5]) ; } 
    else { ind5 = 0 ;} 
  }
listpos();     
}
// ==================================
void servowrite(int sernum, int angl)  // move servo to new position
{
 int imp = map(angl, MIN_ANG[sernum], MAX_ANG[sernum], MIN_IMP[sernum], MAX_IMP[sernum]); // convert angle to impulse
 pca.writeMicroseconds(sernum,imp); 
 delay(servodelay);
 tabserpos[sernum] = angl;
}
// =================================== list the position of the servos
void listpos(){
 
String  aff = String(tabserpos[0]) + " " + String(tabserpos[1]) + " " + String(tabserpos[2]) + " " + String(tabserpos[3]);
String aff1 = String(tabserpos[4]) + " " + String(tabserpos[5]) + " > " + String (epractmax[0]) + "-" + String (epractmax[1]);
if (lcdpres == 1) {lcdw(2,0,0,""); lcdw(1,0,0,aff); lcdw(1,1,0,aff1); }
Serial.println(aff + " " + aff1);
}
void scenario ()
{
  for (int i=0;i<10;i++) {servomove(prog[0][i],prog[1][i]); }
}

Credits

danielgass

0 projects • 1 follower

Robot Arm Automation

Things used in this project

Hardware components

Software apps and online services

Hand tools and fabrication machines

Story

Library calls & Definitions

Setup - peripherals initialization

Main - several nested loops

Moving the arm to a destination position

Android application

Conclusion

Schematics

Wiring diagram

Components

Code

Robot-bluetooth-prog-pca

LCD-EEPROM-functions

SERVO-functions

Credits

danielgass

Comments

Embed the widget on your own site

Robot Arm Automation

Robot Arm Automation

Things used in this project

Hardware components

Software apps and online services

Hand tools and fabrication machines

Story

Library calls & Definitions

Setup - peripherals initialization

Main - several nested loops

Moving the arm to a destination position

Android application

Conclusion

Schematics

Wiring diagram

Components

Code

Robot-bluetooth-prog-pca

LCD-EEPROM-functions

SERVO-functions

Credits

danielgass

Comments

Related channels and tags