retrointerfacing

New A4 flat-kit design: a 18-servo 6-legged hexapod. It does not walk (yet) but servo control works and the mechanics look good:

All parts can be cut from a single A4 sheet of acrylic glass. Other parts include 18 miniature servo’s (selling for 5EUR as TopLine mini-servo ES-05 JR (at Conrad Electronic)) and an ottantotto board

The servo’s are controlled using a simple soft-servo library (for the timebeing) which can be found here.

As presented for the first time on FAB6, using a Sharp gp2y0a02 sensor the flatpack-walker just got a little bit smarter. As long as the distance sensor is triggered, the robot walks backwards.

The code is still pretty simple:

// avoid obstacles using Sharp G2P sensor on Analog 0
#include <Servo.h>
Servo frontservo,backservo;
char walkpattern[] = {60,100,100,100,100,60,60,60};
void setup(){
  frontservo.attach(9);
  backservo.attach(10);
}
void loop(){
  for(int n=0;n<4;n++){
    if(analogRead(0)>500){
      frontservo.write(walkpattern[2*n]);
      backservo.write(walkpattern[(2*n)+1]);
    }
    else{
      backservo.write(walkpattern[2*n]);
      frontservo.write(walkpattern[(2*n)+1]);
    }
    delay(200);
  }
}

Of course, the machine described in the previous post was never meant to have a sole purpose of pizza printing (which it admittedly does badly) but to become a repstrap machine so I can build a sweet Mendel. Next step after a cartesian robot is the plastic extruder. Although other people have tried to use a soldering iron (with limited success) we chose that approach nevertheless. Since isolated heating wire appears to be hard to come by (except for the makerbot store) and we had a spare soldering station lying around. Our first tests seem promising:

Critical issues are the steep thermal decline you need from the guiding tube to the heated nozzle. As soon as you drop pressure in putting the nylon through, the plastic pops out on top of the heated nozzle. Next up are a guiding tube from peak (or perhaps some ceramic material) and the steppermotor drive for automatic feeding.

BTW.. the reason we use nylon, is that you can buy it in a normal DIY hardware store. It is normally used for pulling wires trough tubes or unblocking drainage. ABS wire is still pretty expensive everywhere, especially for this kind of testing you’re not going to buy 3 kg…

Bringing personal fabrication to your kitchen: the pizza Plotter. During one of the last lectures I gave for Creative Technology about reprap’s and personal fabrication one of the pizza hungry students (Symplexity) pointed out the necessary connection between pizza and production. Thus the idea for a Pizza Printer was born.

The previous posts on the Repstrap describe a 3D carthesian robot made from dot Matrix printer parts (using ONLY parts from three StarLC10 printers). Instead of the Z-axis the nozzle of a pressure plant mister was put on the head. The tank has been filled with tomato sauce. See the results on youtube below:

OK. admittedly, the accuracy needs some work. This has more to do with pressure / extrusion control than with the 2D robot. (which is basically an ordinary ottantotto controlled plotter now). The original StarLC10 power supply has been used, along with part of the casing. A standard RC servo has been added to the plant mister nozzle, allowing for on-off control for move- and draw commands. The ottantotto controls three stepper motors directly (using four wires per motor). The original stepper driver chips (STA401A) have been salvaged and re-used. For all the motors a single STA401 has been used. The control signals of both parallel motors have been bridged.

A drawing is made using a very simple processing sketch, based on the ‘file-save’ examples.

/**
* sketchtool, based on the 'filesave' example.
* move mouse. Every time you click, a datapoint will be saved
*/
int[] x = new int[0];
int[] y = new int[0];
void setup()
{
size(512, 512);
frameRate(30);
}
void draw()
{
background(204);
stroke(0);
noFill();
beginShape();
for (int i = 0; i < x.length; i++) {
vertex(x[i], y[i]);
}
endShape();
// Show the next segment to be added
if (x.length >= 1) {
stroke(255);
line(mouseX, mouseY, x[x.length-1], y[x.length-1]);
}
}
void mousePressed() { // Click to add a line segment
x = append(x, mouseX);
y = append(y, mouseY);
}
void keyPressed() { // Press a key to save the data
String[] lines = new String[x.length];
for (int i = 0; i < x.length; i++) {
lines[i] = x[i]*4 + "t" + y[i]*4;
}
saveStrings("positions.txt", lines);
exit(); // Stop the program
}


Tomato Sauce and Pressure Vats are a match made in white-wall hell. At least until I fully understood the merits of hose-clamps. Luckily, if you are quick enough, the stains wash off well.

The printing program is equally simple (but will follow in a next post) The Ottantotto software has been made using winavr (since it involves timer interrupts, and I really love the AVRlib libraries from procryon)

Some time ago I tried rep-strapping using 5-1/4” diskdrive motors and MDF wood. (see here). The motors turned out to be way too weak, the M5 thread way to slow. Perhaps a larger thread (M12) and some bigger steppermotors can save this evening of work.

In this second attempt I have been using only the parts of three old dot-matrix printers (star LC10) and other computer parts. (I cheated a little bit. So far the extra parts include a big slab of MDF wood and two M8 bolts with washers and nuts)

So far I have build a 3D cartesian robot using the three printers. For the Z-axis I have added the mechanism of a CD-ROM player. Next part will be the motor control (also using the salvaged motor control hardware from the original printers) and an extrusion head (probably not completely from printer- or discarded computer-junk parts)