• The Conductive Ink Challenge


    I was recently asked if I wanted to take part in a competition organised by Newark Canada and presented with VHS ( Big thanks to Tom :-) ); a challenge that focused on a very interesting and versatile product, conductive ink. I received a pen in the mail and started to investigate what I could do with it. The Conductive Ink Pen essentially allows you to easily draw lines or tracks that you can pass electricity through. Here is the project that I decided to submit for this challenge. I’ll also explain how I went about building this project and how these concepts can be applied to other projects.

    Rudolph the Conductive Nosed Reindeer

    When constructing this project I wanted to make the conductive ink the star, really show off what it could do but also make it a little out of the norm. From an artistic point of view I really like the way that the silver conductive ink is highlighted on the white stone, even more so when it is lit, beauty in simplicity. I also wanted to bring people closer and connect with this piece so I created a touch interface that starts the sequence.


    Building the Project

    The piece is made up of 4 main parts:

    1. Base Model
    2. Surface mounted lights
    3. Microcontroller
    4. Conductive Ink


    The Base Model:

    As Christmas is nearing there are many ornaments being stocked at local craft shops. After an afternoon looking for just the right subject I came across a reindeer and the idea was obvious. I glued it to a base and that was all I needed to start going.


    Surface mounted lights:

    Surface mount devices or SMD’s for short are components used on the surface of a circuit board as opposed to the traditional through hole method. I decided to use these tiny lights because I didn’t want to drill holes into the reindeer and I wanted to keep the process simple. I mounted one red SMD LED (Light emitting diode, essentially a Light) on his nose and 2 on either corner at the front of the base giving some mood lighting to the model.


    The Microcontroller:

    To control the whole sequence I used a small microcontroller called an Arduino. It looked after detecting the touch, animating the lights and triggering the audio to play on the computer. The code I used for this project is based on the code that I wrote in my experiments with capacitive sensing with Conductive Ink with the addition of the light animation.


    Conductive Ink:

    The main star of this show is the Conductive Ink, it was used to connect all the parts together. There are many great things about this product; the pens are easy to use, they can be applied to almost anything and any shaped surface but the best thing is you can use it as part of the artwork. Conductive ink used to light the nose runs down the left and right side of the reindeer’s face and front legs and out to the sides of the base. For the touch sensor I used a single line from the antlers, down its back and across the background of the base.


    Other Applications

    Conductive Ink is such a versatile and easy to use product, from educating basic electronic concepts to complex circuits, flexible boards and interactive projects. Capacitive sensing as I have used in this project can be applied to many application from detecting a user’s touch or proximity to creating paper thin controls as I have shown in a previous post. The potential uses for conductive ink are vast, grab a pen and start experimenting with making switches, sliders interactive circuits and great looking art.

  • Conductive Ink – Capacitive Sensing Test

    Earlier this week I got a conductive ink pen for a competition that I am currently entered in. I had a bit of a muck around with what I could do with it and the first test that I tried was a capacitive sensing control. The control is a simple slider that drive an LED’s brightness. Capacitive Sensing is a technology that uses the capacitance of the body to alter the charging time on an input pin. The larger a contact surface is the faster the charge time will become; Knowing this we can map the surface charge time to a scale and thus the LED brightness.

    Capacitive sensing circuit using conductive Ink surface with 1 Megaohm resistor and a 100pf capacitor.

    The code below was based on the CapSense tutorial from the Arduino Playground with some additions. I’ve added in 3 sample smoothing and some low end noise reduction. The LED is then mapped to the values coming directly out of the CapacitiveSensor library included in the tutorial.

    #include <CapacitiveSensor.h>

    CapacitiveSensor cs_3_4 = CapacitiveSensor(3,4);
    int led = 9;
    long total;
    long total_01;
    long total_02;
    long holdValue;
    void setup()
        // turn off autocalibrate on channel 1 - just as an example
        pinMode(led, OUTPUT);
    void loop()
        long start = millis();
        //Buffer Samples
        total_02 = total_01;
        total_01 = total;
        total = cs_3_4.capacitiveSensor(30);
        // Average (Smooth values over 3 Samples)
        total = (total + total_01 + total_02) / 3;
        // Remove Bottom end noise
        total -= 300;
        if(total < 0)
        total = 0;
        else if(total > 11000)
        total = 11000;
        //Update LED Brightness
        analogWrite(led, total/43);
        // check on performance in milliseconds & Print Total (Debug)
        Serial.print(millis() - start);
        // arbitrary delay to limit data to serial port

    The Conductive Ink Pen worked quite well and was easy to apply, I didn’t need a lot to get a good surface down on the paper to act as a contact. You can see in the video that I made the conductive surface in the shape of a triangle, this provides the variation in charge time. As the finger is in constant contact with the paper, you need to vary the amount of contact surface to drive the change.

    I have a couple more sensor ideas that I need to try out in the next few weeks and I’ll keep you posted. If you want to try some out yourself head over to Newark and pick yourself up some, there are some pretty freakin’ cool circuits you can make.


  • Super Ultra Deadrising 3 Display

    Over the past 6 months I’ve been working on an Expansion pack “Super Ultra Deadrising 3’ Arcade Remix Hyper Edition EX Plus Alphaand as part of the project I helped build with Jason Buchwitz an in-house display for the project. Here’s a little sample of what the sign was able to do, starting with just an idle animation every minute or so it enters into an attract mode where the sign lives up the name of the game… Massively over the top and completely awesome! Check out the video below and afterwards you can have a read of how the display was put together.



    The Sign is built mainly of foam core with graphics printed and glued to its surface, to illuminate the sign I used some 36mm Square 12V Digital RGB LED Pixels.


    These lights are individually addressable (4 Per Square) and can produce the full RGB gamut. I chained a couple of these strings together and fed them around the display, starting around the logo and then behind the flames. The lights are controlled via a controller Chip (WS2801) and take data via SPI or Serial Peripheral Interface. This data feed is sent from an Arduino  Due.



    This 84 MHz ARM Microcontroller looks after the sequencing of the display and can also control audio playback. The whole display is powered off  2x 12V power supplies for the Lights and a 5V power adapter for the Arduino. I’ll be going into a little more detail about the code and wire setup in future posts… Stay Tuned!


  • Netduino Powered Pumpkin

    Seeing as it’s getting closer to that time of the year when people walk around at night wearing ghastly clothing, no it’s not Talk like a Pirate Day; Halloween. As part of the festivities at work we have a yearly Best Costume and Pumpkin Carving competition. So I thought I would share with you our team’s 2nd place winning Pumpkin family.

    The Pumpkin Family

    Yes the pumpkin was suped up a little from the traditional pumpkin; the competition rules allowed for props to be used I decided to take it to the limit. In a last minute rush the night before the carving, I wired, programmed and sequenced the hardware.

    The setup consisted of a Netduino (Micro-controller that is programmed in c#) for the brains, 4 LEDs (light emitting diode) for the eyes, 2 servos (motors that allow you to set the rotation of an arm between 0-180 degrees) for the eyes and eyebrows and a little speaker to play the theme tune.

    Once all the hardware was built, I created a very simple program to play the theme tune and sequence the movement of the servos and toggle the lighting of the LEDs. The first thing I wrote was the tone generator; to play a note I passed in the note (F#) and using a lookup table I had the note’s frequency, with this I set the speaker output pin to oscillate that frequency. Next I created an array of notes and duration’s, these were the base of the sequencer. Now having the music playing (Thanks goes to my wife who converted the sheet music to note and duration for me) I created the servo and LED tracks and set their timing.

    Netduino & wiring

    The only thing left to do was create an event handler that would fire off the sequence when I pressed a button on the NetDuino. The quality of the music was quite gritty, this was due to not having any smoothing electronics in place, but I kinda liked the classic sounding theme, so I left it.

    The eyes in the following image were bought at a dollar store and mounted on some wire as pivots then the servo and controller arms were mounted to some cardboard for easy installation.

    Inside the pumpkin

    So I hope this quick rundown of how I created the Pumpkin Family electronics has inspired you to go and make your pumpkin a little more high-tech.

    Happy Hacking!

  • Physical Technical Art

    Over the next couple of posts I’m going to be writing mainly on the topic of the emerging field of Physical Technical Art. So… what does that mean you say? Game Development in most parts is a software exercise; once concept art and motion capture has been digitized the remainder of production is mainly dedicated to DCC’s, Assets Pipelines and Code. Development can be fraught with unforeseen hurdles and challenges, some of these problems require a team to think outside the software box and this is where Physical Technical Art implements a solutions. In addition to solving hardware problems Physical Technical Art also aims to improve the human-computer interface (NUI), human to human interface and game interaction methods through the use of technology.

    A great example of a hardware solution is the XBox 360 Controller Monitor. This custom hardware enables the capture of the controller’s inputs (buttons and joysticks) and then displays the values on a small board. This board is then framed with the vision from the game and filmed, giving the reviewer a clear connection between the input and the time taken for it to be displayed on screen.

    The following video is a Tear Down of this hardware, a brief overview of the electronics used and how it captures and displays its data:

    Xbox 360 Controller Monitor (Tear Down)

    Latency is an important concern when developing a game, it changes how the game is played and if it’s too high the user may get frustrated ruining the experience. The Xbox 360 Controller monitor is a practical and simple solution to this important focus. Yes, input latency can be calculated within the devkit; but having a hardware solution ensures no overheads and enables testing for unprofileable games.

    Ben Heck’s Controller Monitor Intro Video

    Ben Heck’s Website

    Uno32 (Ardunio) Code: Macro_Controller.Zip

    Fair Child 8Bit Shift Register DataSheet

    If you use something like this or any other physical solutions in your studios, I would love to hear about it. You can contact me via the contacts tab or just leave a comment.