Wall Mount Drawbot

I’ve been having a lot of fun with the baby drawbot. I will definitely make another of those in the future. As you can see from the images below, it’s able to do portraits on 8.5×11 paper.

But I’m ready to try a larger format. So I designed a wall mount drawbot. It’s made of hardboard and 1/4-20 rod. I wanted to use nylon bolts but I couldn’t find any long enough. Or I wasn’t sure what length I needed so I bought an aluminum threaded rod.

As you can see in the video, it’s easy to slice it down using a rotary cutter.

I will make this system so it can also mount on a board to make it more agile.

I’m also changing the gondola to have a “quick pen changer”.

Drawbot stabilization

I added the bolts to my gondola now that I’m starting to be able to draw images.

They were in the design from the beginning but I didn’t bother to tap the holes and add them till this afternoon.

I was enjoying the wildness of the gondola with it’s backlash and hysteresis.

If you have a look at the pictures you can see that the accuracy is vastly improved.

Baby Drawbot Lives!

Baby drawbot just completed it’s first real images.

I’m still working at the software side but at least I’m able to produce something aside from random scribble now.

The machine is running quite nicely even with the make-shift gondola I made from hardboard. I find that it works better with one of those fancy ball pens that have low friction. The marker type have enough friction to cause a bit of backlash. As you can see the darker drawing is more granular, that’s because of the backlash.

My next gondola will not have this problem as I think I know how to solve that.

If anybody wants this machine for practicing, let me know.

I used Sandy Noble’s software for this run. He has an awesome way of processing the image based on a dual polar system which matches with the actual degrees of freedom of the machine.

I will work more with his method and will try some other methods.

Drawbot progress

I’m back to working on my drawbots. I’ve been trying out some software by Sandy Noble which looks very promising.

I really like my baby drawbot because I can bring it where ever I want to work on it.

As I write this I am at the Ottawa Art Gallery running a drawing on it.

All the electrical fits into a small bag so this thing is really portable.

“Drawbot in a bag”.

I’m going to make an even smaller one so I can take it around on my motorcycle. It will have retractable arms and will work with a standard sheet of paper.

I’m also going to make some that let you mount each spool where ever you want. This will allow for some very large formats.

I’m also making a gondola that can carry many colors and also change colors on the fly. That will be a challenge but I think it will be rewarding.

Double BristleBot

I cooked up a double BristleBot. I figured if I put them in opposite directions it would spin around.

The kids were dipping them in paint and putting them on paper so I figured it would behave more like a Spirograph.

Turns out to work okay. I never tried it in paint but it seems there are lots of kids around so one will try sooner or later.

 

 

ModLab is the place to be

happy

Last nights modlab was a blast (ModLab is the open house of ArtEngine the Ottawa HackSpace).

A newcomer made his first solder connection!

Lots of microprocessor and Arduino activity. An LED game of life. A controller for an autonomous quadracopter (in progress), a musical hat and much more.

Also the new laser was sitting around. This will have a lot of positive impact on the space I’m sure. Currently a solution for air cleaning is being looked at.

I had my drawbots running. I found that it runs nicely on 9v or 6v for motor power. You get .7A and .5A respectively. Quieter on 6v. Also we ran the same drawing more than once and observed some reasonable repeatability.

We actually made a happy face with the drawbot. Mike cooked up a happy face and transferred the data into the drawbot.

I attended a brief aftersocial at a Scottish pub but kept it very short and light since I was pretty bushed.

Drawbot raster scan

drawbot

I spent some time on Baby Drawbot.

I was figuring it would be fun to estimate a Cartesian plane by having four stepper motor modes.

1) To move along the X axis in a positive, spool A out and B in.

2) To move along X in a negative direction, spool A in and B out.

3) To move positive in the Y axis, spool A and B in.

4) To move negative in the Y axis, spool A and B out.

This is a rough approximation and obviously it isn’t a perfect raster but has a zig zag in it. It also tapers toward the top.

