Recently I got more and more fed up by EAGLE CAD. It is a good EDA tool. But the restrictions are really starting to bother me. I need to do more 4 layer boards. Perhaps bigger boards. And I do not want to invest some thousand Euros just to be able to design bigger boards or more layers on the PCB. And since I am unhappy with my libraries anyway it was a good point to try out a new tool.

As you may remember the Mac OS X support in KiCAD is experimental. And from my first impression: Yes it is.Getting it up and running is a major task by itself. So I am writing down my experiences. Perhaps this helps anybody.

Downloading KiCAD

This is the easiest part. I went to the KiCAD wiki download section and checked the experimental builds. I settled for the builds by Brokentoaster since they got some fine installation package for Mac OS X. Just for the records: The version number while doing this was v3052 as the latest stable build. That’s what I grabbed.

Installing KiCAD

After the installation I checked what it installed – and was not very pleased. It just created an Folder /Applications/kicad/ with some demo files in it. No binary, no documentation, no nothing. I tried the second download link on broken toaster for the .tgz of the same build. And there it was. The application folder by the installation routine still belonged to my user. Not as I expected it to be, but very handy to add the files from the .tgz archive. Finally a complete installation. Starting KiCAD was easy and it worked out of the box. I was a bit puzzled that the first project was created in the Application directory. But nothing a new project in another location could fix. Fine!

But running eeschma showed me that I was not nearly there. All necessary libraries where missing. A good sign that the installation was not complete. After some googling I found an file INSTALL.txt. in /Applications/Kicad/share/doc/kicad/INSTALL.txt. It’s content completely solved the mystery:

The parts of KiCad
------------------
KiCad consists of 3 packages:

kicad         - KiCad programs and core files.
kicad-doc     - Documentation and interactive help (optional package).
kicad-library - KiCad schematic, pcb & 3D-model libraries (optional package).

Obviously the package for Mac OS X contains only the KiCAD program and core files. But neither the documentation nor the essential libraries – hence the error messages. Some lines below there was some super secret hint where to put the libraries and documentation:

Mac OS X KiCad tree
 -------------------

System wide files

 /Library/Application Support/kicad/demos
 /Library/Application Support/kicad/internat
 /Library/Application Support/kicad/library
 /Library/Application Support/kicad/modules
 /Library/Application Support/kicad/modules/packages3d

User files can be the same as the system wide files but only inside the users home directory.

$HOME/Library/Application Support/kicad

Warning:
 These paths are hardcoded into KiCad, if you put them somewhere else KiCad will not find them when a new
 project is created.

So back to the download page and get a complete Linux package to extract the documentation. I went for the complete Ubuntu installation. It was nearly the same version and had ‘complete’ on the cover. Downloading and unzipping it it showed me a beautiful Linux file tree with all the needed files. Since I am the only person on this computer using KiCAD I created ~/Library/Application Support/kicad and copied the directories ‘demos‘, ‘internat‘, ‘library‘ and ‘modules‘.

The Result

After copying all the necessary files in all the necessary locations gave me complete and functional KiCAD installation. There are some graphics glitches in the schematic editor. But I hope that those are gone in one of the next versions.

So off to check the tutorial to do something useful with my fresh installation!

You may know that the whole spring and summer has been a bit quiet over here at Interactive Matter. And again for a reason. I was asked by a friend to build the electronics for a massive LED installation for the  ‘Hsinchu Biomedical Science Park Exhibition Center’.

The result was very impressive: An 10 meter long installation, consisting of 30 moving triangles with controllable RGB LEDs in them, acting as a moving display.

A XMOS controller driving 60 stepper motors,  with about 100 meters of HL1606 digitally controlled LED strips composing a moving LED matrix of  30×102 pixels. The concept and design was done by Taiwanese partners. Interactive Matter only provided the electronics and programming.

Driving the HL1606 LED strips

As every big project it all started as a very small and manageable looking proof of concept:

The basic idea was simple: The XMOS XC-2 kit has 4 processing cores, three of them having two 12 pin connectors. So each core can support 16 HL1606 LED strips (some control pins and 8 data pins per connector, with two connectors per core). Due to the parallel architecture of the XMOS controllers it was very easy to create some scalable implementation for the HL1606 driver). Implementing the driver was also quite a breeze since adafruit hosts the datasheet there are some good Arduino tutorials for this. The big problem was that the HL1606 only supports 2 grayscale levels, while it was only practical to use just 1 bit control (on or off). So this called for some kind of software controlled PWM. The lenght of the strip and the communication speed controls the update rate of the LED strip. And especially the communication speed varies widely with electric noise, cable length, power supply quality and so on. The solution to this was to implement some pulse density modulation. By this the grey scale modulation the color depth automatically adapts to the image refresh rate on the LEDs. The faster the update of the LED strip in comparison to the update of the RGB data displayed on the LED strip, the higher the perceived color depth. Nice (and necessary).

