kRC Term Project

kRC is a gesture interface for controlling a remote control helicopter. The remote control is replaced with arm and body movement. It offers a unique experience for flying the helicopter that is very different to typical button and knob controllers. The momentum of the helicopter is much more apparent with body movement. This makes the experience of flying the helicopter much more intuitive.

The kinect sensor’s IR depth camera and rgb camera was accessed through processing. The closest point to the sensor produces an x,y coordinate set that controls signals being sent to the remote control. A red dot is placed on the screen to let the user know what is the closest point. This is often the hand or extended arm as demonstrated.

An Arduino micro-controller was used with an Adafruit Motorshield to control 2 servos that physically turn the potentiometers your thumbs usually move on the helicopter’s controller. The previous hand held interface is replaced with motors that receive signals to move based on your gestures.

Both Arduino and Processing were used. The processing library for kinect is thanks Daniel Shiffman’s and can be found here

Find the source code here for the project.

more at

Posted in 09. Final Project Reports | Leave a comment


DeskPal Final Documentation




Posted in 09. Final Project Reports | Leave a comment

Final Project: Tri-Color Pendulums

Check out my document, complete with images here:

Check out my video here:

Check out my code here:

What is it?

Tri-Color Pendulums consists of three pendulums: red, green, and blue. As they move toward one another, they share their colors with one another. For instance, as the red and blue pendulums are brought together they approximate purple from opposite ends of the spectrum. This combining works three ways with all of the pendulums, so when all three are brought together they all glow white. Users can interact with the pendulums by moving any of them or knocking. They can then enjoy a fun light show while learning about how colors interact in the RGB color-space .

How does it work

Each joystick contains two potentiometers; one for the x-axis and one for the y-axis. I used the measurements from these top mounted joysticks to determine the relative locations of the lights at the bottom of each pendulum.
I spaced each of the joysticks on a sheet of MDF. Each of the joysticks is spaced such that they make an equilateral triangle. In my code, I assigned each joystick a virtual set of base coordinates: (0,0) red, (0,255) green, and (128, ~221) blue. These coordinates map to the physical distances between them.

Since Each pendulum is a little more than 2 feet long and the joysticks can bend approximately 30 degrees from center, I made sure to space the joysticks a minimum of two feet apart to avoid collisions.

I mapped the values coming in from the potentiometers such that when resting they were at 0 and moving full up was +128 and full down was -128, moving full left was -128 and full right was +128. I then added the value from each potentiometer to its base coordinates to determine its position. Once I had these values, I used the distance formula to determine the distance between each of the lights’ current positions. I subtracted that value from 255 (so closer results in brighter) and used that as the output for the LEDs. I kept the primary color for each light constant and varied the other two. For example the RGB values for the red light are always (255, XXX, XXX).

Since the code is running through this input and output process so fast, the lights appear to fluidly change colors as they interact with one another.


Arduino Mega
3x: 2-Axis Joystick: Adafruit (Parallax ID: 245)
3x: RGB LED: Sparkfun (sku: COM-00105 )
3x: 330 Ohm resistor (for blue and green LEDs)
6x:150 Ohm resistor (for red LEDs)
A lot of hookup wire
Solder (and soldering iron)

MDF Sheet (substitute ceiling)
Wood beams (support legs)
Acrylic Mounts (for Joysticks)
Hot Glue
3x: 1 inch diameter x 2 foot PVC pipe
3x: light bulbs
6x: 1 inch diameter coupling (to interface with bulbs and joysticks)


Take 3 lightbulbs and carefully hollow them out, removing the filament and other guts inside. Spray them white so the light in them will be diffuse..

Use epoxy to attach each of them to the inside of a pvc couple. This creates a removable light housing.

take the thumbpads off of the joysticks and use epoxy to attach each of them leveled to the inside of a pvc couple as well. This allows for easy disassembly, storage, and transportation. Now drill a bout a 1/4 inch hole in these coupled to allow for the wires to the LEDs.

Solder the LEDs’ leads to resistors and then to wires at least 3 feet in length. Run the wires through the pvc pipe so the led hangs below the pipe by an inch or two and attach the bulb,couple over it. Run the wires up and through the hole at the top couple that is attached to the thumb pad.