I was able to get it to do a complete scan and then return to the start. Works pretty well. Eventually I’ll do the math and make the raster square if this proves to have too much distortion.

The code is below.

[sourcecode language=”cpp”]/* Darcy Whyte, DrawBot2 */

const int intDebug = 0;
// limit switch
//const int switchHome = 7; // home switch
const int ledHome = 13; // home LED

//Motors
const int motorAStep = 2;
const int motorADir = 3;
const int motorBStep = 4;
const int motorBDir = 5;

int i;
int j;
int switchHomeState = 0;
int homeA = 0;
int homeB = 0;
int switchHomeRequest = 0; //if set, we do the home operation

int x;
int y; //counter
int XPixels = 17; //pixel count (zero based)
int YPixels = 13; //
int XStepsPerPixel = 500;
int YStepsPerPixel = 500; // steps per pixel
int XVector; //direction of X axis alternates
int baseSpeed=300;

int imageDataRaw[] = {
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
};

int imageData[] = {
9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9
,9,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,9
,9,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,9
,9,0,0,0,0,9,9,9,9,9,9,9,9,0,0,0,0,9
,9,0,0,0,0,8,8,8,8,8,8,8,8,0,0,0,0,9
,9,0,0,0,0,7,7,7,7,7,7,7,7,0,0,0,0,9
,9,0,0,0,0,6,6,6,6,6,6,6,6,0,0,0,0,9
,9,0,0,0,0,5,5,5,5,5,5,5,5,0,0,0,0,9
,9,0,0,0,0,4,4,4,4,4,4,4,4,0,0,0,0,9
,9,0,0,0,0,3,3,3,3,3,3,3,3,0,0,0,0,9
,9,0,0,0,0,2,2,2,2,2,2,2,2,0,0,0,0,9
,9,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,9
,9,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,9
,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9
};

void setup() {
if (intDebug ==1 ) {Serial.begin(9600);}
pinMode(ledHome, OUTPUT);
//pinMode(switchHome, INPUT);
pinMode(motorAStep, OUTPUT);
pinMode(motorADir, OUTPUT);
pinMode(motorBStep, OUTPUT);
pinMode(motorBDir, OUTPUT);
XVector = 1;
}

/////////////////////////////////
// drawPixel
/////////////////////////////////
int drawPixel(int intPixelDarkness) {//int PixelSize, intPixelDarkness

for (int ii=1; i>=(YStepsPerPixel*intPixelDarkness/10); ii++) {
SignedStep(motorAStep, motorADir, -1, baseSpeed);
SignedStep(motorBStep, motorBDir, 1, baseSpeed);
}
for (int ii=1; i>=(YStepsPerPixel*intPixelDarkness/10); ii++) {
SignedStep(motorAStep, motorADir, 1, baseSpeed);
SignedStep(motorBStep, motorBDir, -1, baseSpeed);
}

}

/////////////////////////////////
// signed step
/////////////////////////////////
void SignedStep(int StepPin, int DirectionPin, int SignedSteps, int Speed) {
int stepCount;
if (SignedSteps <=0) {
digitalWrite(DirectionPin, LOW);
} else {
digitalWrite(DirectionPin, HIGH);
}
for (stepCount=1; stepCount <= abs(SignedSteps); stepCount++) {
digitalWrite(StepPin, HIGH); delayMicroseconds(Speed);
digitalWrite(StepPin, LOW); delayMicroseconds(Speed);
}
}

