The mouse is my spirit animal.

The house mouse, or mus musculus, is nervous.  She needs to be.  She’s prey for almost every other animal out there.  She isn’t very competitive, but is one of the most successful animals none the less.

Mice are shy and docile, but also playful and curious.  They build intricate burrows and live in colonies.  They live in cooperative colonies mostly dominated by females (does).  Does take turns nursing each other’s young, even if they’re unrelated.  Mice love their sisters and moms and keep warm by snuggling  together.

It should also be noted that I feel that I may be a mouse’s spirit animal too.


Hive 240 by Yin Liu, Michael Uzzi, Chris Egervary, and Alex Olivier

Constructing the Hive

We talked about several construction methods/materials including wood, acrylic, etc..  In the end, we settled on using light-weight materials that would be easy to mount on the wall in the lobby of 240 Central Park South.  To maximize reconfigurability, we decided to create “mini-hives” of three honeycombs, which we could then attach together on the wall.  Chris CNCed blue foam bases that could accommodate a hexagonal piece of acrylic while still providing some room for electronics in back.  He also CNCed some nice wooded frames to fit over the front of the honeycombs.

 Yin and I lasercut acrylic pieces of various colors (white, frosted) to give the hive a bit more organic, less uniform look.  We also cut pieces of orange acetate to fit over the acrylic.



Yin and I also lasercut foam core backs to fit over each of the units, with a small hole to fit an LED.  We assembled all of the pieces using wood glue!

Lastly, we wirewrapped white LEDs to header pins so that we could plug them into our breadboard later.  Things got a little messy…


Coding the Hive

To program the behavior of our hive, we had to do a few different things.  First, we had to somehow get data from our iDigi data stream (which comes in XML format) and extract out the relevant bits.  I modified another XML parser to allow our Arduino to extract important data points.  

We also needed to control the animation of our LEDs.  We used TLC 5940 LED drivers (wired according to the datasheet), which have PWM control.  Below is the code for the entire installation:

// Get XML formatted data from the XIG. Use it to control LED Driver.
// Original Code from Bob S.
// Modified by Alex Olivier, 12/12/2012.

// Include description files for other libraries used (if any)
#include <string.h>
#include “Tlc5940.h”
#include “tlc_fades.h”


// Define Constants
// Max string length may have to be adjusted depending on data to be extracted
#define MAX_STRING_LEN 40

// Setup vars
char tagStr[MAX_STRING_LEN] = “”;
char dataStr[MAX_STRING_LEN] = “”;
char tmpStr[MAX_STRING_LEN] = “”;
char endTag[3] = {‘<‘, ‘/’, ”};
int len;
boolean getData = false;

// Flags to differentiate XML tags from document elements (ie. data)
boolean tagFlag = false;
boolean dataFlag = false;
unsigned long time;

//for leds
uint16_t duration =2000; //default LED speed

void setup()
Tlc.init(); //initialize LED Driver code
time = 0;