Take a piece of MDF or similar material and cut three holes for the joysticks to hang through. Space them along points of an equilateral triangle with sides of about 28 or so inches You can cut these exact or leave room for a custom mount like I made by laser cutting acrylic to fit the joysticks. Hot glue the joysticks to the mounts and the mounts to the holes. drill 1/4 inch holes next to each mount for the LEDs’ wires to continue through.

Epoxy the pendulum assemblies to the joysticks, reattaching the thumb pads.

Construct an assembly to hold the entire thing above the ground.

Wire it up, add the code, and enjoy!

Posted in 09. Final Project Reports | 2 Comments

A few things

Here are a few things I never got around to posting:


For my miniproject i hooked up a scale to my arduino to read in its values. My goal was to create a medication tracking device that based on weight could tell which bottle had been picked up and then how many pills had been removed. Unfortunately, even with amplification with an op-amp and exploration with a wheatstone bridge, I was not able to get precise enough measurement out of the sensor to work with.

here’s a video of what did work:

here’s the code:


Posted in 05. DC Motor and H-bridge, 07. Mini-Project | Leave a comment

Final Project | The Smart Christmas Tree

The Vision

How can I make Christmas more fun and interactive by using knowledge I gained this semester?  This was my core vision that drove both my Mini Project and my Final Project.

The Mini was an initial exploration of how I could bridge the gap between our classroom electronics that are easy to experiment with and electronics found in the home, which are self-contained and have been somewhat of a mystery to me.  The Final was an extension of this exploration, in which I added functionality and tried to end up with a more polished product.

Throughout this process I have been interested in what it took to transform something like what we do in class to something that is sold on the mainstream market.  At the same time I wanted to end the semester with a final product that was functional and fun, and with a concept that could be clearly communicated to family and friends who aren’t familiar with electronics.

I concluded that a good way to do this would be to create a “Smart Christmas Tree” for the season.  Specifically, the lights on this tree can sense the noise level in the room, and different tiers of lights on the tree turn on and off depending on how much noise is generated in the room.    If the room is silent, the tree is off.  With a small amount of sound, the bottom third of the tree lights up, the middle third with more sound, and the top third with a lot of sound.  In this way, the tree serves as an ambient gauge of social interaction.  The more lively the conversation, the more the tree lights up.  Therefore, a lit tree is a sign of a good time.

Vision Scenario

It’s Christmas time and you’re having your family at your house this year.  The living room slowly fills up as family arrives throughout the evening, and the conversation steadily picks up.  The lights on the Christmas tree, once off, now sparkle and flash as family members crack jokes, tell stories, and children play with their new toys.  Once everyone arrives, the songbooks are passed around the group and people start singing Christmas carols.  You smile as you see the Christmas lights, which you designed and built, shimmer with the ebb and flow of the music.




1 small Christmas tree (one foot in height)

3 strings of battery powered LED Christmas lights

Arduino Duemilanove

Arduino Blink sketch

3 5-volt DC relays, which allow the Arduino to control the lights

Arduino protoshield with breadboard

10 inches of heat shrink tubing

Soldering iron


Wire strippers


(each LED represents one string of lights)

BreadBoard Diagram

(each LED represents one string of lights)

The Build

The Mini Project provided me a number of useful learning experiences that allowed many steps in the Final Project’s construction to go more smoothly.  However, I did run into several challenges, which are described in the next section.  The steps below explain how to successfully construct a sound sensing Christmas tree of your own.

1. Take one string of lights, and use wire cutters to cut one of the wires.  It doesn’t matter which wire because there is one circuit, and wherever you cut it, the circuit is broken.  Since I had battery-powered lights, I made my cut before the first LED about 3 inches away from the battery pack.

2. Strip one of the cut ends of the Christmas tree light wire, leaving about 1/2 inch of metal exposed.

3. Take about 6 inches of wire that can be connected to the breadboard and strip it, leaving about 1/2 inch of metal wire exposed.

4. Intertwine the breadboard wire from step 3 and the Christmas tree light wire from step 2.

5. Now solder the two intertwined wires together, making sure to cover all contact points along the wires to ensure the connection will be secure.

