In May I moved into a new office with the great guys of The Future of Everything. The office has really nice big windows and we thought about what we could do with them. I remembered hektor, this super cool 2D drawing machine. What if that thing could draw directly onto the window?

So, here is Der Kritzler (kritzeln is german for scribble).

Parts

Here is a list of parts needed:

• Motor mount and pen holder, laser cut MDF, 5mm Formulor (german partner of Ponoko)
• 2 stepper motors, NEMA 17. e.g. Reichelt
• 2 suction cups with mount, esska
• Various M5 and M4 bolts, screws and washers, 2 ball bearings Screws and More
• 2 toothed belt pulleys, Mädler
• 6 m toothed belt, Mädler
• Arduino or breadboard compatible Arduino clone
• 2 stepper drivers, A4983, Pololu
• Standard servo (missing on the photo)
• Power supply, 3-12V, 2250 mA, conrad.de

Most sources are german, but I assume that all parts are pretty common. The toothed belt was extremely expensive, almost 20 Euro per meter and I ordered 6. There has to be a cheaper source, especially because I don’t need the best material available.

The SVG to cut the motor mount and the pen holder was my first attempt to have something laser cut. To be honest, it was my second, the first one was a complete fail. This one worked. I designed it in Inkscape because I haven’t decided yet which 2D CAD tool to use. Inkscape can be really annoying but you can get it done. The design is not optimized so it makes a lot more cuts than actually needed, which makes it more expensive.

Assembling

The motor is mounted with its axis towards the motor holder. That way the belt is kept as close as possible to the window. I had to use the black tubes as spacing washer, because the thread on the bolt doesn’t go up all the way. I should look closer next time at what bolts I order.

Assembling the pen holder is quite easy. I just used some wood glue to glue all parts together.

Electronics

I am using the drivers with quarter stepping, which means 800 steps per revolution of the motor. The pulley has a circumference of 62.8 mm, that gives a resolution of ~0.08 mm per step which is far enough for such a device.

The driver board is connected as follows:

• 2B – black
• 2A – brown
• 1A – blue
• 1B – red
• MS1 – GND (via 100k resistor)
• MS2 – VCC
• MS3 – unconnected (means low, has internal pull down resistor)
• RESET and SLEEP are connected

The connections from the Arduino are:

• pin 6 – Debug LED
• pin 8 – Servo signal
• pin 9 – Driver 1, DIR
• pin 10 – Driver 1, STEP
• pin 11- Driver 2, DIR
• pin 12 – Driver 2, STEP

The firmware boots up and expects the motor mounts to be 1500 mm placed apart from each other. The pen holder is placed in the middle with 1060 mm on the timing belt to each side. That position has to be the same every time the machine is powered on because it has no feedback where the pen holder really is.

The Kritzler is then ready to receive commands from the host machine. Possible commands are:

• m dx dy (move relative)
• l dx dy (line relative)
• M x y (move absolute)
• L x y (line absolute)

For every new command it is computed how much steps had to be executed to move the pen to the new position. That involves a bit of geometry because we have to transform the position in x,y into a position that depends on the length of the two belts. If the command is a move command, the servo is used to keep the pen away from the window.

For debugging it is also possible to connect to the Kritzler via a simple terminal. Then you can examine the plotting area, for example, by simply typing M 1000 1000 into the terminal and see where the pen goes to.

Software

I used Processing for implementing the host software. Processing was the first choice because it is primarily targeted for graphics programming and plays well with Arduino. Any other software that could talk to the serial port would work here as well.

The host software falls into two parts. The first part is for reading an SVG file and sending it to the machine. It starts with loading the first SVG file from a directory if there is one. Then you could still scale, mirror and move the shape on your canvas. If everything fits, the drawing is sent to the Kritzler, one instruction after another.

