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

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

It took a while since I first posted about the new ATmega header board but finally, here it is.

The board is great for prototyping on a solderless breadboard. It is compatible with the common 28-pin AVR controllers like ATmega48, ATmega88, ATmega168 and ATmega328. On plus it is Arduino compatible.

Some of the features:

• Space efficient, occupies only on more row than the controller itself
• Has no voltage regulator on board, so you choose, at which voltage you want to run it
• It has SMD resistors and LEDs (size 1206) to make it a great starting point to learn how to hand solder SMD
• Has a sticker to tell which pin is what. Thanks Tod!
• Blinks blue!

Check out the detailed howto page and grab a kit at the shop, if you like.

What is a remote accelerometer? It’s a tiny device that has a three axis accelerometer and transmit the acceleration values to a remote host. And what is it good for? There are various uses for it. One is you attach the sensor to someone and let him jump around. On your remote machine you can use the data to produce sound or modify music. Think of it as a simplified Wiimote.

Last year Jan of electronicperformers.org came to me with the idea to make the jumping of people on a trampoline audible. We thought about it and it seemed to be easy. I tinkered with some XBees and ADXL acceleration sensors. They worked quite ok, but we had some trouble with the transmission, which sometimes just stopped for a couple of seconds. Maybe some kind of resetting, I really don’t know. Here is a video of the installation.

After that I thought, nice, but can’t we get it smaller and cheaper? So I sat down and designed a tiny custom PCB.

Features

I had already two JeeNodes laying around. These boards are using a RFM12B transceiver board to communicate with each other. So I decided to use the RFM12B as XBee replacement. They are really cheap, around 3 to 4 Euros.
The device should be Arduino compatible. Mostly because of the ease of development and available libraries.

• ATmega328P, Arduino compatible microcontroller, running at 8 MHz
• ADXL335, 3 axis accelerometer, +/- 3g
• RFM12B radio transceiver, 868 MHz, range of up to 100 meters
• MCP1702 linear, low-drop voltage regulator for 3.3 V, 250 mA
• powered by a 3.7 V lipo cell, 100-300 mA
• 6 pin ISP header for programming the bootloader
• 6 pin serial header to attach an FTDI-cable
• voltage sensor to tell when the battery goes low

Assembly

This is my second try on SMD. Resistors and capacitors are sized 0805. The controller is TQFP and the ADXL335 is LFCSP. LFCSP has not even pins you can hand solder. A very tiny package. As I had no stencil to place the solder paste (because I still have no laser cutter) I had to place the paste by hand. Pressing hard on the syringe and trying to work precisely at the same time is not that easy. After placing a tiny bubble of paste on every pad and gently placing all components, I heated up my hot-air rework station. Soldering with the hot-air station was easy. Not all components are well aligned, maybe because I used not enough solder paste. Often mis-aligned parts slide into place as soon as the paste gets liquid.
Next were the headers, battery connector and the RFM12B module. These were soldered traditionally with an iron.

Here is a picture of the back with the RFM12B module. The red wire is the antenna.

Software

After having the thing assembled it’s time to test it out. First is to program the Arduino bootloader. For that you need an ISP programmer. I used the USBtinyISP from adafruit. Simply select the target (Arduino Pro Mini @ 8 MHz w/ ATmega328), programmer and the port in the Arduino IDE and select “burn bootloader”. Worked on the first try.
Next is a blink sketch to check if the serial connection and the LED works. It turns out that I used too little solder paste on the controller. After resoldering that pin the LED worked.
Next sketch was to check if the ADXL works correctly, which it did. All three axis seem to work great.
After that I had to get the transceiver working. I took the RFM12 lib from Jee Labs. You have to download the Ports lib as well to get it running. First I uploaded the RF12demo sketch, which allows to setup the RFM12 module and store the configuration in EEPROM. The module was recognized and configured with no problem at all.

Time to develop the actual firmware. Here is the sketch for the sensor.

// RF12B ADXL sensor
// config D i4 g212 @ 868 MHz

#include "Ports.h"
#include "RF12.h"