6. Cut about 1 inch of heat shrink tubing and position it over the intertwined wires.

7. Using a lighter, heat the shrink tubing at the base of the flame so it firmly encloses the intertwined wires and does not char the tubing.

8. Repeat steps 2-7 for the other end of the exposed Christmas light wire.

9. Repeat steps 1-8 for the other two strings of Christmas lights

10. Wire the breadboard (see schematic below)

11. Upload Arduino sketch

12. Wrap tree lights around Christmas tree.  Make sure to concentrate each string of lights around different thirds of the tree to get a more pronounced effect (e.g. wrap the first string around the bottom of the tree, the second around the middle, and the third around the top).

13. For each string of lights, connect each end of the wires to each end of the relay, making sure they are fully connected (safety first!)

14. Turn on the battery packs for each string of lights.

15. Run the Processing code and enjoy!

The Code

Arduino Code

Processing Code


Similar to the Mini Project, my biggest challenge revolved around the functioning of the relay.  For some strange reason that I still don’t understand, the relay worked properly for the Mini Project, but this was not the case for the Final Project.  Using exactly the same components, I was getting different results.  The lights worked fine initially, but after about two or three seconds, the relay would get stuck in one state.  Every time I reset the connection, it worked properly again, but would always get stuck again.

I investigated the problem using a multimeter and discovered that 2.5 amps of current were flowing through the lights.  However, the relay could only handle a current of 0.5 amps. Therefore I must have miscalculated the size of the relay I had needed for the Mini Project, but at the time of the  Mini Project demo it mysteriously worked anyway.

To solve the problem, I bought a larger relay that could handle up to 10 amps (I wanted to be safe).  However I could not get this relay working properly either.  It was supposed to run off of 9 volts, but even when I tried 32 volts (using a printer cable power cord), the relay was not switching.

Finally I bought LED lights, which run at a lower amperage than standard Christmas lights.  Fortunately the original relay I had used previously now worked!

Another challenge I had was getting the Bluetooth working, which unfortunately I was unsuccessful at.  I initially wanted the lights to be controlled wirelessly through XBee so that a laptop would not have to be near the base of the tree.  However, XBee proved too difficult to calibrate, and so I switched to Bluetooth.  I soldered headers to the protoshield and the Bluetooth device, but was unable to successfully establish a connection.  Unfortunately I did not give myself more time to troubleshoot the Bluetooth problems, and so I had to work with what I had for the demonstration day.


I am happy that I was able to use what I learned in the Mini Project and expand upon it to create a truly interactive piece.  Since the Mini Project just used the Blink code, it wasn’t really interactive (other than going into the code and changing the length of time the lights stay on).  However, using sound input to control the lights of the tree proved to be a very effective type of interaction for this application.

I was also relieved that I could successfully troubleshoot the problems I had with the relay to get my project working properly in time for the demo.  This experience gave me a valuable lesson in electronics and programming—that things always take longer to than you think they should, and as a result, plan accordingly!

Posted in 09. Final Project Reports | 2 Comments

Meet MEmote! by Aubrey Shick

Meet MEmote!
a DIY (Do it Yourself) robot aspiring to help children with Autism recognize and express emotion.  (The project is a preliminary exploration executed over a few weeks and will continue to be developed and researched.)
MEmote is an affective mobile robot that will also accept remote control signals to effect it’s behavior and emotional state.  Emotional state is represented by a coordinated language of light, movement/gesture (and eventually sound). This affective display allows the robot to communicate its current status* and intent* to viewers.

*status = angry, sad/scared, curious/confused, happy
*intent = to attack, to be alone/escape, to discover, and to play (dance)