Driving the stepper motors

For the stepper motors I used the simple pololu A4983 stepper motor driver carrier chained with some Microchip MCP23S08 to adapt the Pololu drivers to SPI. So I could drive up to 32 motors from a single XMOS connector. A simple and effective plan. But at the beginning of the construction phase I completely underestimated how much work it is to solder 60 motor drivers.

But finally it was done, only to learn that there was a mistake in the MCP23S08 footprint. But no design is a good design without fix wires:

The only think keeping me sane during the build period was the fun that Interactive Matter was the workbench for some Taiwanese company.

Assembling everything

Finally the XMOS and the motor drivers were shipped to Taiwan, where the arrived safe and sound. But the result of the unpacking gave the impression of the scale of this project.

And the scale of the project got even more visisble once the stepper motors and drivers where installed onto the base board.

And gosh where we happy when we saw the first light on the installation.

So the next step was to pack everything and reassemble it at the customer site.

And testing it. The first results were at best described as – uhmm – mixed.

Everything that worked nice in the ‘clean room environment’ had a good amount of trouble in the real world. There were a bunch of high voltage or high current cables in the ceiling. Giving the digital communication a hard time. But finally after some debugging and fixing everything was ready for the big show.

The final installation

Even Ma Ying-jeou, the president, attended.

And after some more debugging and fixing we were able to see some very nice results of the installation:

Some final thoughts

There were two facts in this project which really puzzled me. First of all the whole project coordination was done via video conferencing. I was never to Taiwan (yet) and have never seen the final result. It worked very well considering the hassle of communication and time difference. It was great to do a project with the partners from Taiwan. Even though I only did the electronics and programming.

Second the digital communication in the installation could have been better. If you are working with medium distances and/or motors be sure to use some more robust protocol like RS485 or LVDS (more on that topic soon).

I would massively like to thank the people at XMOS and XCore, the XMOS community. This project could have never happened without their help. And it was the first project for me to discover the power of the parallel processors from XMOS. Marvelous stuff. They scale well and are easy to program. One of my new favorite piece of hardware. I would really like to thank XMOS for their open source initiative. It helped this project a lot!

Even though XMOS have a very encouraging open source initiative and even released the base software for this project as open source there is only a HL1606 driver sketch availaible at github. In the mean time Interactive Matter maintains the XMOS Led Tile Appplication, which is the heart of this project. So the HL1606 driver will eventually end up there, so please be patient. The motor driver will never be released as open source. It is just not good enough. But you can expect some activities in that area soon on Interactive Matter.

In the end it was a quite big and fun project. It was great to work with the partners from Taiwan and the people from XMOS. And the result is quite impressive. I hope you will see more of this from Interactive Matter in the near future.

You may know the Blinken Button for Beginners Kit. And you may know that I am quite out of stock at the moment.  But things are changing: The new Blinken Button Kits have arrived!

The best: The now come in red or green (Jimmy liked it – so I added this option) and I got plenty.

This new Blinken Button version sports some enhancements over the old version which came from contribution, wishes and recommendations:

• First of all they now come in red or green – more options for you!
• They include built in self test to give you a better chance to find the nasty solder bridges.
• They now have an optional SPI connector to use them as simple 8×8 displays.
• The PCB is now white (don’t know how this is an advantage – but I like it more so I sell it here as an advantage).

The idea to add an SPI interface cam from Johannes and Gabe. In a unbelievable stunt they hacked the SPI connection in the old version the same night they bought the kit – and added the implementation straight away. So thank them that this it´s now a standard feature. And be sure to check out their spectacular Game Of Life on Blinken Button too!

Please apologize that I did not find enough time to prepare packages – so they will restock in my shop in the next few days. But if you really want one just send me a mail and I will restock on demand (i.e. send you one or some). And if you don’t dare to solder it on your own come to the Chaos Communication Camp near Berlin. I will offer some SMT soldering classes with Blinken Buttons for Beginners there.

Related posts:

• Blinken Buttons for Beginners – a SMT Beginners Kit
• Blinken Button as a SPI Display
• Blinken Button revisited