int xPin = 0;
int yPin = 1;
int zPin = 2;
int ledPin = 5;
byte buf[6];

void setup() {
  rf12_config();
  pinMode(ledPin, OUTPUT);
}

int x, y, z;
unsigned long time;
byte ledOn;

void loop() {
  rf12_recvDone();
  if (rf12_canSend()) {
    x = analogRead(xPin);
    y = analogRead(yPin);
    z = analogRead(zPin);
    buf[0] = x >> 8;
    buf[1] = x;
    buf[2] = y >> 8;
    buf[3] = y;
    buf[4] = z >> 8;
    buf[5] = z;
    rf12_sendStart(0, buf, 6);
  }
  if (time < millis()) {
    time = millis() + 200;
    if (ledOn) {
      digitalWrite(ledPin, HIGH);
    }
    else {
      digitalWrite(ledPin, LOW);
    }
    ledOn = !ledOn;
  }
}

It's really easy. You have to call the rfm12_recvDone() to make sure the driver is still working. You have to call it, even if you are not trying to receive anything. If rfm12_canSend() returns true, we can transmit our data. We read the 3 axis acceleration and pack it into a byte array. This byte array is then transmitted. No more, no less. No acknowledge, nothing.

The receiver part looks almost the same, it receives the data and prints it on the serial port. From here on, you can do almost anything: Processing, Pure Data, Python, what ever fits best. You only have to be able to read a serial port.

Demo

For the demo I used Processing to draw a graph of every acceleration value. The red one is a bit hard to see in the video. Then I used Python with pyglet to play short wave sounds.

Outlook

The picture above shows three generations of this device. On the left is the first implementation, using an XBee and an ADXL335, both on breakout boards, wired on a prototyping board. In the middle is the first custom PCB. As you can see, there are two air wires. That happens, when you get distracted while designing a PCB. On the right is the current version.

For the next design I would include an ON/OFF switch so you don't have to pull off the battery all the time. And maybe add a small tactile button to make more Wii-like projects possible.

Downloads and Links

• Eagle files and Arduino sketches, remote_accell.zip
• RFM12 lib at Jee Labs, great stuff!

If you’ve missed Marcus post, here is another on the same topic.

Nearly every other Thursday Marcus and I are hanging out together for having a beer and chatting about all things geek, especially electronics, CNC, 3D-printing, micrcontroller and Arduino. But there’s no limit, everyone interested in tinkering and making is welcome. It takes place at Saal II in Schanze. Try us, we’re kind

You can take a look at Marcus’ or mine twitterfeed to checkout when the next #palo_altona will be.

We already had guests sometimes but yesterday’s drinkup was great as we had two new guests. Feels as if there is something moving in Hamburg. Yeah!

Update 2010/02/16: Palo Altona is now scheduled biweekly. Every Thursday was a bit stressing for everybody.

Update 2010/03/20: Palo Altona has now a Posterous page for news and schedule.

A couple of weeks ago Jan came to me and asked me if I could build a special kind of twitter wall. At our company CoreMedia we do an Open Space every 3 months or so. This time we had a Hacking Day as well, so we needed something special. After throwing some ideas around, we came up with a twitter client that should print out tweets with an electric typewriter. A short google showed, that that has been done already (of course!). See it at oomlout.

But that couldn’t stop us. Jan scanned ebay for a nice electric typewriter and found a Commodore SQ 1000. It was in really good condition, probably rarely used. It worked as advertised.

Take it apart

First step is to take it apart. That reveals a small PCB and the connections of the keyboard. Later I realized that I hadn’t to open up the keyboard itself, because there is nothing of interest in there. It is a simple keyboard matrix.

The big chip on the right is a SEC microcontroller. The smaller chips should be there for driving the barrel etc. but I haven’t investigated that. The green foil in the middle is the connection to the keyboard. Actually there are two connections, each with 8 lines, one for the rows, one for the columns to form a matrix.