The robot assumes a natural disposition or emotional predisposition as a function of the ambient light in the room and its sensed proximity from others and objects.   The emotional state is governed by a set of rules that allow it to react to its environment in an emotionally representative pattern.  The environment is represented by a combination of the robot’s proximity to objects and the light levels in the room.  The child will have a light wand that the robot will follow, thereby making the child most likely be next to the robot.  The robot will wonder towards the brightest point in the room until it is close enough to sense a presence.  Once the robot senses a presence, it will stop at a safe distance and bounce persistently.  When the child steps into the robot’s personal space, the robot will run backwards to avoid being stepped on.  Once the child is out of the robot’s sensing range it will continue to follow the direction of the light.  Light levels work in combination with the proximity sensor on the robot to determine the mood of the robot.  The mood is represented by combinations of gesture, movement and light-color to represent 4 possible emotional states.
The emotional states govern the way the robot will behave in relation to the light levels in the room and proximity the robot is to objects (or hopefully children).  The robot will always follow the brightest point of light in the room, but when it senses really bright light or “light in it’s eyes” it will become angry and when it senses the darkest light it has ever seen, it will become sad.  Though out the ambient light level  or “when the light is not in his eyes” her wavers between happy and curious depending on whether he detects a presence.  When he is in ambient light and detects a presence he is happy/ Excited, glows green light.  When he does not detect a presence however he is curious and glows yellow wandering near objects at a safe distance.  If it becomes very dark and becomes too close to something it will become “scared/sad ” and glow blue while running backwards.  There is a total of nine possible behavior combinations.

MEmote version 1:

The Future of MEmote
The next generation of MEmote will include a controller that will be combined with the light wand. When a child engages with the controller she or he may override the robot’s assumed emotion and chose the emotional state they would like to communicate.  The controller will have a button pad with iconographic faces and an color-changing light (RGB LED) that takes on the color of whatever mood the robot is expressing.

The robot will maintain that mood  in spite of the levels of sensed presence and light levels until the controller is no longer being used and MEmote returns back to autopilot.  He will still however follow the brightest point of light.  Once the remote is no longer being played with the robot will cycle back through the emotions to the self-governed state.  For example if the child leaves it on mad and then stops playing with it… it will slowly become sad, then curious, happy and return to autopilot.

How is MEmote made?
This robot and controller are constructed out of laser-cut snap-together (at this point slide together) acrylic, electronic components including and Arduino and fabric or fur.
The platform drawings, wiring diagrams, and Arduino code are all freely available online.  You can customize your robot to fit your personal needs with your own choice of motors, wheels, and sensors.

Inside of MEmote…

How does MEmote work?
How does MEmote see light?
He calibrates to the light levels of the specific room. MEmote always starts off mad because the the only light he has seen so far is also the brightest light he has seen.  By shining a brighter light such as a light wand directly on the light sensor (photoresistor) on his head he will then recognize the ambient light as the medium light level.  If you then cover his head or shut off the light he will recognize the minimum light level.  MEmote divides sensed light into three possible levels: max bright, medium light  and minimum light.  He then choses his behavior based on which of these three levels he senses.

How does MEmote follow light?
He follows the light by using two light sensors on the right and left of his body to control the motors steer the wheels.  Each light sensor is associated with the wheel on the opposite side of the body.  For example, if the light sensor on the left senses the most light the motor on the right will go faster thereby steering the robot towards the left.  This method allows the robot to always drive towards the brightest light in the room which is likely to be the light wand/controller.

How does MEmote know when I’m close?
MEmote senses presence by using an infrared (IR) range finder.  The range finder shines IR light in front of the robot and is able to gauge whether something or someone is in front of him by the amount of IR that is reflected back.  When MEmote senses a presence he will stop and bob, but when you get to close, and he senses brighter IR levels, he will run backwards.

How does MEmote move?
MEmote bobs by using servos, a special kind of geared motor that will turn to a specific angle rather than at a certain speed.  When he senses changes in presence and light levels the program calls a specific angle and causes the servos between the dome and the base to change angles allowing him to move.  A servo in the dome also changes angles to raise and lower his eyelid and antenna.

Build your own MEmote!
Anyone can build a MEmote by following the directions and using the file resources available online.   Above you will find the pdf files for cutting MEmote out of acrylic, the code you will need for his behaviors, electrical schematics and material list.
Wiring Diagram
Arduino Code
Materials List

You will need…
Soldering iron
wire cutters
wire strippers
heat gun

