Posted on

Building a Delta Robot: 3D model version 1


Now that I’ve defined what success should look like, I have to start putting the pieces together.  This started as a set of pen & paper drawings in my sketchbook.  Then I had a friend model the entire thing in Solidworks.  This model uses

  • Some sheet metal or wood for top & bottom plates (blue)
  • Some 3D printed brackets (green)
  • 24 3D printed ABS bearing mounts
  • 12 3/8″ OD bearings (between the bearing mounts)
  • Three pieces of 16mm hollow square aluminum bar (grey)
  • Three NEMA17 stepper motors
  • Six pieces of 4mm threaded rod
  • Six 1cm rods (attaches bearing mounts to square bar & bottom plate)

Before I could say this design is finished I still need to do a number of changes and tests, based on my previously stated goals:

  • The 1cm rods should be supported on bearings to make movement nice and smooth.
  • Bearings means a redesign of the square rod, the 1cm bar, and the bottom plate.
  • The legs that will hold up the delta robot haven’t been designed yet
  • Length of the 16mm square bar, length the 4mm threaded rod, and size of the plates will change once I calculate the correct numbers for the work area and accuracy that I want.  I just hope the motors I have will be up to the task!
  • Solidworks can simulate material stress and do other kinds of performance analysis.  I should be able to test how much weight the machine can carry before I start making anything, which will help me make sure my targets are being met.
Posted on

Kinect based art project

An 8 foot pole, atop which are 9 Kinect bars facing outward. Their cameras cover 360 degrees around the pole, and together they create a color 3d map of the entire surroundings. The user wears 3D goggles like Occulus Rift and can see themselves in the third person, look behind themselves without turning, peek around corners, and more. Imagine combining it with a UAV or a live satellite feed!

I could probably come up with a lot of BS about human interaction, the nature of technology in society, man’s relation to himself when reduced to an avatar, etc… but the truth is I think it’s just a really neat idea.

Posted on

Building a Delta Robot Part 1: Defining Success

What is a delta robot?

My goal is to make a delta robot that draws pictures.  Later I’d like to 3D print in ABS plastic.  So what am I looking to achieve?

  1. Repeatable accuracy: 0.25mm.  Say the robot is holding a pen pointing at a grid on a piece of paper.  It starts at (0,0,0), moves around, comes back and is within 0.25mm of (0,0,0).  It might be right on.  It might stop at (0,0.125,0).
  2. Envelope size: 15cm*15cm*15cm.  That’s the maximum range of motion for the tool the robot is holding.  So from (0,0,0) it can move from (-7.5,-7.5,0) to (7.5,7.5,15).  This is easy to test
  3. Weight limit: 50 grams.  Delta robots aren’t known for carrying a lot of weight, and all I’m moving is a pen.  I’ll probably have to use stronger stepper motors if I ever try 3D printing.
  4. Play/Slop: Does the tool undercut or overshoot the target line?
  5. Maximum velocity: 20cm/s?
  6. Maximum acceleration: 20cm/s/s?
  7. Automatic calibration: I want the robot to know where (0,0,0) the moment I turn it on.  No guess work.

I plan to test each of these conditions as follows:

  1. I’ll mount a 3D digital touch probe to the table and a metal cone to the tool tip.  After each movement the computer can record the amount of push on the probe.  After a few hundred samples a pretty clear picture should form.  The tests would then be repeated near the corners of the envelope.  To make life easier our math is going to try to do better than 0.25mm.
  2. Using the same cone, and a ruler taped to the table.  Test that the cone can travel from (0,0,0) to the desired distance on the rule.  Repeat in every direction.
  3. The metal cone should weigh 50 grams so that the previous tests are done at maximum load, when the machine is being strained to the limit.
  4. I’ll print a test pattern on a normal printer, tape it to the table, and then have the machine draw the same design and see if they match.  This will depend a lot on the physics of momentum.
  5. I’m not sure.  The cone could touch a switch at either end of the envelope a few dozen times and then I’d have a measure of top speed.
  6. See #5
  7. The same touch switches could be used to tell when the robot has re-centered itself.

