Products of Design hosted to BioCities’ second event in its Transforming Cities Project: Buildings and Agriculture: Soil, Hydroponic or Aeroponic? The standing-room-only crowd listened to experts present and discuss the merits of three different cultivation techniques for growing food in, and on buildings. Guests to the studio were welcomed by Tom Jost, Senior Urban Strategist from Parsons Brinckerhoff, and Department Chair Allan Chochinov. Student Richard Clarkson spoke about the culture of food and agriculture and his explorations into aesthetics, production, consumption and disposal that inspired his final project for Claire Hartten’s Design for Sustainability and Resilience class – a sensuous white food surface entitled Diptable.

Kathleen Bakewell, BioCities’ Executive Director, introduced the evening as an opportunity to examine three forms of building-integrated agriculture and their potential for creating “sitopian” cities. Speakers Marc Oshima (AeroFarms), Laurie Schoeman (Intervention: Green) and Alec Baxt (FarmingUp), debated the three systems of food production, bringing to light several distinctions in growing techniques, economic structures, energy demands, community benefits, and prospects for expansion.

The evening wrapped up with a lively Q&A and warm invitation by faculty member Claire Hartten to engage in a reception centered upon ingredients made from local, seasonal foods. The “ugly vegetables” selection of paradoxically delicious and nutrient-rich snacks was offered on the Diptable. The evening, co-presented with the Green Rabbits, received support from Whole Foods Market, Greenmarkets, Parsons Brinckerhoff and the Urban Green Council. Special thanks to students Gaïa Orain and Zena Pesta for enhancing the reception as an example of social interaction design through their collaborative efforts.

Both alluring object and experimental feast, Diptable debuted last night at the Products of Design studio. This video documents the gestural interactions of hungry guests with a surface that encourages drips and greasy fingers.

Classmates Gaïa Orain, Zena Pesta and Cassandra Michel inspired student Richard Clarkson to create the table as a final project for Claire Hartten’s Design for Sustainability and Resilience class. The class empowers designers to make artifacts that champion sustainable food and agricultural practices, and to generate knowledge and capacity beyond dominant models of production, consumption and disposal. Orain, Pesta and Michel designed scrumptious bundles (dumplings, spanakopita, and handmade fig-brie wraps) as cues for messy snacking.

Italian design strategist and leading sustainability expert Ezio Manzini gave an intimate talk to Products of Design students on Monday, 10 December. His presentation linked design strategy to strategic change by showcasing distributed systems and collaborative models that support resilience.

Ezio Manzini is author of numerous design books, professor of Industrial Design at Milan Polytechnic, and founder of the DESIS (Design for Social Innovation towards Sustainability) network of university-based design labs. Manzini’s research redeems users as surprisingly active, collaborative and inventive stakeholders. Two examples he highlighted were the adoption of community supported agriculture (CSA) in Beijing, and the emergence of digital platforms in suburban London that connect family care. He saw inventive social processes of co-production as an important emerging norm, along with values such as human scale, mutual trust, slowness, complexity and localism.

Taking a moment to address hands-on makers around him, Manzini talked about the empowering new wave of popular enthusiasm for experience, craftsmanship and quality. Quality-of-life has emerged as a primary concern for all, said Manzini, rather than a secondary need that designers merely service. Using the metaphor of an archipelago, Manzini said that this paradigm shift might seem small, but we may be at “the beginning of a new continent,” seeing “the first dry land of a tectonic shift.”

Manzini discovered that resilience emerges from the intentional design of systems that are distributed, rather than merely centralized or decentralized. Citing the Fukushima disaster of 2011, Manzini illustrated the incredible fragility of large, hierarchical systems. Today’s designers promote sustainability as new systems architects, but also as activists or facilitators, who create favorable environments for change when “triggering,” “supporting” and “co-promoting” a “broad wave of social-technical experiments.” Designers can further expand their impact by collaborating with non-design actors to organize grassroots initiatives. He encouraged students to find service model inspiration in small European communities creating economic crisis-era alternatives to market exchange. Manzini closed by offering current students a suite of options for further investigation, from small enterprise incubation to the “maker movement.”

Below is a set of photos from the MFA Products of Design department, designed by Andrea Steele Architects. We love our architects.

“On one hand, ‘Cloud’ is an Arduino-controlled, motion-triggered lightning & thunder performance. On the other, it is a music-activated visualizer and suspended speaker unit.”

For the Making Studio course in the MFA Products of Design program, Richard Clarkson created an engaging combination of electronics and form, simply called “The Cloud”.