MEmote cut-out pieces
2.5″ x 4″ cardboard eyelid
4 sticks of hot glue
Electrical tape
4 6″ zip ties
4 – 4″ x 3/8″ round aluminum tubes
2 – 6″ x 1/4″ round aluminum tubes
2 – 1.5″ x 1/4″ round aluminum tubes
2 wheels
2 – 4″ angle iron with holes
2- rubber bands for wheels
10 – 3/16″ bolts and matching nuts

10″ – 12-strand ribbon cable
20″ – 30 AWG solid core wire
4 colors  x 48″ each of 30 AWG stranded wire (RGB LEDs)
6 – 2 pin (button, motors, photoresistors) 100 mil Molex connector housings
2 – 4 pin (RGB LEDs)  (2-5 pin) – 100 mil Molex connector housings
20 – female header pins
32 – brake-away vertical 100 mil headers
6 – 220 ohm resistors
3 – 1K  resistors
2 – RGB LEDs
2 – .01uF capacitors
2 – 6v DC gear motors
H-bridge IC
3 – photo resistors
Extended range finder
3 – HS-425BB servos  –
9v battery holder
9v battery
4 AA battery holder
4 – AA batteries
DPST Switch
2 x 10″ – 3/8″ shrink tubing (cover antenna)
8 x 1/2″ of 1/16″ shrink tubing (RGB LED leads)

*Since MEmote is a mobile robot and will be subject to a great deal of vibration which may shake wires on a breadboard loose, we suggest moving directly to a Protoboard.  For less experienced individuals you may plug the wires into the breadboard instead, but the robot will be more likely to malfunction.

1. The board
Assemble protoboard according to schematic provided.  Solder headers to one end of ribbon cable.  Crimp pins to opposite end to allow connection from protoboard to Arduino.

Solder on H-Bridge, resistors, and header pins onto protoboard. Make connections between components according to schematic.

2. Sensors
Solder extension wires onto the RGB LEDs, photocells and motors.  The four prongs of the RGB LEDs will need to be soldered with flux and very 30 AWG stranded wire so that they will fit in the aluminum tubes.  Use a different colored wire for each prong.  Heat shrink over each individual LED pin to prevent shorting.  Slide wires into 1/4″ aluminum tube.  Heat shrink over the tube leaving the LED exposed.
For each item crimp on connector pins and slide on connectors.  Solder capacitor to motors.

3. Button and Batteries
Solder the switch such that one pole goes between the 9V battery and Vin on the Arduino and the other pole goes between the AA battery back and motor power on the protoboard.
(See schematic).

4. Assemble the base
Assemble the base of the robot by placing the two large oval pieces together.

Mount wheels to motors against angle iron.  Bolt angle iron to the base of the robot.
Velcro Arduino, protoboard and batteries to the base.  Hot glue button in slot.

5. Attaching the servos and range finder
Drill two 3/16″ holes t in your servo arms.  Bolt servo arms to the linkages then attach servo arms to servo with screwdriver.  Zip-tie servo to base laying flat with the arm towards the center edge of the robot.  Drop photocells and range finder into slots.  Zip-tie range finger and use electrical tape on the photocells.

6. Building the dome of the robot.
Slide ribs into the base of the dome.  Bolt antenna and eye elbow to servo.  Zip-tie servo to center plank.  Snap in eye and attach eyelid to elbow on servo.  Hot glue antenna inside of servo antenna arm.  Use electrical tape to affix photoresist to the top of the dome.  Run wires for servos, LEDs and photocell down the inside of the dome towards base.

7. Connecting the dome of the robot
Use 3/8″ aluminum tubes as axils for the linkages between the dome and the base.  Connect the linkage from the dome to the linkage bolted to the servo.

8. Connecting it all
Run all wires into the base, leaving slack in the wires to the top so that the head can bob freely.  Plug the connectors into the corresponding head pins on the protoboard.

9. Upload code

10. Set robot on the floor before turning it on!

The Process of Designing MEmote
MEmote was a long process of cutting out pieces, putting them together, and taking them apart again.
I built and rebuilt MEmote with Xacto blades and a laser cutter at least 8 times.
<Pictures of cardboard, foam core and acrylic physical iterations>

Before there was MEmote… prior work
<Background and Prior art>