/////////////////////////////////
//
/////////////////////////////////
void loop(){
digitalWrite(ledHome, HIGH); //pause
delay(5000);
digitalWrite(ledHome, LOW);

for (y=0; y<=YPixels;y++) {
for (x=0; x<=XPixels;x++) { // an entire x row
for (i=1;i<=XStepsPerPixel;i++) {
SignedStep(motorAStep, motorADir, XVector, baseSpeed);
SignedStep(motorBStep, motorBDir, XVector, baseSpeed);
}
//Draw the pixel
//map(random(1,2), 1,2,0,9);
//drawPixel(5);
drawPixel(imageData[x+(y*XPixels+1)+1]);
}

//move up to next y row
for (i=1;i<=YStepsPerPixel;i++) {
SignedStep(motorAStep, motorADir, -1, baseSpeed);
SignedStep(motorBStep, motorBDir, 1, baseSpeed);
}
XVector = -1 *XVector;
//delay(200);
}

//return to (0,0)
for (y=1; y<=YPixels;y++) {
SignedStep(motorAStep, motorADir, 1*YStepsPerPixel, baseSpeed);
SignedStep(motorBStep, motorBDir, -1*YStepsPerPixel, baseSpeed);
}

//wait
while (1==1) {
digitalWrite(ledHome, HIGH);
delay(100);
digitalWrite(ledHome, LOW);
delay(100);
}

}

[/sourcecode]

Limit Switches for Drawbot

I was able to get this working roughly.

I made some beads put onto the strings. These beads will trigger my limit switches.

I then wrote a small program to go through the calibration process twice then move the system to (0,0 Cartesian).

It works pretty consistently. I know I’ll change it as the bot will probably finish at the top right. So I need to make sure it can do a zero operation from there and also from 0,0.

I suppose I could have a switch. If the switch is on, then the system will do a calibration run on boot-up.

The code is at the bottom.

/* Darcy Whyte, DrawBot2 */

// limit switch
const int switchHome = 7;     // home switch
const int ledHome =  8;      // home LED

//Motor S
const int motorAStep = 0;
const int motorADir = 1;
const int motorBStep = 2;
const int motorBDir = 3;

int i; int j;
int switchHomeState = 0;         
int homeA = 0;
int homeB = 0;

void setup() {
  pinMode(ledHome, OUTPUT);      
  pinMode(switchHome, INPUT);     
  pinMode(motorAStep, OUTPUT);
  pinMode(motorADir, OUTPUT);
  pinMode(motorBStep, OUTPUT);
  pinMode(motorBDir, OUTPUT);

  //////////////////////
  //seek home
  //////////////////////
  //switchHomeState == LOW; //don't start till switch
  //digitalWrite(ledHome, LOW);
  //while (switchHomeState == LOW) {
  //  switchHomeState = digitalRead(switchHome);
  //  if (switchHomeState == HIGH) {    
  //    digitalWrite(ledHome, HIGH);  
  //  }
  //}
  //while (switchHomeState == HIGH) {  //wait switch release
  //  switchHomeState = digitalRead(switchHome);
  //  if (switchHomeState == LOW) {    
  //    digitalWrite(ledHome, LOW);  
  //  }
  //}

  for (j=1; j

 

Baby Drawbot and Community Drawbot

Last night’s ModLab was a big success. Lots of people came out with projects and lots of people from the general public came by to check it out.

Maryam got the community drawbot going and I finished up my baby drawbot project.

Guy helped me with my infrared sensor for arduino. Also Micheal helped with some arduino connectivity and also with the Baby Drawbot

Community Drawbot

I got to Modlab a few hours early to work on projects.

I’ve got the drawbot ready. A new modlabber is going to give it a go.

I’ll work on my other drawbot and whatever else comes to mind.

drawbot! yippie!

Few more drawbot pictures from modlab

Here are a few more pictures from last night.

I took some closeups of the pictures we made with the drawbot.

It was a lot of fun. It’s time to make some more serious programs to control the drawbot.

Ideas are welcome! I have lots of ideas too!

Drawbot stress test

Drawbot

I did the wiring, glued the spools onto the motors using a glue gun (loctite didn’t work) and made a pen holder.

Even before running it with the pen I let it run for about 4 hours to see if everything was okay. I noticed right away that the motors were getting pretty warm at 13.5V. So I ripped the 9V off my cordless phone. Seems to run nice and quiet with that. After 4 hours, no overheating.

I added the pen holder and a ball point so it wouldn’t mark everything up.

It turns out the ballpoint works great. Obviously that’s an anomaly.

I’ve had it going with the pen for about an hour now. No missed steps.