It was time again to talk at the Good School ‘Camp Digital’ about the Internet of Things. Instead of choosing a real world example I choose to revive the good old ‘Twitballon‘ and create a new and improved version.

Twitballoon is a simple Arduino installation, which raises a balloon according to the activity of a certain keyword on twitter. The old version was using a hacked servo to move the ballloon but the servo had real problems with temperature stability. Due to the great opportunity to bring the Trinamic stepper driver chips to Arduino the servo was replaced by a stepper motor.

The basic principle of the Arduino sketch is real simple: The Arduino is connected to the internet via the Ethernet Shield and uses the Twitter Streaming API to permanently search for tweets with a certain keyword.  A Tweet raises the level of the balloon for a certain amount and over time the position of the ballloon is lowered again. By this the position of the balloon reflects the activity on Twitter regarding the selected topic.

The stepper motor is driven by an experimental Trinamic breakout board. Interactive Matter provides a first version of the Arduino library for the TMC260/1/2 chip of Trinamic. The Trinamic chip makes driving a stepper motor a breeze. It offers a very detailed configuration, adapting the driver exactly to the given stepper motor, giving a very sielnt and precise control over the stepper. This is a little bit overkill for this project but in the end it made the positioning of the balloon very easy.

The look of Twitballoon 2 is intentionally rough and industrial to give it a technical yet humble appearance. In the end it was a very nice and conversational piece, communicating the playful aspects of tinkering.

Related posts:

• Twitballoon – a Twitter Trend Visualizer

There is nothing better than happy and even creative customers! At 27C3 Johannes and Gabe were one of the first customers for the Blinken Button Kit. After some minor issues they managed to assemble their kit. But that was positively not enough for them.  They wanted to use the Blinken Button as SPI slave, so that they can use them as a display. To control the animation and texts from other microcontrollers, e.g. an Arduino. So they sat down, hacked the software and hacked the hardware until they succeeded. The even got their first SPI Blinken Button ready on the 27c3!

Congratulation!

Right now their solution looks as hacked as it is. But you have to blame me for this since I did not break out all the pins for the SPI connector.

I am reviewing the Blinken button design anyway. So I think I will follow their recommendations and find a way to break out the SPI pins as optional connectors. Let’s see how it will look in the end. But I think it is good to have those pins available.

So check their Blinken Button Code over at Github and see if you can also repurpose your Blinken Button. And if you got other Blinken Button hacks be sure to leave a comment!

Related posts:

• Blinken Button revisited
• Blinken Button for Beginners Version 2
• Blinken Button – The LED Matrix Button Kit

It was a bit quiet in the last months here at Interactive Matter. For a reason!

One happy day in fall 2010 Mitch and Jeff convinced me to prepare some Blinken Buttons for Beginners Kits for a SMT soldering workshops at the 27c3 in Berlin. I was happy that they did! And I suffered massively because they did. Preparing 50 kits, ordering material, reworking How-To’s, packaging packages and packaging my suit case cost me a lot of time (the later was not that complicated). But in the end I was prepared, got everything packed. Unfortunately I completely forgot any marketing material. You know on conferences there are these kind of hosting space called walls where you are supposed to bring up some content on paper, publishing it with stickers. So I had to come up with an impromptu solution. But fortunately with Mitch’s help I could gather all necessary technology and created this wonderful ad shown above.

And best of it all Hackable Devices and Interactive Matter stumbled over each other and made a distribution deal. So as soon as I have restocked again you can get the Blinken Buttons directly from Hackable Devices.

It was big fun! We soldered so may kits (thanks to anyone who bought one). And as always stated by me SMT is easy to solder. After some short introduction and showing some tricks of the trade everybody was able to solder it. We even had some complete soldering beginners who never soldered before, choosing the Blinken Button as first kit! Perhaps more for the look than for the technology. But they did it and they did it well and returned happy with their Blinken Buttons. Some guys even started at the conference to hack the software by adding a SPI interface to it! Cool!

And spending some days with Mitch was a great experience too! Watching him teach and seeing his approach to all this DIY hardware stuff helped me so much. So special thank to Mitch & Jeff again, without your help this great success of Interactive Matter have never been possible!

Related posts:

• Blinken Button for Beginners Version 2
• Blinken Buttons for Beginners – a SMT Beginners Kit
• Blinken Button as a SPI Display

Interactive Matter proudly presents the first joint project with Tinkerlog (the Space Invaders Button does not count, it was me doing a knock-off): The Twitballon.

