A drawing machine

I have a couple of ideas in mind that involve a drawing machine, so I wanted create one as a final project for our physical computing class. In post I’ll explain the technical side of the project. I’ll talk about my motivation for building such a thing in a later post.

We just had a few days of time for completing this project, so I did my best of resisting the temptation to invent everything from scratch. I decided to base myself on the ‘hanging drawbot’ design, which to my knowledge was first done by Jürg Lehni with Hektor ten years ago.

The basic idea is this: motors are used to control the position of a pen that is connected to the motors via threads. By using the Pythagorean theorem you can find out what the position of the pen is, and this information can be used to control the length of the threads.

There have been countless variations on this theme in the meantime. I mostly used the work of Dan Royer and his DrawBot. I choose this project because it’s open source, simple and well-documented. I’ve used his project to show me the way, but along the way I’ve had some troubles and I’ve made a few changes. I’m documenting them here.

Bill of materials

I almost couldn’t start this project because I couldn’t get some materials in time. Then I found out about Barcelona Cybernetics, where you can order Arduino’s and related components online and pick them up the same day. Here’s what I bought from them:

• 1 x ADA-081 Adafruit Motor/Stepper/Servo Shield para Arduino kit – v1.0, €24.81
• 2 x ADA-324 Stepper motor – 200 steps/rev, 12V 350mA, €32.10 for 2
• 1 x A-0072 Arduino ETH Shield Rev3 SIN PoE, €35.10

Then I went to Onda Radio where I go a couple of smaller standard items:

• A power supply (12v, 4.7 amps, around 20 euro)
• Cabe for power supply (2.80 euro)
• Wire, in 4 colours: red, yellow, green, grey, the same colors as the ones on the motors. (2 euro per color) The wires on my motors were pretty short.
• Some screw terminals for extending the wires of the motors.

And this is what I picked up in a basic crafts shop:

• A Staedtler marker.
• A bulldog clip. (Used to give the pen holder some weight, could be something else.)
• Fishing line.

And this I had already:

• An Arduino Uno
• Scrap pieces of plywood and acrylic.
• A big wooden board to mount everything on.
• Some M3 screws in various sizes.

h2. The motorshield

I checked out various ways to control the stepper motors. The easiest seem to be EasyDriver and Adafruit’s shield. I went for the shield, since it’s only slightly more expensive but you can control 2 motors with it.

You need to assemble it. I didn’t have much soldering experience, but it was pretty easy using the instructions. It took me around an hour.

The motors

Dan sells his DrawBot in kit form, and this comes with motors that can do 400 steps per rotation (see https://www.sparkfun.com/products/10846, more or less same price). This type of motors are used by CNC machines, so there pretty accurate. I’m using the steppers sold by Adafruit, which can only do 200 steps per rev. That means there’s only half as precise. In pratice, the results I get don’t seem that bad, but I’m curious what the difference is.

The wiring for the motors is explained on Adafruit’s product page:

After this I downloaded the library for the shield and I ran the examples. Everything seemd to work fine.

The wires on the motors were short (around 20 cm) so I extended them by connecting them to 1m wires I cut and tinned. I used screw terminals because I wasn’t sure if I was going to keep the motors in this setup. It was a good idea to spend a few euros on getting wires in the same color. This made this job much easier.

The motors need 12V and 350mA each. I got a 12V/4amp power supply in the form of those metal boxes. You need to buy a power cord seperately for these things.

Motor mounts

You’ll some way to hang the motors on a wall or a board. Dan’s 3D-printable design for the mounts is nice: it functions as an L bracket, and it has holes for the thread. I adapted it for laser cutting by tracing it in Rhino and adding some notches so the parts could be glued.

Here is what I sent to the laser cutter:

I used 3 mm acrylic. Here is the mount after glueing:

I forked Dan’s project on GitHub and added the files in AI, PDF and Rhino format.

Spools

I really like this bobbin design from Stuart Childs. It can be laser cut, and it has a hole for a screw that can be used to tigthen the spool to the motor.

Stuart’s bobbins are too big for the motor mounts I used, so I made a variation on it:

I cut this on 3mm plywood. I’m using fishing line for the thread, and I connected it a screw after to the second disc. This is how the whole thing looks when it’s assembled:

The “files for lasercutting can be found on GitHub.

Pen holder

I reused the same idea of the tightening screw for the pen holder. This is the file that was sent to the laser cutter:

This was cut on 3mm acrylic. Here is the finished piece:

The hole in middle is big enough for the tip of a Staedtler marker. I had to add a bulldog clip on the top to add some extra weight so the pen holder would be close enough to the board.

Firmware

I loaded Dan’s DrawBot firmware into my Arduino. There’s a couple of very important changes I made:

• Bobbin size was set to 3mm.
• And, most importantly: the maximum speed of the motors was decreased from 2000 RPM to 250 RPM. It took me a while to understand that this was necessary. With the 2000 RPM setting, the motors couldn’t keep up. They went a little forward, and then back again.

See the changeset on Github for the exact code.

Drawing

Dan’s DrawBot project includes a handy interface for controlling the drawing machine and sending images to it.

This is how mine has to be configured:

Here’s how the first test looked like:

This is a program to determine the speed of the motor, using the photosensor:


const int transistorPin = 9; // connected to the base of the transistor

}


