For my final project, I'm thinking of creating a set of objects with some (minimal) agency that would upset / reset / defamiliarize our daily experience. They could be cast or CNC'd or made out of some soft material (think pillow), and they would all exhibit some form of disembodied human behaviour, such as breathing, humming, or hugging. I would achieve this by making them appear like an anthropomorphic lamp, chair, or other everyday object, but encode some simple behaviour (e.g. dimming at the pace of breath) that would place them in the interstitial space between objects and agents.

Breathing chair

Jes Fan's "Poke"

Jes Fan's "Forniphilia I"

Marguerite Humeau's "Echoes"

Jung and I decided to re-focus our intentions and bring together 'drawing' and 'objects' by creating a ceramic dripper that intergrates a mechanical valve, a rotating base or a Stewart platform, and slip casting, inspired by Studio Joachim Morineau's Moca Machine.

Studio Joachim Morineau produced some beautiful ceramic cups and bowls using a dripper end that drops liquid clay ("slip") onto a plaster mold, and is then easily extracted from it. We envied the forms (integrating intentions and stochastic flow, hand-designed parts and machine autonomy) and wanted to produce something similar.

I started by designing the servo board and putting together a draft for the main controller that we both needed. For the servo, I integrated a switch and an LED for debugging.

We both thought about what the master board would need, since this was the board to integrate and communicate with our two independent boards. We added three inputs: the two potentiometers and a button, and two 2x2 headers for communicating with the servo and stepper boards. We also added an FTDI connection so that we could debug all communication / network errors via Serial monitoring, which proved to be extremely helpful.

At the point when I started soldering, all the endmills seemed broken at the architecture section... I tried all of them after closely inspecting them and not seeing too much difference between them, which resulted in the bad traces above which caused my Bluetooth board never to connect... so I looked further. After 3 hours of trying and readjusting location on the sacrificial board, changing endmills, and changing cut depth, eventually we found a completely new endmill in Jen's office, and I used that to mill a clean board for both servo and master. So many hours later: clean milled boards! Once we found the functional bit, milling and soldering, as well as programming, was very quick.

I used the Arduino & the SoftwareSerial libary to communicate with the boards--parsing the data correctly was particularly difficult (especially without maxing out on memory), but in the end it worked!

/*
 * Dalma Foldesi
 * Ceramic dripper
 * 
 * Servo code for opening / closing valve
 * 
  Servo PWM:

  https://arduino.stackexchange.com/questions/44760/programming-a-servo-on-an-attiny85

  Parse Serial:
  
  https://arduino.stackexchange.com/questions/1013/how-do-i-split-an-incoming-string
  
*/

#include 
#include 

#define RX    1   
#define TX    2   
#define INPUT_SIZE 20

SoftwareSerial ServoSerial(RX, TX);
Servo myservo;

const int LED_PIN = 3;
const int SERVO_PIN = 7;
const int BUTTON_PIN = 8;

//int buttonState = -1;
int remoteButtonState = 0;
boolean isOpen = false;
int servoAngle = 0;

// Parameter for receiving Serial command (add 1 for final 0)
char input[INPUT_SIZE + 1];

void setup() {
  pinMode(LED_PIN, OUTPUT);
  pinMode(BUTTON_PIN, INPUT_PULLUP);
  pinMode(SERVO_PIN, OUTPUT);

  ServoSerial.begin(9600);
}

void updateRemoteButton() {
  if (remoteButtonState == 1) {               
    digitalWrite(LED_PIN, HIGH);
  }
  // button pressed
  else {
    digitalWrite(LED_PIN, LOW);
  }
}

void toggleRemoteButton() {
  // button pressed      
  isOpen = !isOpen;
           
  if (isOpen) {
     digitalWrite(LED_PIN, HIGH);
     openServo();
  }
  else {
     digitalWrite(LED_PIN, LOW);
     closeServo();
  }
}

void closeServo() {
  for(int i = 0; i< 20; ++i) {
      digitalWrite(SERVO_PIN, HIGH);
      delayMicroseconds(1000);
      digitalWrite(SERVO_PIN, LOW);
      delay(19);
    }
}

void openServo() {
  // keep sending second position for about 400ms
    for(int i = 0; i< 20; ++i) {
      digitalWrite(SERVO_PIN, HIGH);
      delayMicroseconds(2000);
      digitalWrite(SERVO_PIN, LOW);
      delay(19);
    }
}

/*
void updateButton() {
   if (buttonState == LOW) {
     digitalWrite(LED_PIN, HIGH);
     //delay(300);

    // servo PWM
    openServo();
    closeServo(); 
  }
  else {
    digitalWrite(LED_PIN, LOW);
    delay(50);
  }
}
*/