In the next installment I’m going to cover the math and look at how it will help us design to spec build a computer model and then adjust it to fit the math.

Posted on

How I built a Line Following Arduino Robot

Sitting at a teacher conference one day, my booth partner asked me how long it would take me to build a line following arduino robot. I looked around at the parts we had on hand: an arduino UNO, a pile of 10k resistors and photovoltaic resistors, continuous servos, coffee cups, wire, tape, and a nine volt battery.

I said “an hour.”

He said “Prove it.”

Posted on

Hypocycloid reduction drives

I love the idea of hypocycloid reduction drives, or cycloidal reducers, because of they symmetry, their simplicity, and their promise of inexpensively using speed to get more power.

Some links I found about hypocycloids include http://www.thingiverse.com/thing:3617 and http://www.zincland.com/hypocycloid/

I’ve rediscovered – and written about – why cycloidal reducers aren’t commonly available.

Posted on

How to Control Arduino through the Serial Monitor

When I’m developing Arduino code, I often have variables that need to be tweaked during testing & calibration.
Rather than recompile and upload the code (a time consuming process) I wrote a few lines to let me open the Serial Monitor and send commands directly.

I hope you find this useful – I use it in all my robots!

#define DELAY   (5)
#define BAUD    (57600)
#define MAX_BUF (64)

char buffer[MAX_BUF];
int sofar;

char test_on=0;  // only used in processCommand as an example.
float pos_x;
float pos_y;
float pos_z;


void jog(float x, float y, float z) {
  // do some tests here to validate x, y, and z.
  pos_x=x;
  pos_y=y;
  pos_z=z;
}


void processCommand() {
  if(!strncmp(buffer,"help",4)) {
    Serial.println("commands: where; test (1/0); jog [x(float)] [y(float)] [z(float)];");
  } else if(!strncmp(buffer,"where",5)) {
    // no parameters
    Serial.print(pos_x);
    Serial.print(", ");
    Serial.print(pos_y);
    Serial.print(", ");
    Serial.println(pos_z);
  } else if(!strncmp(buffer,"test",4)) {
    // one whole number parameter
    char *state=strchr(buffer,' ')+1;
    Serial.println(state);
    if(state[0]=='0') {
      Serial.println("End test");
      test_on=0;
    } else {
      Serial.println("Start test");
      test_on=1;
    }
  } else if(!strncmp(buffer,"jog",3)) {
    // several optional float parameters.
    // then calls a method to do something with those parameters.
    float xx=pos_x;
    float yy=pos_y;
    float zz=pos_z;

    char *ptr=buffer;
    while(ptr && ptr < buffer+sofar) {
      ptr=strchr(ptr,' ')+1;
      switch(*ptr) {
      case 'x': case 'X': xx=atof(ptr+1);  Serial.print('x'); Serial.println(xx); break;
      case 'y': case 'Y': yy=atof(ptr+1);  Serial.print('y'); Serial.println(yy); break;
      case 'z': case 'Z': zz=atof(ptr+1);  Serial.print('z'); Serial.println(zz); break;
      default: ptr=0; break;
      }
    }
    
    jog(xx,yy,zz);
  }
}


void setup() {
  Serial.begin(BAUD);
  Serial.println("Init...");
  Serial.println("Stretching...");

  sofar=0;
  Serial.println(F("** AWAKE **"));
  Serial.print(F("\n> "));
}


void loop() {
  // listen for serial commands
  while(Serial.available() > 0) {
    char c = Serial.read();
    if(sofar < MAX_BUF-1)
      buffer[sofar++]=c;
    if(c=='\n') {
      // echo confirmation
      buffer[sofar]=0;
      Serial.println(buffer);

      // do something with the command
      processCommand();
      // reset the buffer
      sofar=0;
      // ready for more
      Serial.print(F("\n> "));
    }
  }
}

Edit 2016-07-11: closed a possible overflow in buffer[].