void loop() {

if ((millis() – time > 30000)|| time == 0){ // sample every 30 s
time = millis();

// code for controlling LEDs
if (tlc_fadeBufferSize < TLC_FADE_BUFFER_LENGTH – 2) {
if (!tlc_isFading(channel)) {
int maxValue = 4095;
uint32_t startMillis = millis() + 50;
uint32_t endMillis = startMillis + duration;
tlc_addFade(channel, 0, maxValue, startMillis, endMillis);
tlc_addFade(channel, maxValue, 0, endMillis, endMillis + duration);
if (channel++ == NUM_TLCS * 16) {
channel = 0;

// Process each char from web
void serialEvent() {
while (Serial.available()) {

// Read a char
char inChar = Serial.read();

if (inChar == ‘<‘) { // a tag is starting

if (getData == true){ // if we’re done getting the data chars
getData = false;
double dataNum = atof(dataStr); // convert chars to a double

// map sound data to LED animation speed
int clippedData = constrain(dataNum, 400, 800);
int lightDelay = map(clippedData, 400,800, 1000, 7000);
duration = lightDelay;;
clearStr(dataStr); // flush out data string


addChar2(inChar, tmpStr); // if it’s not data, start adding the chars to the other string
tagFlag = true;

}else if (inChar == ‘>’) { // we’re done with this tag

addChar2(inChar, tmpStr);
tagFlag = false;

if (strcmp(tmpStr, “<data>”)==0){ // is it a data tag
getData = true; // get data until the next < tag.

}else if (tagFlag == true){
addChar2(inChar, tmpStr);

}else if (getData == true){
addChar2(inChar, dataStr);

// Other Functions //

// Function to clear a string
void clearStr (char* str) {
int len = strlen(str);
for (int c = 0; c < len; c++) {
str[c] = 0;

//Function to add a char to a string and check its length (Alex version)
void addChar2 (char ch, char* str){

str[strlen(str)] = ch;

// Function to check the current tag for a specific string
boolean matchTag (char* searchTag) {
if ( strcmp(tagStr, searchTag) == 0 ) {
return true;
} else {
return false;

Installing the Hive

Luckily, we were able to install brackets on the walls of the lobby hallway.  Our piece was very light, so it wasn’t terribly tricky to hang out.


Here’s the final piece, notice the laser-engraved label (which also hides our electronics!).


Here’s the hive on the wall:



Video coming soon!


bacon tbone

P1160253 P1160257 P1160260 P1160269 P1160287 P1160308 P1160314 P1160324


For my tech crafts final, I wanted to explore the idea of creating a modular, re-configurable ring oscillator circuit. I made 20 “barnacles”, each with an LED, a MOSFET, and an RC circuit.  These barnacles can be connected together to create larger ring oscillators.

Each circuit was made on a flat wood surface using copper tape.


In the end, my barnacles worked but ideally would be redesigned to be more intuitive.  I found that clipping the barnacles together was too awkward to accomplish the effect that I wanted.  Here’s an example of three hooked together.

For my Tech Crafts class, we were asked to experiment with EL Wire.  Originally, I wanted to make an word necklace with very fine “angelhair” EL Wire (inspired by this neon installation).  Not wanting to wait to order more parts, I decided to make a pillow instead, using some thicker gauge EL Wire I snagged from ITP’s junk shelf.

First step, I had to sew a pillow!  I used a thick black velvet and a sewing machine to sew three sides of my pillow.  I left the fourth side open so that I could secure the electronics and hand sew it closed later.

My EL Wire was already attached to a driver so there was no need to solder to it.  I added some heat shrink tubing at the end of the EL Wire to insulate where it had been trimmed.  I cut a tiny hole in the velvet and pulled the wire through.  I wrote a word on my pillow in chalk and carefully stitched the EL Wire to fit the chalk drawing.

Since I planned on putting this pillow on my bed, I didn’t want to have it on all of the time.  I decided to put a reed switch between a 9 volt battery and the power to the driver.  That way, I could turn the pillow off and on using a magnet.  Because my pillow says “bite”, I made a small felt apple with a magnet inside and attached it to the corner of the pillow.

For some reason, my reed switch occasionally sticks on.  I think it might be temporarily magnetized…but it seems to work well most of the time!  If I had to do this pillow again, I might switch to using fishing line to sew on the EL Wire to make it less visible.


Here‘s a video of the final project!



The Test

My group hoped to create a sensor network as part of our final project in sensitive buildings.  As a first test, we followed the example found in chapter 5 of Wireless Sensor Networks.  We configured two XBees to be routers in AT mode, and one XBee to be a coordinator in API mode.  We also configured our two router XBees to send out analog data from AD02 every 1000 milliseconds.

To test out our wireless setup, we breadboarded each of the router XBees and added a photoresistor (the example uses a temperature sensors, but we had these lying around).  We made sure to incorporate a voltage divider circuit on the photoresistor, as XBees require analog values to be between 0 and 1.2 volts.

We plugged our coordinator XBee into the computer (via an XBee Explorer) and ran the example Processing sketch.  We were able to see data!

We brought our setup to 240 Central Park South to test our range.  We left the coordinator in the conference room and brought the sensor into the lobby hallway on the first floor.  We were definitely able to communicate close to the window, but another router might provide some extra coverage on the ground floor.

The Real Deal

For our final setup, we added an Arduino into the mix since we wanted to do some preprocessing before sending our data to iDigi  Michael breadboarded some op amp + mic circuits to pick up sound data, and attached some great indicator LEDs.  He wrapped it all up in a modified Radioshack project box.

Here’s the inside:



Which fits nicely inside the box (labels by moi!):




Notice that we wrapped the mic in latex to protect it from the elements.  Our plan was to install two microphones in the building, one in the conference room and one in an abandoned apartment building on the second floor (facing Columbus Circle).  We stuck the mic in the conference room out of the window, but decided to keep the other mic inside as there was no good way to protect it from the wind near that particular window.  Here’s a setup in action:



Sending our data to iDigi

Here’s a very simple code example to send data to the XIG/iDigi data stream.  This code is keeping count of the sound spikes above a certain threshold, then sending that data to a data stream entitled “counter”.  Our final version is modified, but this is the basic idea.

/* Code by: Alex Olivier
* Example to send sensor data to XIG

int spike_counter;
int threshold = 542;
int[] names = {”

void setup(){
counter = 0;


void loop(){
// send a counter value every second
int micValue = analogRead(A0);

if (micValue > threshold){
//increment spikes

String name = “spike_counter”;
String units = “spikes”;
String post_message = “idigi_data:names=” + name + “&values=” + counter + “&units=” + units;



And here’s some of the data posted on iDigi:




This week in Understanding Genomes, we were asked to run a pBLAST search on a chicken protein to determine its function and similarity to human proteins.  We watched a tutorial video on the proper way to do a pBLAST search beforehand.  Here is the sequence:

Here’s a model of the chicken protein:
In the video, I learned a few things that were definitely helpful.  First of all, the video recommends to search the “Reference Proteins” database rather than the default “Non-redundant protein sequences” database, which actually contains many redundant sequences.  Secondly, the video explains how to read the “E value” of the resulting search.  We are told that e values on the magnitude of 1e-10 are considered good matches.
I ran a pBLAST on the chicken protein and searched only for human matches.  I got 15 results with a low E value.
The top results was an “interleukin-1 beta proprotein”.  It is a cytokine, or cell-signaling protein, that is produced by macrophages.  It is processed to its active form by capsase 1.  According to the report, this protein helps mediate our body’s inflammatory response, as evidenced by some of the related journal articles.
The highest homo sapien match to our chicken protein shows 73/212 exact amino acid matches and 107/212 similar matches.

Sheiva and I did our ethnography assignment at our classmate Jacki Steiner’s apartment on Wall Street.  We decided to explore how Jacki’s space expresses her personal identity.

Jacki is 25 years old.  She’s originally from Florida, but moved to Providence to attend RISD.

The first thing that struck us about Jacki’s room was how coordinated it seemed.  All furniture (her desk, bed, dresser, and bookshelf) was sleek, modern, and black.  Her linens (bedsheets, a curtain hung to cover her windowed door, etc.) were a deep purple.  She even had a black and purple toned painting of the Manhattan skyline.  The painting was small, clean, and framed in a sleek black frame.  She later informed us that she purchased this painting from a street vendor.

Jacki has a lot of books in her bedroom, which are organized into two main locations.  The makeshift bookshelf on top of her dresser contains many books relating to typography and design.  Jacki went to RISD, so some of these books were from her time spent there.  Her other bookshelf contains a few books for pleasure (books about Batwoman, wolves, etc.) as well as books about sexuality.  Jacki told us about her organizational scheme, but it is also pretty apparent.

Her desk is neat as well, complete with a chair and printer. She has a few trinkets around her room, including a postcard with a schnauzer dressed as a biker and a leather Pirates of the Carribean cuff.  She told us that she has a schnauzer named Mongo at home in Florida.  It seems like Jacki’s trinkets remind her of home.

Jacki’s room appears very adult, with small touches of nostalgia.  It seems like she aspires to live in a somewhat controlled and organized environment as well as present a mature but well-designed exterior.

Pics coming soon!