void readSerial() {
  // We need this counter to simulate Serial.readBytes which SoftwareSerial lacks
  int key = 0;

  // Start receiving command from Serial
  while (ServoSerial.available()) {
    delay(3);  // Delay to allow buffer to fill, code gets unstable on Attiny85 without this for some reason
    // Don't read more characters than defined
    if (key < INPUT_SIZE && ServoSerial.available()) {
      input[key] = ServoSerial.read();
      key += 1;
    }
  }

  if (key > 0) {
    // Add the final 0 to end the C string
    input[key] = 0;

    // Read each command pair
    char* command = strtok(input, "&");
    while (command != 0)
    {
      // Split the command in two values
      char* separator = strchr(command, ':');
      if (separator != 0)
      {
        // Actually split the string in 2: replace ':' with 0
        *separator = 0;
        int id = atoi(command);
        ++separator;
        int value = atoi(separator);

        if (id == 1) {
          if (value != servoAngle) {
            servoAngle = value;
          }
        }
        if (id == 3) {
          if (value == 1 && remoteButtonState == 0) {
            toggleRemoteButton();
          }
          remoteButtonState = value;
          /*
          if (value != remoteButtonState) {
            updateRemoteButton();
            remoteButtonState = value;
          }
          */
          
        }
      }
      // Find the next command in input string
      command = strtok(0, "&");
    }
  }
}

void loop() {
  readSerial();

  /*
  buttonState = digitalRead(BUTTON_PIN);
  updateButton();
  */
  
  delay(300);
}

  /* Master board for Ceramic Dripper
 *  Dalma Foldesi & Jung In Seo
 * ------------------ 
 *
 *
 */

#include 

#define RX    8   
#define TX    7   

SoftwareSerial Serial(RX, TX);

const int BUTTON_PIN = 1;
const int POT1_PIN = 2;
const int POT2_PIN = 3;

int buttonState = 0;
int mapped_val = 0;

int prevVal1 = 0;
int prevVal2 = 0;

int value1 = 0;
int value2 = 0;

void setup() {
  pinMode(BUTTON_PIN, INPUT_PULLUP);
  
  Serial.begin(9600);
  //Serial.println("Initializing...");
}

void readButtonState() {
  int buttonVal = digitalRead(BUTTON_PIN);
  // button off
  if (buttonVal == HIGH) {
    buttonState = 0;
  }
  else { // button pressed
    buttonState = 1;
  }
}

void readPots() {
  // Servo angle
  value1 = analogRead(POT2_PIN);
  if (value1 != NULL && abs(value1 - prevVal1) > 50) {
    prevVal1 = value1;
    value1 = map(value1, 0, 1023, 0, 100);

    /* DEBUG
    Serial.println("new value 1: ");
    Serial.println(value1);
    */
  }

  // Stepper speed
  value2 = analogRead(POT1_PIN);
  if (value2 != NULL && abs(value2 - prevVal2) > 50) {
    prevVal2 = value2;
    value2 = map(value2, 0, 1023, 0, 100);
    
    /* DEBUG
    Serial.println("new value 2: ");
    Serial.println(value2);
    */
  }
}

void loop() {

  // Update machine speeds & angles
  readPots();

  // Start / stop operation
  readButtonState();

  Serial.print('1');
  Serial.print(':');
  Serial.print(value1);
  Serial.print('&');
  Serial.print('2');
  Serial.print(':');
  Serial.print(value2);
  Serial.print('&');
  Serial.print('3');
  Serial.print(':');
  Serial.print(buttonState);
  Serial.print('&');
  Serial.flush();
  
  delay(1000);
}

I tested both our solution for the machine week drink dispenser and a syringe for 'extruding' liquid clay, and it seemed like while I could drip using the valve, the syringe only led to an uneven combination of flow and drip. I decided to refine our previous, purchased valve and 3D print our own instead.

I wanted to test 3D printing the valves with different cross-sections, and I found an OpenScad design for one on Thingiverse here which I ended up customizing using the OpenScad interface to set up multiple prints. I also designed different nozzles (with different outflow radii) for this & a connection to a supported bottle to receive the clay.

I had to manually split the output mesh in two halves using Netfabb to be able to print & assemble the valve.

There was only one roll of filament left at the architecture section by Sunday, so I had to use that for printing all my valves and nozzles--after many many failed filament insertions by the machine and fixed beds, the prints finally came out.

I then had to coat the valve in lots of Tamiya white plastic putty--and even after quite a few coats, the valve wasn't completely waterproof, but sealed enough to hold liquid clay.

The print of the bottle joint and the nozzles was successful, and the fitting was also tight enough to make a good connection after sanding.

I created the 3D formwork for the plaster casts in Rhino, which we then milled on the Onsrud and glued with 3M Super 77 to keep it securely sealed. We each cast into one or two the foam formworks at the Mars Lab (ACT shop) with Graham's supervision, who also introduced us to the 'island method' of casting plaster, where you first create a small heap of plaster, then let it sit for a minute or so, and only after that you mix.

We then left the formwork to dry for about 3 days, after which the bowls didn't feel cold anymore.

I tested a syringe and a valve for dripping slip onto one of the bowls before it completely dried, and while it helped me decide on the valve (the syringe wouldn't allow dripping at a constant rate), it didn't demold because the plaster was too wet.

I bent our steel section at the Mars Lab while Jung waterjet and cut out the parts for the lower half of the machine. We inserted the servo, stepper, potentiometers, and jumped the button to reach the interface.

The communication and the hardware all seemed to work fine, except that the button was *WAY* too small and jumping it caused some unforeseen errors. In retrospect, we should have ordered a new button earlier... it is the first item on our to-do list. In addition, there was some power leak from the Stepper board to the other two, since all the boards shared ground. But overall--the machine was moving the valve, rotating the platform, and dripping clay!