Acting as both a semi-immersive lightning experience, or as a speaker with visual feedback, this nightlight/nightspeaker hybrid introduces a new discourse for what a nightlight could be. Richard writes: “Advances in physical computing and interaction design hardware over recent years have created a new breed of smartobjects, which are gaining more and more traction in the design world. These smartobjects have the potential to be far more interactive and immersive than ever before. And what is exciting is that it’s becoming increasingly easier and cheaper to become a part of this new kind of making, with DIY and hacker community initiatives such as Maker Faire, Instrutactables and numerous others. This project aims to capture the essence of this kind of designing—where ideas and process are shared for others to use and expand upon.”

(Be sure to watch to the end of the quick video below.)

The cloud itself is made by felting hypoallergenic fiberfill to a sponge casing that forms the frame of the cloud, holding the speakers and componentry within. (A custom felting tool was constructed, made from the left-over sponge casing and four felting needles.) To control the functions of the cloud, users activate three tactile switches scattered along the base.

Check out some process pictures below, as well as the Arduino code for those who want to try their hand at capturing the thunder. See more of Richard Clarkson’s work at his site.

Arduino Code below:

#include <FatReader.h>
#include <SdReader.h>
#include <avr/pgmspace.h>
#include "WaveUtil.h"
#include "WaveHC.h"


SdReader card;    // This object holds the information for the card
FatVolume vol;    // This holds the information for the partition on the card
FatReader root;   // This holds the information for the filesystem on the card
FatReader f;      // This holds the information for the file we're play

WaveHC wave;      // This is the only wave (audio) object, since we will only play one at a time

int motion_1 = 8;
int light_1 = 13;
int led2 = 6;
int led3 = 7;
int led = 9;
int randomSound = 1;
int chooseWAV = (randomSound);
int delayTime = 201;
int flash = 31;
int randomChoose = 1;
int chooseLED = (randomChoose);
int flashTime = 1;
int sporaticCounter = 0;
int strikeCounter = 0;

  
// this handy function will return the number of bytes currently free in RAM, great for debugging!   
int freeRam(void)
{
  extern int  __bss_end; 
  extern int  *__brkval; 
  int free_memory; 
  if((int)__brkval == 0) {
    free_memory = ((int)&free_memory) - ((int)&__bss_end); 
  }
  else {
    free_memory = ((int)&free_memory) - ((int)__brkval); 
  }
  return free_memory; 
} 

void sdErrorCheck(void)
{
  if (!card.errorCode()) return;
  putstring("\n\rSD I/O error: ");
  Serial.print(card.errorCode(), HEX);
  putstring(", ");
  Serial.println(card.errorData(), HEX);
  while(1);
}

void setup() {
  pinMode (motion_1,INPUT);
  pinMode (light_1, OUTPUT);
  // set up serial port
  Serial.begin(9600);
  putstring_nl("WaveHC with ");
  Serial.print("NUMBUTTONS, DEC");
  putstring_nl("buttons");
  
  putstring("Free RAM: ");       // This can help with debugging, running out of RAM is bad
  Serial.println(freeRam());      // if this is under 150 bytes it may spell trouble!
  
  // Set the output pins for the DAC control. This pins are defined in the library
  pinMode(2, OUTPUT);
  pinMode(3, OUTPUT);
  pinMode(4, OUTPUT);
  pinMode(5, OUTPUT);
 
  // pin13 LED
  pinMode(13, OUTPUT);
  pinMode(led, OUTPUT);
  pinMode(led2, OUTPUT); 
  pinMode(led3, OUTPUT);
  
  //  if (!card.init(true)) { //play with 4 MHz spi if 8MHz isn't working for you
  if (!card.init()) {         //play with 8 MHz spi (default faster!)  
    putstring_nl("Card init. failed!");  // Something went wrong, lets print out why
    sdErrorCheck();
    while(1);                            // then 'halt' - do nothing!
  }
  
  // enable optimize read - some cards may timeout. Disable if you're having problems
  card.partialBlockRead(true);
 
// Now we will look for a FAT partition!
  uint8_t part;
  for (part = 0; part < 5; part++) {     // we have up to 5 slots to look in
    if (vol.init(card, part)) 
      break;                             // we found one, lets bail
  }
  if (part == 5) {                       // if we ended up not finding one   
    putstring_nl("No valid FAT partition!");
    sdErrorCheck();      // Something went wrong, lets print out why
    while(1);                            // then 'halt' - do nothing!
  }
  
  // Lets tell the user about what we found
  putstring("Using partition ");
  Serial.print(part, DEC);
  putstring(", type is FAT");
  Serial.println(vol.fatType(),DEC);     // FAT16 or FAT32?
  
  // Try to open the root directory
  if (!root.openRoot(vol)) {
    putstring_nl("Can't open root dir!"); // Something went wrong,
    while(1);                             // then 'halt' - do nothing!
  }
  
  // Whew! We got past the tough parts.
  putstring_nl("Ready!");
  
  }
  