This is basically the StateChangeDetection example that comes with Arduino.

Here are some numbers. I’m still using 5V, and I’m getting top speeds around 1.800 rounds per minute, or 30 per second (= 1.800/60). That means one rotation takes around 32-33 ms (= 1/30 * 1.000).

I counted how many times the Arduino goes through the loop() function during each rotation: I get values around 125. And here I have a problem. Each time my code in loop() gets executed, I can draw 1 “pixel”. If the Arduino can only do the loop() 125 times then I can only draw 125 “pixels”, which is not enough to draw something interesting. I probably don’t need 1.800 rpm, but even at half that speed I would only get 250 pixels.

So the chip needs around 0.264 ms (= 125 executions per rotation / 33 ms per rotation) to execute my code in loop(). I confirmed this with this piece of code:


timeSpentInFrame = micros() - now;
Serial.println("timeSpentInFrame");
Serial.println(timeSpentInFrame);
now = micros();


Then I created a minimal Arduino program to see how much time it would to loop():


unsigned long timeSpentInLoop;
unsigned long now;

void setup(){
Serial.begin(115200);
}
void loop(){
timeSpentInLoop = micros() - now;
Serial.println("timeSpentInLoop");
Serial.println(timeSpentInLoop);
now = micros();
}


Here, is some sample output:


timeSpentInLoop
8
timeSpentInLoop
8
timeSpentInLoop
4
timeSpentInLoop
8
timeSpentInLoop
8


This is in microseconds. The number is not stable and varies between 4 and 16. Let’s say 0.008 is the average, then is this around 30 times faster than my code. I think I have some optimizing to do.

I asked Alex and in the Arduino forums there’s a way to make analogRead() to its thing a bit faster by trading a bit of resolution for speed. I tried it out, and it was indeed faster. The Arduino needed only around 65 microseconds to through loop() instead of 264.

At a speed of 1.600 rpm this gives me 526 pixels to work with. After slowing down to 1.500 rpm, the Arduino managed to 642 loop() iterations per rotation. That still wasn’t much, and looked like interrupts might the solution. I was a bit afraid of going into that topic, because it seemed to bring me a step closer to the hardware, with the danger of loosing lots of time in uncharted territory. However, because timing is crucial for this project I decided to check it out.

Turns out that there’s two types of interrupts. One is for timers (feels a bit similar to threads), and that’s the hard one. The other types of interrupts are a bit similar to events, for example a JavaScript click event: you define a callback that get executed when a pin detects a change in value. This run directly on the hardware, outside of the loop, so its very fast. More details about interrupts can be found in the documentation.

Here is the new version of the code:


const int transistorPin = 9; // connected to the base of the transistor

void photoSensorActivated(){
rotations ++;
}


I only fully understood the implication of what I just did by looking at the sourcecode from a similar project. (Michiel, I don’t know your lastname so I can’t credit you properly, but thanks for posting your code.) Because the main loop() function was now free from it’s job of checking the photosensor, I could now use delay() again. I was supposing that I could only draw one pixel per execution of loop() – and that was true in the version without an interrupt. Now however, I could draw all pixels in one loop().

I made a quick test and was able to draw a fine pattern of pixels. The image was very unsteady, so I realized I couldn’t depend on the motor to maintain a constant speed. The Arduino forum had a simple algoritm to keep the speed constant:


if (rpm setRpm) {
motorValue -= 1;
}
motorValue = constrain(motorValue, 0, 255);
analogWrite(transistorPin, motorValue);


Far from perfect, but good enough to continue testing.

For the motor (12V, round type), I used a lamp holder. The motor didn’t fit in perfectly, so I added some paper. Not sure if this is bad for ventilation, but the motor doesn’t get noticeably hot. I screwed the holder onto a block of plywood I found.

Since I wasn’t sure if this would be the final circuit, I left everything on breadboard. I used two: one for the photo sensor related things, and another for the all the rest (motor control, pot and laser). I taped the boards and the wire on the wooden block, and screwed the Arduino to it as well. This made it easy to cary everything around.

The motor I used already had a gear connected to it. I glued a slim piece of leftover acrylic onto it. Next, I glued a wooden hexagonal prism on it. For the mirrors, I used a cheap handheld mirror. I tried different ways of cutting this, but none of them working without breaking the mirror. In most similar projects people just snapped the mirrors into pieces. I also found a project where the mirrors from a disco ball were used. Someone also suggested using mirrored plexiglass and lasercutting that.