The nice people of Good School approached us, asking for a simple showcase what tinkering is all about. Nothing less. So Alex of Tinkerlog and Interactive Matter came up with the idea of Twitballoon. Twitballoon is a simple balloon winch. An Arduino controls a small servo lifting or pulling down a balloon according to Twitter activity regarding a predefined topic. To see it in action head up to the video after the click.

Twitballoon is controlled by an Arduino, permanently performing Twitter searches for a predefined keyword. If it finds a tweet the balloon is released a bit and lifts up. Over time it is pulled down again. So the height of the balloon reflects the activity of that keyword on Twitter. It is much easier to understand if you watch the video:

Twitballoon it is a very poetic way to visualize Twitter activity regarding a topic. It is much easier to comprehend then some dry graphs. It was nice to see how the visualization triggered a nice competition for the chosen keywords Kolle and Rebbe.

Since Alex has done all the hardware just check his Twitballoon post for all the nifty hardware details. If you are more interested in the software side of the project read you can find all the implementation details here.

The heart of the project is the Ethernet Shield and its accompanying library. To make the network setup as easy as possible the DHCP and DNS library was used (don’t know why it is not already included in the Ethernet Library). The Arduino acts as a web client, retrieving its IP via DHCP and resolves Twitter via DNS – this setup is much easier than just using predefined IP-Adresses. The HTTP client is used to perform Twitter searches via the Twitter Search API.

The implementation for the balloon behaviour is quite simple. The Arduino maintains a concept of the current level of the balloon. Every time the search keyword is found on twitter a certain amount is added to the height of the balloon. By this the balloon raises. Over time the height is reduced slowly until it hits zero. If you want to check it out yourself just grab the source.

It is a very simple hack. But in the end it was a beautiful trend visualization. Let’s see if there is an improved version soon.

Related posts:

• Twitballoon 2

Update: There has bee a major API change in Version 1.0 refer to the dedicated aJson page.

Exchanging data with other computers can be a daunting task with Arduino. No matter if you just want to pass some information to Processing, to a Web Service or something else – You always have to encode the data and decode the answer.

There always have been solutions like XML for structured data. But XML is hard to decode, complicated an takes up a lot of space. And then there is JSON. JSON is an easy and efficient way to transfer data. A complex data structure can for example represented as
{
"name": "Jack (\"Bee\") Nimble",
"format": {
"type": "rect",
"width": 1920,
"height": 1080,
"interlace": false,
"frame rate": 24
}
}

aJson is an Arduino library to enable JSON processing with Arduino. It easily enables you to decode, create, manipulate and encode JSON directly from and to data structures. By this you don’t have to bother with data encoding and decoding – this will hand aJson for you. It is based on the cJSON implementation, reduced in size and removing one or two features.

Using aJson

To use aJson get it from the git repository or download the latest version. Unpack the zip file (or the git files) into an Folder ‘aJson’ in the Arduino library directory ‘libraries\’. Due to the early stage of this library you can encounter problems. Simply submit a ticket and it will fix it as soon as possible. On github you will also find a simple Arduino sketch to test the library, or as a starting point.

To parse the above structure with aJson you simply convert it to a object tree:

 aJsonObject* jsonObject = aJson.parse(json_string);

(assuming you got the JSON string in the variable json_string – as a char*). This is an object. We’re in C. We don’t have objects. But we do have structs. Therefore the objects are translated into structs, with all the drawbacks it brings. Now we can e.g. retrieve the value for name:

 aJsonObject* name = aJson.getObjectItem(root, "name");

The value of name can be retrieved via:

Serial.println(name->value.valuestring);

Note that the aJsonObject has a union ‘value’ which holds all possible value types as overlays – you can get only useful data for the type which you have at hand. You can get the type as

 name->type

which can be either aJson_False, aJson_True, aJson_NULL, aJson_Number, aJson_String, aJson_Array or aJson_Object. For aJson_Number you can use value.number.valueint or value.number.valuedouble, for aJson_String you can use value.valuestring, for True or False, you can use value.valuebool.

If you want to change the name, you can do so by

aJson.getObjectItem(jsonObject,"name")->value.valuestring="a new name";

To render the object back to a string you can simply call

 char *json_String=aJson.print(jsonObject);

Finished? Delete the root (this takes care of everything else).

 aJson.delete(root);

This deletes the objects and all values referenced by it. So take care for your string, you directly assigned. They are deleted too.  If you want to see how you’d build this struct in code?

