This is a class is about a big building and the people who live there. Students will conceive and create large scale sensor networks to benefit the tenants of a 28-story, 325-unit landmark building on Central Park South. The property’s owners have invited ITP to develop a variety of prototypes that enhance the livability, ecology and community of their building. Students will learn to use the latest in ZigBee wireless technology to design, build and deploy interactive sensor network systems, with full access to this landmark pre-war apartment complex. We’ll start hands-on, by teaching everything you need to know about wireless networking while developing potential project ideas. During the first part of the class we’ll tour the building to learn about its infrastructure, inhabitants and context. Next, we’ll create fast prototypes that explore your project ideas, installing these proof-of-concepts on site and observing the real-world results. Finally we’ll take what we’ve learned into final projects that have the potential to be deployed at scale and even as sponsored solutions. 240 CPS has been described as, “state-of-the-art green architecture before the term was coined.” Built in 1940, the building’s motto is “Where The Park is Part of the Plan.” A recent renovation has it sporting a ground-floor green roof, various upgrades for energy efficiency and a historically restored facade. We will have full access to any vacant units as well as limited access to several occupied apartments. The owners will also provide us with supervised access to all the building infrastructure from roof to basement including ventilation, plumbing, heating, elevator and energy systems. Students will have the chance to think big and work big with technology to help make this building extraordinary.
with Matt Belanger, Lynn Burke, Margaret McKenna and Doug Thistlethwaite
For the final project in Sensitive Buildings our group installed a small sensor network at 240 Central Park South, and put together a web interface for logging data, and built several prototypes for different applications such as visualization and actuation.
Matt has some very thorough documentation (on fatbits.net/) about putting together our sensor nodes and web interface. The nodes included a Series 2 XBee radio, a TMP-36 temperature sensor, and optionally an HIH-4030 humidity sensor. We installed two units in the apartment of the building’s engineer, Peter Julinszki (thanks Peter!), as well as units in the second-floor conference room and hallway. They logged data via the XBee Internet Gateway that had been set up on the second floor for the purposes of our class to a server program written in Node.js and running on Amazon’s EC2, and visualized using a web front-end featuring real time WebSocket updates.
Further additions to the network might include ambient light sensing, and an RFID-enabled keychain which alerts the system to the presence of an apartment’s occupants. Matt put together a prototype internet-connected lamp, triggered by an RFID reader, which simulated an automated home lighting system that would be designed to automatically turn on the lights in the apartment as needed.
Based on the Romantic Lighting Sensor project from Rob Faludi’s Building Wireless Sensor Networks. The Arduino code can be found in the book.
An XBee set for IO mode reads the value of a photoresistor using an onboard ADC and sends that data to a second XBee connected to an Arduino. Based on the voltage coming through the photoresistor, the Arduino will turn an LED on or off: off if it’s too light or too dark, on if the mood is just right. The second Arduino in the video is being used as a power supply only.
Based on the Simple Sensor Network from Rob Faludi’s Building Wireless Sensor Networks.
Two TMP-36 temperature sensors are each connected to the first input/output pin of an XBee radio, which transmits the ADC data to a third XBee radio set as a coordinator in API mode. The coordinator then sends that information to a Processing sketch via a USB-serial adapter, where it is parsed and displayed.
Rob’s code here.
Based on the XBee Doorbell exercise from Rob Faludi’s Building Wireless Sensor Networks.
Three XBees, two Arduinos, a computer and Amazon’s Simple Notification Service are used to create an “escalating response” doorbell. The first Arduino has a button and three indicator LEDs attached to it. When the button is pressed, serial data is broadcast via the connected XBee to the other XBees in the network and the appropriate indicator light is illuminated. The first two button presses trigger a visual indicator on the second Arduino, the second two button presses trigger an additional auditory indicator. The following button press triggers a Processing sketch, which in turn runs a shell script that sends a text message to my phone via the command-line interface to Amazon’s Simple Notification Service. Additional button presses are not registered until a specified timeout has elapsed.
After setting up the command-line interface to SNS as per the instructions contained in the Readme, a simple shell script which contains the appropriate environment variables is used to send a message (replace all values within < and >):
export JAVA_HOME='<Location of your Java installation>'
export AWS_SNS_HOME='<Location of your SNS CLI tools>'
export AWS_CREDENTIAL_FILE='<Location of your credential file>'
export PATH=<Location of your SNS CLI tools>/bin:$PATH
sns-publish --topic-arn arn:<Your Amazon Resource Name> --message "<Your message>"
XBee radios can function as a basic pipe for serial data; after properly configuring one radio as a coordinator and another as a router / end device (using Digi’s X-CTU configuration program), serial data fed into the RX pin on one radio will be broadcast and received by the other radio, which then spits the data out over the TX pin.
The result is that two computers, each with an XBee radio connected to a USB-to-serial converter (Sparkfun, Adafruit), will be able to open serial terminals and transmit serial data from one computer to another wirelessly.
Lacking two computers (or even two USB-to-serial converters), I connected one of my XBee radios to an Arduino which also had a TMP36 temperature sensor and HIH-4030 humidity sensor connected to its analog pins. I programmed the Arduino to read the data from the two sensors, and once per second write that data to the Arduino’s hardware serial pins (Digital 0 and 1), which were connected to the XBee’s serial pins (RX to TX and TX to RX).
I connected the second XBee radio to my computer using a USB-to-serial converter, and used GNU screen (available by default on OS X And most other GNU/Linux and UNIX OSes) to monitor the serial port. Once the Arduino was powered on, the data began to stream into the terminal.
Most contemporary buildings are already sensitive to one degree or another; either through reactive systems such as a water faucet or light switch, or through cybernetic systems such as heating and air conditioning. In the case of a reactive system, the building is only able to sense when an inhabitant takes a specific action intended to produce the required result.
The cybernetic systems in buildings are closer to what we might imagine when we say sensitive buildings. Air conditioning is a cybernetic system: sensors determine the temperature of the air in a room, and some logic is used to decide whether or not to turn on the AC’s compressor and fan in order to cool that air. The AC has some rudimentary understanding of the environment within the building and can take action to change the aspects of that environment which it understands.
The air conditioners in my apartment are standard window units. When operating in “energy save” mode, the fan turns on at periodic intervals to draw air from the room into the unit, to more accurately determine the temperature in the room, as opposed to the temperature near the window. In more expensive centralized air units the thermostat is separated out from the rest of the mechanism, negating the need for a fan to draw room air into the sensors.
One could conceivably hack a window AC unit to have a similar remote thermostat function. Most window AC units, and mine in particular, have an infrared remote control. In general, they are fairly simple devices, outputting modulated, pulsed bursts of IR light which is interpreted by the receiving device. Much of this functionality can be replicated using an Arduino or other microcontroller. By pairing a temperature sensor with an IR emitter, you can essentially create a separate thermostat for the device, and alleviate the need for “energy saver” mode.
Once the AC is being controlled by an Arduino, however, additional possibilities for increasing the sensitivity of the system are made available. Perception of temperature, for instance, is dependent on humidity, and adding a humidity sensor to the Arduino would allow more intelligent control over the AC. Because the Arduino can keep track of time, schedule-based programming of the AC also becomes possible.
When at home, I leave my keys on a small table by the door so that I don’t misplace them, a side effect of which is that the presence of my keys is a good indicator as to my own presence in the apartment. By putting an RFID tag on my keychain, and connecting a RFID reader to the Arduino, I’d be able to set separate programs for when I was home versus when I was away.
Connecting the Arduino the the cloud creates even more possibilities for intelligent control. A last-minute trip might mean that you log into your web interface and set your ACs to vacation mode. A geofencing application on a mobile phone could alert the AC when the user was nearing their home, and set the temperature so that it was already cool by the time they arrive.
This model could be carried over to virtually all of a building’s systems; by connecting a microcontroller, and especially by having a connection to the internet, we can improve the intelligence of those systems and make them more dynamic. As the complexity of those systems grow, and the connectivity between systems increases, new applications and use patterns will emerge. Over time the spaces we occupy will become increasingly aware of their occupants.