Creator Comments …Things to change
MEmote was initially held together mostly with zip-ties, hot glue and tape.  The latest iteration has since been bolted together.  The linkages are much stronger with the bolts and the robot is able to move much more smoothly

The dome was off balance due to the servo.  To resolve this I taped batteries on the other side of the head to balance it.  In the future I may use two servos and make two eyes so that it is more human-like.

The slide-together joints needed to be held together with hot glue.  To resolve this in the future I will include snap-together joints.

Acrylic may not be the best material for a toy robot.  It is prone to cracking and does not hold up well to abuse by children.  In the future I think I may use sheets of ABS plastic.

Currently MEmote can only run a few minutes before the motors stop responding, but you shut him off for a few minutes and turn him on again he works great.  It is possible that the H-bridge is overheating.

While MEmote was inspired by the recent influx of robots for children with autism, deeper research reveals that while he is going in the right direction he is missing some critical considerations.  MEmote is not very anthropomorphic.  It would be better for him to have more human-mapped features by which the child could learn to recognize emotion.  MEmote would also benefit from responding to appropriate interactions.  For example if he were sad and the child went over and pet him, he would become happy again.  MEmote would probably also gain a great deal from sound.

While there are many ways that MEmote could be improved upon it is important to keep in consideration that he was conceived and built in a few weeks.  The project will continue to be developed with future research.

Thanks to:
Cornell Wright and Steven Brudenell.  There is no way I could have gotten MEmote working so quickly without their help!

Posted in 09. Final Project Reports, Uncategorized | Leave a comment

Final Project | Floating Lights Out

What Is It?

Floating Lights Out is a lights out game that has a special way to save patterns of lights onto physical objects containing RFID tags. It lets players enjoy the game and then save and share their favorite challenges with others.

I conceived this project as a way to continue exploring the use of RFID, and to develop something that would express my interest in the ways that physical objects can contain hidden or invisible information. I wanted to make something that, while it worked simply as an enjoyable game or experience, also hinted at the way that we associate memories and other thoughts with objects in the physical world. Floating Lights Out attempts to accomplish this by taking seemingly disparate objects with embedded RFID tags and giving them all the same function, saving patterns of lights to restore later. By creating a context where the normal functions of these objects are not pertinent, I wanted to let people focus instead on seeing the objects as items that record some sensory “memory,” in this case, one of lights.

In action


  1. 1 ID-20 RFID Reader
  2. 1 RFID Reader Breakout board
  3. As needed, RFID Tag – 125kHz
  4. As needed, RFID Glass Capsule – 125kHz
  5. As needed, RFID Button – 16mm
  6. 1 Button Pad 4×4 – Breakout PCB
  7. 1 Button Pad 4×4 – LED Compatible
  8. 16 Diode Small Signal – 1N4148
  9. 16 Red LEDs
  10. 2 Break Away Female Headers
  11. 2 Break Away Headers – Straight
  12. Plenty of Hookup Wire
  13. Lots of cardboard/acrylic/body material of choice
  14. Items to attach RFID tags to.


The Code

Code for the lights out game is here.
I was not able to get RFID reading to work how I wanted it to. The code I was working on modifying came from this blog. The goal was to save the current board state the first time a new RFID tag is seen, and to restore it, replacing the current board state, the next time the object is seen.

The Making

Making Documentation

Posted in 09. Final Project Reports | Leave a comment

06. Mechanisms and Movement

My attempts at creating a working, combined mechanism were… not so successful. I created two mechanisms that worked on their own (see video), but because my initial plan with cardboard didn’t work. I hadn’t realized how difficult cardboard is to use in the way I was trying.

While staying up pretty late the night before it was due, I had jumped around to different solutions realizing later that I didn’t really have a plan after the first idea didn’t work as expected. In the end I succeeded in constructing two mechanisms but didn’t get them working together. Lots of lessons learned on this assignment which I eagerly applied to my midterm project (RGB Glove). Biggest takeaways: planning and research 🙂

Posted in 06. Mechanisms and Movement | Leave a comment

Reversed Scanner Project


The objective for this project was to create a device that could print graphical elements into a surface that had the ability to erase itself.