The other part is used to transform bitmaps into more or less pretty SVG files. I have two snippets at the moments. One converts a bitmap into a SVG by using some sort of halftone algorithm. It produces a horizontal line with more or less jitter, dependent on how dark the current pixel is. The second uses ImageMagick and Potrace to convert a bitmap into an b/w SVG file. That black outline is then filled with diagonal lines by another small Processing sketch.

All tools read and write files from special directories. That means tools can be somewhat chained together. One reads files, preprocesses it and stores them in a new directory. Another tool then reads that file and sends them to the Kritzler. To process the SVG files, I first used the built-in functionality of Processing. After some poking around I switched to Geomerative which is a really capable SVG library for Processing.

Testing

This is the very first drawing done by the machine. I used a whiteboard foil on the window which worked pretty well. The pen is a permanent marker. I tried many different pens until now. Whiteboard markers are great for drawing on the window. They could be wiped off easily but are not very intense. My favorites for drawing directly on the window are pens with liquid chalk. Although all I tried have some kind of valve to fill the head. That means you have to monitor the drawing process and when the chalk gets thin, stop the drawing to refill the head. There must be an easier way. Maybe making my own liquid chalk?

More Scribbling

Conclusion

This is my first project that uses ropes, gears and motors. The hardware could be build prettier and cheaper. Maybe I’ll build another more optimized one. We’ll see. Nevertheless I am quite pleased with the outcome. Always great to see people passing the window and then get attracted by the Kritzler, while he paints on the window.

This project is based on great software and inspired by some super cool 2D plotting devices.

Links and Downloads

• Hektor, first in the list!
• Sprites Mods Online Whiteboard
• Wallrus
• Drawbot
• Vertical Plotter, Arduino Forum
• Geomerative, SVG lib for Processing
• ImageMagick, THE image processing tool for the command line
• Potrace for converting bitmaps to vector graphics
• More hi-res pictures at Flickr
• Sources, Arduino and Processing at Github

Almost a year ago Martin came to me and asked me, if would like to join him on a cool project. His idea was to put a LED POV into a real race car. Of course I wanted!

Concept

Every race event attracts a lot of fans. Martin’s idea was to integrate the fans into the race. The race cars should carry fan messages around the track and print them into the night.
The technique used for that is called POV (Persistence of vision). It is somehow related to Light Painting. For that you take a long exposure picture and move the LEDs through it. If the LEDs are switched on and off in the right pattern, it prints a readable message on the picture.

Hardware and Software

We did some prototyping and testing and this is the final version. The module consists of an Arduino compatible microcontroller, LED driver chips and a GPS module. The GPS is used to track the speed of the car. The speed is needed to regulate the speed of switching the LEDs on and off. Otherwise the messages would get stretched or compressed.

The LEDs are blue Piranha 4-pin LEDs (20mA @ 3.2V).

The software was pretty much straight forward as seen in other POV projects. New in this version is the use of the GPS. To have the messages in a pretty font, I developed a small Python script, that converts a bitmap with all characters into a header file, usable with a microcontroller.

At the 24h of Nürburgring

It took some time and efforts until we finally showed up at the 24h endurance race at the famous Green Hell, Nürburgring. We were invited to install our modules into two Audi R8 LMS race cars of the Audi Race Experience team! Wohoo!

Very impressing to look behind the scenes at such an event. We programmed a couple fan messages in every module and installed the module in its car.

We then switched on the modules and the cars went on the track. We crossed our fingers.

And … it really worked! We got some very nice shots around the track.

To sum up, this was the most intriguing and challenging project I was part of until now. It was so big fun and I learned a lot.

Thanks so much, Martin, for letting me join this great project! Thanks also to kempertrautman and Audi Race Experience Team for making this possible.

Be sure to check out the howto and the hi-res Flickr set for more POV galore.

Links

• Race Car POV Howto. This is the detailed write-up of this project. Be sure to check it, if you are interested on how all works.
• Audi’s Facebook Gallery of the Fan Messenger
• Audi Race Experience Team
• kempertrautmann

Soldering is easy. It realy is. If you are still in doubt, head over to mightyohm.com, where you can find a really nice comic on how to solder, done by my good friends Jeff Keyzer and Mitch Altman.

