Technical Overview
The installation was powered with 4 QProx QT113 Proximity sensors attached to a plate of spaghetti, a stuffed Goofy doll, a cup of tea and a photograph in frame. When a visitor touched any of these objects, the QT113 sent a signal to a microcontroller--the BX-24--which in turn passed serial 1 Byte messages seperately to each of two computers, a Mac G4 and an IBM laptop. These two computers were each running a virtually identitical Director file (Lingo) and were each connected to an InFocus video projector. When they received a message from the BX-24 saying that a particular object had been touched, the Director files displayed the relevant media associated with the object--one of four video files on the Mac and one of four text files on the PC. Projections, then, appeared on two walls--as if, from the visitors' standpoint, in direct response to their touch.
Description of Proximity Technology
The QT113 Proximity Sensor, manufactured by QProx detects changes in environmental capacitance. Think of this as the environmental electrical field. Any increase in area capacitance beyond a certain level will activate the QT 113 sensor. You can read in detail about the sensor here.
Since humans are capacitors (remember The Matrix in which machines use humans as batteries?), a human can set off the QT113 by approaching or touching its sensor wire. Increase the capacitance of the sense vector (think of this as making the sensor wire longer or thicker) and you will also increase the sensitivity of the QT113. With this in mind, I attached a QT113 sensor wire to the bottom of a ceramic (yes, a capacitor) plate of spaghetti. This proved somewhat sensitive to the touch of a human--but not enough. The human had to pick up the plate and hold it before the sensor was activated, so to increase sensitivity I taped a sheet of copper mesh to the bottom of the plate. That done, the sensor was activated with only a light touch to the plate. I then attached QT113s and sensor wires to a stuffed Goofy Doll which I stuffed with copper mesh, to the bottom of a cup of tea (the liquid tea, a capacitor, made the cup sensitive enough for my purposes) and to a metal photograph frame.
What Happens When the Sensor Is Activated?
The QT 113 sensor sends a steady stream of +5V to the microcontroller. When activated, it actually switches this signal to Ground! So I programmed the BX-24 to listen for a change from a positive signal to ground.
How Sensitive Is It?
The QT113 is very cantankerous. Capacitance is an art, not a science. Environmental factors (say, a nearby elevator or light or someone playing a radio) will change the area capacitance and cause the QT113 to become more sensitive. You can stablize the device and make it less sensitive to fluctuation by using capacitors (see diagram) in the circuit and by putting the various control pins to ground. Alternatively, you can make it more sensitive to fluctuation by putting the option pins to various combinations of ground and +5V. See the QProx site for details.
A major obstacle: A long sensor wire makes the QT113 insanely sensitive. Further, when close to each other the QT113s have a tendency to set each other off. To combat this, I wired each sensor into its own circuit and kept that close to the object (spaghetti plate, etc.) so that the sensor wire would be short.
The last bit of work I did to stablize my readings was on the Director end. I read data coming from the BX into a 20 cell array and averaged out the readings, to eliminate abrupt fluctuations. For example, typically, the sensor--if not active--would send a stream of 1s, interrupted periodically, by 0s: 1,1,1,1,1,0,0,0,1,1,1,1,0,1,1, etc. So that these "false" 0 readings were not interpretted by my code as someone actually touching a sensor, I would take 20 readings and add them up. Remember: a 0 = sensor active, and a 1 = sensor not active. If the readings remained greater than, say, 8 (yes, 8 out of 20!), my code acted as if the sensor had not been touched. If a visitor touched the sensor, readings would typically look like this: 0,0,0,0,0,0,0,0,0,0,1,0,0,0,0. So as you can see were much more stable. This is why I skewed toward insensitivity to 0 readings. The only downside: it takes a seconds for 20 readings to work their way from the QT113 to the Director code, causing a slight reaction delay. For my purposes, this was OK.
The BX-24
The BX-24 did its standard job of receiving +5V and ground signals from the four sensors. Each was wired into its own pin. Every micro-fraction of a second the BX-24 would check the four pins with their individual signal wires running from a particular QProx and see what sort of signal was coming through--either 5V or ground. Without really processing this information, the BX-24 would then relay a status message directly out its serial connections to the Mac and PC, letting both machines know the most recent set of signals it had received. It would send four bytes out at once, in the same order--one for each QT113 signal. The Director files running on the Mac and PC were then looking to receive these Bytes in the same order, knowing the first byte received pertained to the Spaghetti sensor, etc.
The only trick here was that the BX-24 did not relay a simple 1 or 0 conforming to the signal it had received. In fact, at the time I wrote my program the SerialXtra for Director, from PhysicalBits.com, which enabled my Dir file to talk to the BX-24, had some bugs. One was that it did not enable Director to send a Byte back and I could not do any sort of call-response. Instead, on the BX-24 side I encoded each byte so that even if the Byte order became incorrect, the Director side would have no trouble sorting things out.
The encoding method was simple. If the BX-24 received a 5V signal from the Spaghetti sensor it would send, instead of a 1, the number 25. If it received, a ground signal it would send, instead of a 0, a 26. Goofy, teacup and photograph sensors each had their own special numbers. If the Dir file as it read in the Bytes was expecting a Spaghetti Byte (either 25 or 26) but instead received, say, a 35, it knew to ignore that Byte and requery the BX-24 until it got what it was looking for. For extra security, whenever Bytes in the wrong order were detected, my Dir file flushed the serial buffer and started reading a fresh batch of Bytes. It worked beautifully!
Useful Stuff