aJsonObject *root,*fmt;
root=aJson.createObject();
aJson.addItemToObject(root, "name", aJson.createString("Jack (\"Bee\") Nimble"));
aJson.addItemToObject(root, "format", fmt = aJson.createObject());
aJson.addStringToObject(fmt,"type",        "rect");
aJson.addNumberToObject(fmt,"width",        1920);
aJson.addNumberToObject(fmt,"height",        1080);
aJson.addFalseToObject (fmt,"interlace");
aJson.addNumberToObject(fmt,"frame rate",    24);

The whole library (nicely provided by cJSON) is optimized for easy usage. You can create and modify the object as easy as possible.

Limitations of aJson

Unfortunately everything comes for a price and complex data structures and text processing is not really the primary domain for Arduino. So some simplifications had to be made:

• aJson is not really suitable for ATmega168 based Arduinos – there is just not enough RAM – and the library itself eats up toe 80% of the flash memory.
• aJson cannot handle Unicode.
• Lists and Objects can only handle up to 256 entries.
• All strings are case sensitive, this is no real problem for values. But if you want to find a name you have keep in mind that it works case sensitive.

A lot of these limitations will be gone in the future versions of aJson.

Further Development of aJson

Currently aJson is considered to be in a beta phase. It is usable, but it can get better. The most important task is to further reduce the memory footprint. Therefore the API may change a bit in next versions. When the library is better tested and more evolved it will be package as real Arduino library.

I hope that many people will use and test the library. So go ahead and download aJson!

Related posts:

• Arduino & AD7746

A short German sumary, English version after the click:

Auf zur Palo Altonale! Zusammen mit Tinkerlog, Palo Altona und Interactive Matter bietet die Good School einen Kurs zu Physical Computing & Tinkering in Hamburg an. Ziel des Workshop ist es Kreativen in 2 Tagen die Umsetzung von interaktiven Physical-Computing-Projekten auf Basis von Arduino zu vermitteln.Wer immer schon mal interaktive, elektronische Spielereien selber basteln wollte ist bei uns bestens aufgehoben.

Wir geben nicht nur eine Einführung in die Programmierung mit Arduino sondern helfen jedem ein eigenes kleines Projekt umszusetzen! Jeder Teilnehmer erhält einen Arduino mit Netzwerkverbindung, notwendige Bauteile und Sensoren. Grundkentnisse sind eigentlich keine erforderlich (OK, Computer bedienen istsollte drin sein). Wer dann schon mal eine Programmiersprache gesehen hat (ActionScript, JavaScript, oder was auch immer) kann mitmachen. Wer denkt er könne keinen Arduino programmieren wird eines Besseren belehrt.

Der Workshop findet am 29. & 30.10.2010 statt. Weitere Informationen gibt es bei der Good School oder Facebook. Wer Interesse hat innerhalb des Workshops spezielle Themen umzusetzen will (MIDI, Robotik, …) meldet sich frühzeitig bei der Good School – dann können wir darauf gerne eingehen.

And now for the English description …

Tinkerlog, Palo Altona and Interactive Matter will help Good School to offer a Arduino workshop in Hamburg. The idea of the workshop is to bring creative professional in touch with physical computing. Every participant will build a physical project interacting with the internet. The basic concept of the workshop is pretty simple. Every participant gets an Arduino with a network connection and some physical interface sensors.  We will give a short introduction into the Arduino platform and how to program it. Everybody who had a look at ActionScript or any other programming language will be able to programm his Arduino. Don’t be shy, since you think you cannot program – nobody will be left behind. The most important part of the workshop will be free tinkering. You can design and realize your project. We will help you with any question, programming or sensors that you need! We will bring a plethora of stuff and experience! If you are in Hamburg on the 29. & 30.10.2010 contact the Good School and register! Uhmm, the course will be held in German.

Related posts:

• Palo Altona – Hamburg Tinker Drinkup
• Palo Altona will build Hamburg’s first Makerbot
• Tinkering with ADJD-S371-Q999

Developing software – or better firmware – for the Atmel AVR can be quite easy or quite complicated. A lot of people like to just use vi, some source files and a make file. Here at Interactive Matter we are a tad lazy and want a fully fledged IDE, with code completion, one click building, no make files and buttons to flash the AVR. The easiest was is to achieve this with Open Source Software, using avr-gcc, avrdude and avr-eclipse.

To help anybody who wants to use this very convenient package Interactive Matter offers a complete guide on how to install and use avr-gcc, avrdude, Eclipse and the avr-eclipse plugin.