Best of all, it’s totally open source!

Links

• Soldering is easy as PDF

After reading about light stencils at DIY Photography I was sure I had to try that. In short, you use a flash to illuminate a printout while taking a long exposure picture.

Building

To build a light stencil I used:

• a cardboard package (about 25 x 22 x 25 cm)
• a sharp knife
• aluminium foil
• glue
• black tape
• a cheap flash (Unomat B 18 DIGI Slave, 9.99€) with a test button

Here are some pictures on how to build such a thing.

First cut off the edges so that the remaining will form a funnel.

Cut a window into one side. I have a frame of about 3 cm on each side but 1 cm at the bottom. You may want to go even lower on the bottom side, because otherwise your stencil will be always floating.

Then use some tape to build the funnel.

Now glue aluminium foil into it to reflect the flash.

I tried to build a kind of envelope out of a clear folder to be able to exchange the stencils easily. That kind of works.

Testing

Now, take your favorite super hero or what ever and open it in Gimp or Photoshop. Mask the background and fill it with black. Then print it twice. Use the best settings your printer has to offer. The more ink the better. Especially for the black areas. Align both printouts as perfect as possible and fix them with a bit of tape. Then insert the stencil into the envelope. If the stencil is not big enough, use some black cardboard to build a frame.

Next, setup the camera. Here is how I did it, but maybe there is an easier way. Put a well lit replacement at where you want see the stencil afterwards. Measure the distance with the camera auto focus, then switch to manual focus. Darken the room and check the exposure with you camera. Exposure time should be around 20 to 30 seconds. Use a tripod (of course) and a remote control, if available. Otherwise use the self timer. Put the flashlight into the funnel and turn it on. Now hit the shutter, then put the funnel at the right position, hit the flashlight test button and move out of the picture.

This is one of my first test shots (ISO100, f5.6, 30s). Slightly lighten up with Lightroom.

Here is another one (ISO100, f5, 30s).

Yesterday I was out to test the light stencil in the wild. It was still very cold, slightly above 0°C. Setting things up was a bit difficult because it was dark (haha!). I used a flashlight to help me measure the distance. I think it would be much easier to do this in a twosome. Anyway, the first test was disappointing. It turns out that my city (Hamburg) is still really bright, even at night. The stencil was almost invisible on the first shots. I managed to compensate it a bit by using different angles and then over exposing them in Lightroom.

Optimizing

The problem is the ratio between ambient light and flash light. I could use a stronger flash next time, but that may also reveal the complete stencil because the stronger flash will most likely shine through the black regions of the stencil. Even now with the weak flash you can almost see the light stencil on some pictures. How to overcome that? Three printouts?

Another thing that I noticed is that sometimes the two printouts are not really close together. That may look like they are out of focus on the picture. I should glue them together, even the inside, not only at the edges.

Next time I would try to use standard format, say A4, for the printout and the envelope to make it easier to experiment with different stencils. Now it’s like print, glue, cut, insert, add a black patch here and so on.

After all it is fun to play with light stencils. The pictures you get are somewhat special.

Links

• More hires pictures at Flickr
• Use Light Stencils To Create Amazing Light Paintings at DIY Photography
• light stencil tutorial done by Trevor Williams
• Tutorial for light stencils by truemarmelade

Do you remember, when you first started your X and stared at Xeyes? Aaaah, those were the days.

I wanted to have Xeyes in Processing to have it as an example of some lines of code that could be easily integrated into an interactive demo or the like. So I thought, ok, that’s quite easy, just draw a bunch or ellipses and circles. Turns out that it is not that easy.

First you draw an eye, then a straight line from the middle of the eye to the current position of the mouse. Then draw a tiny circle at the intersection of the line with the ellipse. But how to find that intersection?

The solution is to equate the formula of the straight line with the formula of the ellipse.

  y = mx + c  // straight line
  x2/a2 + y2/b2 = 1 // ellipse