I connected the laser and pointed it on the mirrors. I added some tape on the wall, added the first mirror and made a mark on the tape to indicate the position of the laser. This had to be repeated from each mirror, giving each of them a slightly different inclination, with the marks on the wall as a reference. I glue to keep the mirrors in place. Here is how that looks like:

This took a long while, and because I didn’t wait long enough for the glue to dry, the mirrors shifted out of place a bit. The result is that some lines are too close together:

Later on I found a really nice description on how to make such a mirror array. Hot glue seems to be very useful here, since you can heat it up again and correct the alignment of a mirror.

I added a small plastic stick on the platform with the mirrors. The photosensor was mounted under it and sends back lower values when the stick is on top of it.

I was a little disappointed with the brightness. It needs to be pretty dark for the lines to be visible.

I just had to add the phototransistor by following a tutorial. A quick test showed it works really well. I connected a cardboard disc to the motor, taped a few coins on the bottom side in one place, and put the sensor under the disc. There is a very large difference in the values you get back from the sensor when it’s covered with something and when not.

Here’s a first attempt at visualizing the schematic with Fritzing:

Note that for now this includes a pot (to set the motor speed) and no external power (doesn’t seem necessary for now).

And this is a simple program that will turn on the laser when something is in front of the photo sensor:

const int transistorPin = 9; // connected to the base of the transistor
const int laserPin = 13; // connected to laser TTL control (white wire on https://www.sparkfun.com/products/8654)

}

That’s actually it for the electronics. This part went easier than expected, thanks to some great tutorials on SparkFun, Bildr, the physical computing wiki from ITP – and of course Alex’s great courses.

What’s next: I have to find a nice design to keep all the parts together. Now everything is literally kept together with tape, which is not very safe. I already sent some mirrors flying around the room. I think I’ll start with moving the optical sensor related things to a second breadboard and connect it to the other one with some longer wires.

References

Here is a nice example:

And this is another good example.

Concept

• A few mirrors are mounted vertically on a spinning disc.
• A laser is pointed on the mirrors. The mirrors reflect the light.
• The mirrors are all have a slightly different inclination.
• When the laser shines light continuously, then each mirror will reflect the light at a slightly different height on the wall. For example: 8 mirrors = 8 lines.

That’s how to draw parallel lines. If we have 6 mirrors and the laser is on continuously, then we get this pattern:

mirror 1: on ——
mirror 2: on ——
mirror 3: on ——
mirror 4: on ——
mirror 5: on ——
mirror 6: on ——

To draw patterns or text the trick is to turn the laser on and off at the right moment. For example, to have only two lines in the middle, we would need to do this:

mirror 1: off
mirror 2: off
mirror 3: on ——
mirror 4: on ——
mirror 5: off
mirror 6: off

Controlling the speed of the disc with the mirrors is crucial for this. I’m thinking of using the solution from the video: the disc is white, and one spot has a black marker. An optical sensor detects when the black marker passes in front of it, and like this it’s possible to find out how many rounds per minute the disc is doing. This is a first shot the algorithm in pseudocode:


numMirrors = 8;
mirrorWeWantToHit = 2; // let's say we want to hit mirror 2

timeDiff = difference between now and markerLastSeenTime
if(timeDiff > mirrorWeWantToHit * timePerMirror && timeDiff > (mirrorWeWantToHit + 1) * timePerMirror){
switch laser on
} else {
switch laser off
}


At a later point I will also need to define a font map if I want to display text. However, all the examples I saw were using text, and I think it might be interesting to work with more abstract shapes, such as waves and blocks.

Bill of materials

• 1 x Laser Module – Red with TTL Control. It bought this from SparkFun a while ago, but never used it. I’m not sure why this costs $18.95. Most examples I saw use cheap laserpointers.
• 1 x Optical Detector / Phototransistor – QRD1114 ($1.13). The range of this thing is 0.50 – 1 cm, so it seems like a good idea to use this.
• 2 resistors for the phototransistor, one 200-200ohm and one 4.7k – 5.6k ohm
• A motor. I have one of these standard toy motors that came with my Arduino starter kit, but I’m pretty sure these are not powerful enough. I found a bigger, 12V (2.1W) motor laying around here.
• An IRF520 MOSFET transistor, for switching high current for the motor.
• A diode, also for the motor.
• A pot resistor is nice for testing so you can control the speed of the motor easily. But it is not required.
• An Arduino. I used an Uno.
• An external power supply.
• A mirror. I started off with a one I found in a cheap shop (€ 1.50).
• Something to put the mirrors on. I’ll look for something simple to begin with, but it could be nice to have a Processing sketch that creates a 3D object I could print with the Makerbot. I could then easily make different versions of the object, for example one with more mirrors.

First steps

At this point I know enough about electronics to know that motors need power, but I’m a little unsure if I should use a transistor or a relay. This tutorial seemed to suggest that a transistor is fine. I started off with building the circuit to control the motor, which was pretty easy by following the tutorial.

Then I taped a mirror to the motor and connected the laser by following the guide from SparkFun. I did a quick test by pointing the laser the rotating mirror.