I decided, that the easiest way to simulate key presses was by shorting the switch of the desired key. I soldered two 8 line cables to the solder joints on the bottom side of the PCB. Actually there were 12 lines on one of the connectors, but 4 of these lines are used to drive LEDs for caps lock and power.

How does it work

Putting everything back in to place I tried to understand, how the keyboard matrix works. Very helpful was this tutorial, that connects a keypad to an AVR.

All 16 lines are directly connected to the controller, no external pull-up or pull-down resistors. As already said, the 16 lines are arranged to form a 8 by 8 matrix, giving 64 possible key codes. 8 lines are supplying 5V (called out) and the other 8 lines are low (called in). The controller then cycles through all out lines, pulling it down, one at a time. Then it checks if one of the in lines is pulled to low to identify the pressed key.
To simulate the key press I have to wait for low on a specific out line and then pull one of the in lines low. I used my oscilloscope to see what’s really going on. It turns out that the controller scans for key strokes with 87 Hz. Every line is low for about 150 us. I used the Arduino to record the sequence and calculate how wide the low phase is. When I would find a low on line 1 of the out line, I could use it as trigger and compute when the other lines would be pulled down. That way I would only use a single wire (and Arduino input) to detect the out line.
To set a specific in line to low I am using a 74HC595, a shift register with tristate output. The tristate is nice, because if it is disabled, the keyboard is fully functional as if the Arduino is not connected at all.

Here is everything connected on a breadboard. On the left is a standard Arduino with an Ethernet Shield.

On the right is the shift register. In the middle is a pull up resistor connected to line 1 of the out lines. That is used to be able to “see”, when the line goes down.

Reading twitter

The software part to connect to twitter is straight forward. I used the twitter search API to pull tweets that contained the word #cos09, which was the hashtag used at the CoreMedia Open Space. The query is executed every 60 seconds and the query string looks like this:

Parsing the json formatted response is a bit ugly, mostly because memory is very limited on the ATmega168. After fetching and parsing a complete response, the max_id is stored and used for the next query. That way only new tweets are printed.

Demo

So far everything worked well, except the hash sign (#), the @ and … umlauts (*sigh*). The hash sign is not available because it only accessible by pressing the code key simultaneously, which is not possible with the current setup. The @ is not available at all, I simulate it by the sequence O-backspace-a. Umlauts are missing because … I’m lazy.

Final twitter wall setup

This is the setup as twitter wall. On the right is a video camera, recording incoming tweets and displaying them via a projector on the wall. The notebook is only bridging WiFi to Ethernet.

After all, the retro twitter wall was fairly successful. People stood around with a smile, tweeting with their iPhone, waiting for an intense “rattatatat rattatat …”.

Here is another action shot, taken by Jörn.

Links and Downloads

• Source: twypper.zip
• Twitter Monitoring Typewriter at oomlout
• Connecting a keypad to an AVR
• Keyboard Matrix Help

Here is my very first article. It is published in c’t, one of the best known computer magazines in Germany. wOOt!

It shows some basic Arduino examples and how to build a Wiimote-like controller. The controller consists of an 3-axis accelerometer, a push button and an Arduino nano on a breadboard. This combination is used to control a Lunar Lander type of game, programmed in Processing.

• c’t article Shake, rattle ‘n’ roll, as full text
• wiki with more images, links and downloads

Often, when I am tinkering with a controller on a breadboard, I have to open up the according datasheet, only to look up the pinout. So I designed a simple page with all of of the pinouts that I use most. It has:

• 8-pin AVRs, ATtiny25/ATtiny45/ATtiny85
• 20-pin AVR, ATtiny2313
• 28-pin AVRs, ATmega48/ATmega88/ATmega168/ATmega328
• Arduino to ATmega mapping
• ISP header, 6-pin and 10-pin
• FTDI-cable

Maybe it’s helpful for others as well. You can download it as:

• micro-cheat-sheet.pdf
• micro-cheat-sheet.svg

If you like it, you will also like the Tod’s cool Arduino chip sticker.

Update 2010/01/24

The new version includes the pinout of the Bus Pirate. Thanks Philipp for the update.