Now insert one formula into the other, and solve it for x and y. If you still know how to do that, great! I failed in a few attempts. And felt lazy. Wolfram Alpha to the rescue!

Using the Wolfram Alpha it was easy to get the right solution. See here and here for examples. Now just calculate the values for the intersection coordinates and handle some special cases (e.g. prevent division by zero).

Another example how to use math to solve real world problems

Updated 26.02.2011 to the much easier version as proposed by cjameshuff.

/**
 * xeyes in Processing
 */

int eyeDist = 60;
int eyeWidth = 70;
int eyeHeight = 100;

void setup() {
  size(450, 450);
  smooth();
  background(120, 120, 120);
}

void draw() {
  int eyeX = width / 2 - eyeDist;
  int eyeY = height / 2;
  translate(eyeX, eyeY);
  drawEye(eyeWidth, eyeHeight, mouseX - eyeX, mouseY - eyeY);
  translate(2 * eyeDist, 0);
  drawEye(eyeWidth, eyeHeight, mouseX-(eyeX+2*eyeDist), mouseY - eyeY);
}

void drawEye(int eyeWidth, int eyeHeight, int mx, int my) {
 // draw the eye
 fill(220, 220, 220);
 strokeWeight(10);
 ellipse(0, 0, eyeWidth+35, eyeHeight+35);

 float x2 = mx/((float)eyeWidth/eyeHeight);
 float t = max(1, sqrt(x2*x2 + my*my)/(eyeHeight/2));
 float sx = mx/t, sy = my/t;

 // draw the pupil
 strokeWeight(1);
 fill(0);
 ellipse(sx, sy, 20, 20);
}

Links

• Xeyes
• Wolfram Alpha Ellipse Line intersection
• Processing.js

Two years ago I posted about how to build a neoprene sleeve for a Macbook. This time it’s a sleeve for a Samsung Galaxy Tab. As last time, my mom did the work, I did the documenting

We had some remains from the first project. This piece is a front part of a neoprene wetsuit. Cut out the biggest piece you can get. Then use chalk to mark the size. The size is about 15cm x 51.5cm. You may want to cut it a bigger as you think you need it.

Now cut it out.

Check, if the size still fits.

Now sew the envelope inside out. Then cut the overlapping neoprene as close to the seam as possible. Flip the envelope back to have the outside out.

Check if the tab fits. If its too loose, you can always sew another time to make it a bit tighter. Mine got a tiny bit too tight at the first try, so you have press it a bit.

To keep the tongue in place, we decided to simply cut stripes from the sleeve.

Ok, that looks great. Now just trim the tongue a bit to make it fit into the strap.

Here’s the finished sleeve.

Ready to throw it into my bag. All together the project took only one hour. And for me the result is way cooler than any sleeve you can buy.

Links

• Flickr set with hires pictures
• Neoprene Macbook sleeve

A couple of months ago Martin came up with the idea to build a dustbin, that would take pictures of people using it and then send them to Twitter. We tried some different approaches and finally used an Arduino, a WiFly-shield and a c328 serial camera to build it. It worked really well and was a lot of fun.
What you see there on my desk is the current issue (2011/01) of Weave. Weave is a magazine that covers interactive design and such. We were asked to write an article on “internet of things” and now, there it is. It’s a tutorial on how to use Arduino with twitter and how to take pictures and upload them.

Here is a teaser of the article (in german).

I hope to find some time soon to document the project in a separate post. We’ll see. You can follow @TweetsOfWaste to see any updates of the project and the first couple of pictures.

End of October, Marcus and I gave a two day workshop on sensors, Internet of Things and Arduino. It was for people who had small to no knowledge about electronics and programming, so not for the average geek. The aim was to show how easy it is to build things that interact with the physical world. It was hosted at the Good School.

First day was training. With small examples on sensors and outputs we saw how easy it is, to collect real world data and act upon them. After that we connected the Arduino with a WiFly-Shield to the interwebs. At the end of the day all had an Arduino running, that did a search on twitter and if someone tweeted your name, an LED light up. Not bad for the first day.