To do this, I explored the potential of a photochomatic ink. This special kind of ink, also found in sun glasses, has the ability to change color when exposed to UV light. In my case, it is blue when UV light is present, and while when it is not. The speed at which the effect dissipates depends on the color. Mine is blue and it fades away in about 2 or 3 seconds.

In order to print on this surface, a scanner was used because of its sliding arm. It allowed me to replace the regular light with a strip of 32 UV LEDs. These in conjucton with the sliding arm allow the scanner to print a 32×40 pixel image in an area of about 16 square inches. This is very low resolution but it is perfect for a prof of concept.

What i used to built it

1 Scanner, with a working stepper motor
1 Arduino Duemilanove or Uno with a prototyping sheild
2 TLC5950
1 SN754410
1 7805 Voltage Regulator
1 Power Supply, 12V capable of more than 1A
32 UV LEDs
2 100nF Capacitors (ceramic)
2 Electrolytic capacitors bigger than 100uF
2 1k resistors
2 10k resistors

The circuit

The surface

The UV reactive surfaces were created by spreading the UV reactive power on adherent film. This film is stiky on one side and not on the other. This allowed me to cover the adheret side of two films and them glue them together so that the adherent part faces the middle. This traps all of the power inside.

This ink can be sold here:

How it works

A processing program was created so that images could be captured using the computer’s webcam. Doing it this way avoids the extra work of creating a system for the arduino to capture the image, process it and save it.

All the image process is done by the computer. It captures the image, converts it to a 32×40 pixel image, then converts every pixel to black and white and only then sends them to the arduino using serial.

The arduino receives these values and interprets them as white, gray and black. These are the three levels of the UV LEDs: no power, half power, full power. The reason why this was made this way was because the UV paper fades away too fast. If the whole scale was used it would disappear before we could perceive it.

To test if the concept was working I created two cards with high contrast images drawn on them. One with a smile =) and another with a uppercase F.

It is very hard to capture this with a camera but if the camera is set for long exposures, you get something like this image.

Demo of it working


This technology could be improved to create a new kind of paper. If the ink lasted a day and the printing resolution was much much higher, people could print their newspapers using this kind of technology, reusing always the same sheet.


Arduino Code

Processing Code

Some Images

Posted in 09. Final Project Reports | Leave a comment

09. Remote Temperature and Humidity Sensor for new parents

The purpose of this project is to allow parents to remotely check both the temperature of their baby and the humidity of the diaper. I used wearable Lilypad technology sewn into a baby blanket.

Figure 1 – Electronics in the banket

Figure 2 – Sensors

Figure 3 – Sensors in baby clothes

I used two sensors: a temperature sensor and a humidity sensor. The temperature sensor will be placed in the baby’s clothes, and the humidity sensor in the diaper.

1.Humidity Sensor
This sensor detects humidity in any piece of cloth. The circuit I used amplifies the currents that goes between two small metal pieces (see figure 3 – 6 humidity sensor)

It used one of the analog ports of the Arduino to read the values (from 0 to 1024) .The sensitivity can be adjusted in the code. I used 10 as being my threshold value: whenever the sensor reads a higher value than 10 it will alert that it is time to change the diaper.

The circuit is composed by one transistor and two resistors. In order to be able to sew the electronics into the blanket, I made a PCB “lilypad style” (see figure 1-2 – humidity sensor), using the method described on Paulo Coelho’s web site.

2.Temperature Sensor
For reading temperature, I used a small temperature sensor that was designed to be wearable (description here). It detects physical touch based on body heat and ambient conditions. This sensor outputs 0.5V at 0 C, 0.75V at 25 C, and 10mV per degree C.  I found out that it has a slow response; it takes more than 2 minutes to read the temperature of the skin. (see figure 2-5 – temperature sensor)

I chose to use the Bluetooth Mate (description here) which was designed specifically to be used with the LilyPad Arduino.(see figure 3- 4 Bluetooth)

4.Computer Interface
I used Processing to build the computer interface.
The temperature value is always displayed on the monitor.
For humidity, there are two different screens:  when the diaper is dry it displays screen 1; when it is wet it displays screen 2.

Screen 1 – Dry Diaper                                  Screen 2 – Wet Diaper



Posted in 09. Final Project Reports | 4 Comments