void loop() {
    delay(3000); //this delay is to let the sensor settle down before taking a reading
  int sensor_1 = digitalRead(motion_1);\
  if (sensor_1 == LOW){
    Serial.println("nomotion");
    delay (200);
 }
  else if (sensor_1 == HIGH){
    Serial.print("motiondetected");
    strikeCounter = 0;
  while (strikeCounter < random (3,25)){
    sporaticCounter = 0;
    delayTime = random (30,5000);
    flash = random (10,50);
    flashTime = random (1,3);
    int randomChoose = random (1,4);
    if (randomChoose == 1){
      chooseLED = led;
    }
    else if (randomChoose == 2){
      chooseLED = led2;
    }
    else if (randomChoose == 3){
      chooseLED = led3;
    }
    while (flashTime > sporaticCounter){
      digitalWrite(chooseLED, HIGH);   // turn the LED on (HIGH is the voltage level)
      delay (flash);
      digitalWrite(chooseLED, LOW); 
      delay (flash);       
      sporaticCounter = sporaticCounter + 1;
    }
    delay (delayTime);
    strikeCounter = strikeCounter + 1;
    Serial.println(strikeCounter);
  }
  //STORM!!!!!
  putstring("storm");
  digitalWrite(led, HIGH);   // 1st Flash
  delay (5);
  digitalWrite(led2, HIGH); 
  delay (10);
  digitalWrite(led3, HIGH); 
  delay (50);
  digitalWrite(led, LOW);
  digitalWrite(led2, LOW); 
  delay (30);
  digitalWrite(led3, LOW); 
  delay (70);
  digitalWrite(led3, HIGH);   // 2nd Flash
  delay (5);
  digitalWrite(led2, HIGH); 
  delay (10);
  digitalWrite(led, HIGH); 
  delay (50);
  digitalWrite(led, LOW);
  digitalWrite(led2, HIGH); 
  delay (30);
  digitalWrite(led3, LOW); 
  delay (20);
  digitalWrite(led, HIGH);   // 3rd Flash
  delay (5);
  digitalWrite(led2, HIGH); 
  delay (10);
  digitalWrite(led3, HIGH); 
  delay (50);
  digitalWrite(led, LOW);
  digitalWrite(led2, LOW); 
  delay (30);
  digitalWrite(led3, LOW); 
  delay (10);
  digitalWrite(led2, HIGH);   // 4th Flash
  delay (5);
  digitalWrite(led, HIGH); 
  delay (10);
  digitalWrite(led3, HIGH); 
  delay (50);
  digitalWrite(led, LOW);
  digitalWrite(led2, LOW); 
  delay (30);
  digitalWrite(led3, HIGH); 
  delay (100);
  digitalWrite(led, HIGH);   // 5th Flash
  delay (5);
  digitalWrite(led2, HIGH); 
  delay (10);
  digitalWrite(led3, HIGH); 
  delay (50);
  digitalWrite(led, LOW);
  digitalWrite(led2, LOW); 
  delay (30);
  digitalWrite(led3, LOW); 
  delay (100);
    int randomSound = random (1,9);
    if (randomSound == 1){
      playcomplete("01.WAV");
      putstring_nl("DO");
    }
    else if (randomSound == 2){
      playcomplete("02.WAV");
      putstring_nl("RE");
    }
    else if (randomSound == 3){
      playcomplete("03.WAV");
      putstring_nl("MI");
    }
    else if (randomSound == 4){
      playcomplete("04.WAV");
      putstring_nl("MI");
    }
    else if (randomSound == 5){ 
      playcomplete("05.WAV");
      putstring_nl("MI");
    }
    else if (randomSound == 6){
      playcomplete("06.WAV");
      putstring_nl("MI");
    }
    else if (randomSound == 7){
      ; 
      playcomplete("07.WAV");
      putstring_nl("MI");
    }
    else if (randomSound == 8){
       
      playcomplete("08.WAV");
      putstring_nl("MI");
    }
    delay(500);
    digitalWrite(light_1,LOW);
    digitalWrite(led,LOW);
    digitalWrite(led3,LOW);
    digitalWrite(led2,LOW);
    delay(3000);
  }
}


// Plays a full file from beginning to end with no pause.
void playcomplete(char *name) {
  // call our helper to find and play this name
  playfile(name);
  while (wave.isplaying) {
  // do nothing while its playing
  }
  // now its done playing
}

void playfile(char *name) {
  // see if the wave object is currently doing something
  if (wave.isplaying) {// already playing something, so stop it!
    wave.stop(); // stop it
  }
  // look in the root directory and open the file
  if (!f.open(root, name)) {
    putstring("Couldn't open file "); Serial.print(name); return;
  }
  // OK read the file and turn it into a wave object
  if (!wave.create(f)) {
    putstring_nl("Not a valid WAV"); return;
  }
  
  // ok time to play! start playback
  wave.play();
}