Second day was free tinkering. Everyone could come up with ideas for projects. We gave some guidance of would could be achieved until the end of the day and what not. Then all started on developing their projects. Marcus and I had a lot to do in answering questions and giving hints into the right direction. At the end their was a presentation where all proudly presented their project. And they were really great. All teams came up with something that really worked, none failed. What a success.

That was a fantastic experience, having so many people together, tinkering and having fun. All of them were really engaged and fully committed to their projects. I took a couple of pictures, and guess what, all people you see on these pictures are smiling and enjoying what they are doing.

Pictures at Flickr.

Last weekend, Marcus of interactive-matter and I, gave a small introduction into internet of things and ambient devices at the Good School. The idea was to have two devices that show the current volume of two terms on twitter, e.g. love against hate. The demo should show how easy it is to connect the physical world to the internets. Marcus did the software part, so if you are interested in that, visit interactive-matter. I did the hardware part, if you want see that, just read on.

Parts

So what is needed to build something like that?

• Arduino Board with ATmega328
• Ethernet Shield
• Breadboard
• RC Servo
• Cardboard
• Hot glue (a lot)
• Photoresistor, LED and two resistors, 10 kOhm and 100 Ohm
• Protoboard, small

Build it

First you have to hack your servo for continuous rotation. A standard servo rotates only from 0 to 180 degrees. You have to hack it so that it rotates continuously forward and backwards. There are many different servos out there and as many instructions how to do that. Just use google. For me it was enough to separate the potentiometer from the servo arm. Important is, that you can still control it like a servo afterwards. That means you still have the red (+), brown (-) and orange (pulse) cable to control the servo. You should also write a small Arduino sketch to check where the motor stands still.

Now cut a servo holder out of the cardboard and glue the servo onto it.

Glue the holder to some cardboard as basement. Then build a barrel out of coasters and cardboard tube. Cut small holes in one of the coaster. These holes are part of the light barrier to count the rotations. I cut only two holes. Less precision and less work.

Then glue the barrel on the servo.

Next we need the light barrier. It consists of a light dependent resistor (LDR) or photoresistor and a LED. Both need a an additional resistor in series. The one for the LED is for limiting the current. It is around 100-200 Ohm, depending on your LED. The other one is to form a voltage divider with the LDR. My LDR has a resistance between 2 k and 50 kOhm. I chose 10 kOhm. The connect the voltage divider to an analog port of the Arduino. Place the light barrier beneath the barrel, so that the LED shines through the holes onto the LDR.

Next, I wrote a small sketch to test the light barrier. It made the servo turn and tried to detect the light flashes of the light barrier. And it worked!

After integrating the software part with Marcus, this is how it looked at our tiny booth.

Conclusion

After all it worked very well and showed, what we wanted to show.

Connecting things to the internet is easy.

Although, there is always room for improvements. After a couple of hours, one of the servo motors began to turn, even if it shouldn’t. And as there is no longer any direct feedback, only through the light barrier, it turned half, noticed that and turned back. I had to re-run the test sketch to find the new settings for it’s zero point. Next time, I would use a) stepper motors or b) a better light barrier, which could detect rotation direction and more holes.

Links

• See the TwitBalloon software part at interactive-matter.
• Good School

Here are two brand new boards for faster prototyping. These are especially useful for these one-off projects that need to be more permanent than on a breadboard. And they save time as most of the standard components as reset button or ISP header are already on board. Only the custom part of the project has to be soldered on the proto area. They come in two flavors, one for ATtiny25 and one for ATtiny2313 Atmel microcontrollers.

Even a 3 AA cell battery holder with on/off switch is included in the kit. There also two new how-tos with detailed step-by-step instructions, Tiny25 Proto Board Howto and Tiny2313 Proto Board Howto.

You can grab a full kit at the Tinker Store, if you like.