d e l i v e r a b l e s¶

o r i g a m i . t h e . r e s u l t¶

The final bioplastic origami pieces resulted in a diverse collection of forms that combined natural aesthetics with structured design. I created several variations, experimenting with different folding patterns and drying techniques to see how the bioplastic behaved in various conditions. For four selected pieces, I connected them directly to the acrylic mechanisms, treating them as both decorative and functional surfaces. Some of the origami pieces were left in their natural form, preserving the organic textures and unpredictable curves that formed as the bioplastic dried—these gave a skin-like quality to the assembly, emphasizing the material’s natural behavior and uniqueness.

For two of the bioplastic pieces, I introduced more control over the shaping process by using molds created with the vinyl cutter. I designed precise folding guides and plastic forms that allowed me to influence how the bioplastic would set, producing more geometric and predictable shapes. This contrast between the molded and natural forms created a rich visual and tactile dialogue across the final installation. The integration of these bioplastic elements with the acrylic mechanism highlighted a balance between structured mechanical engineering and soft, living material design—showing how digital fabrication and biomaterials can coexist in meaningful ways.

a s s e m b l y¶

Once the mechanical structure was fully assembled and validated, I integrated the bioplastic origami element into the design. This component was both aesthetic and functional, interacting with the movement of the mechanism. I designed the mounting points for the origami piece based on the final positions of the mechanical joints, ensuring that it could be securely attached without obstructing motion. The combination of rigid mechanical parts and the flexible, sustainable bioplastic created a dynamic and visually interesting assembly that reflects both technical precision and material experimentation.

t h e . g l o v e . c o n n e c t i o n¶

p r o g r a m m i n g¶

w i r e l e s s . c o n t r o l¶

w i . f i¶

To obtain the mac address

#include <WiFi.h>

void setup() {
  Serial.begin(115200);
  delay(1000);  // Small delay to ensure Serial Monitor is ready

  WiFi.mode(WIFI_MODE_STA);  // Set WiFi to station mode

  Serial.print("ESP32-C3 MAC Address: ");
  Serial.println(WiFi.macAddress());
}

void loop() {
  // Nothing here
}

#include <esp_now.h>
#include <WiFi.h>

// MAC address of receiver
uint8_t receiverMac[] = {0xB0, 0x81, 0x84, 0x03, 0x5D, 0x98};

// Flex sensor pins
const int FLEX1 = A0;
const int FLEX2 = A1;

// Message structure
typedef struct {
  int flex1Value;
  int flex2Value;
} SensorData;

void setup() {
  Serial.begin(115200);
  WiFi.mode(WIFI_STA);

  if (esp_now_init() != ESP_OK) {
    Serial.println("ESP-NOW init failed");
    return;
  }

  esp_now_peer_info_t peerInfo;
  memcpy(peerInfo.peer_addr, receiverMac, 6);
  peerInfo.channel = 0;
  peerInfo.encrypt = false;

  if (esp_now_add_peer(&peerInfo) != ESP_OK) {
    Serial.println("Failed to add peer");
    return;
  }

  Serial.println("Sender Ready");
}

void loop() {
  SensorData data;
  data.flex1Value = analogRead(FLEX1);
  data.flex2Value = analogRead(FLEX2);

  esp_now_send(receiverMac, (uint8_t *) &data, sizeof(data));

  Serial.print("Sent: ");
  Serial.print(data.flex1Value);
  Serial.print(", ");
  Serial.println(data.flex2Value);

  delay(50); // Send rate
}

XIAO ESP32C3 (Sender - Stretch Sensor) Prints both analog value & mapped angle in Serial Monitor

#include <WiFi.h>
#include <esp_now.h>

// MAC Address of the Receiver (ESP32C3 Super Mini)
uint8_t receiverMAC[] = {0x9C, 0x9E, 0x6E, 0xF7, 0x7F, 0x50};

// Stretch sensor pin
#define SENSOR_PIN A0

// Structure to send data
typedef struct struct_message {
    int servoAngle;
} struct_message;

struct_message myData;

// Callback function to check if the message was sent
void onSent(const uint8_t *mac_addr, esp_now_send_status_t status) {
    Serial.print("Message Send Status: ");
    Serial.println(status == ESP_NOW_SEND_SUCCESS ? "Success" : "Fail");
}

void setup() {
    Serial.begin(115200);
    WiFi.mode(WIFI_STA);

    // Initialize ESP-NOW
    if (esp_now_init() != ESP_OK) {
        Serial.println("ESP-NOW initialization failed!");
        return;
    }

    // Register callback function
    esp_now_register_send_cb(onSent);

    // Register peer (receiver)
    esp_now_peer_info_t peerInfo;
    memcpy(peerInfo.peer_addr, receiverMAC, 6);
    peerInfo.channel = 0;
    peerInfo.encrypt = false;

    if (esp_now_add_peer(&peerInfo) != ESP_OK) {
        Serial.println("Failed to add peer");
        return;
    }
}

void loop() {
    int sensorValue = analogRead(SENSOR_PIN); // Read sensor
    int mappedAngle = map(sensorValue, 0, 4095, 15, 180); // Map to servo range (0-4095 for ESP32 ADC)

    // Round to nearest 15°
    mappedAngle = round(mappedAngle / 15.0) * 15;

    myData.servoAngle = mappedAngle;

    // Send data
    esp_err_t result = esp_now_send(receiverMAC, (uint8_t *)&myData, sizeof(myData));

    // Print values on Serial Monitor
    Serial.print("Analog Value: ");
    Serial.print(sensorValue);
    Serial.print(" | Mapped Angle: ");
    Serial.println(mappedAngle);

    delay(500); // Adjust sending frequency
}

ESP32C3 Super Mini (Receiver - Servo Motor) Receives the mapped angle and moves the servo motor.

#include <WiFi.h>
#include <esp_now.h>
#include <Servo.h>

Servo servo; // Create servo object
#define SERVO_PIN 1 // Change if needed

// Structure to receive data
typedef struct struct_message {
    int servoAngle;
} struct_message;

struct_message receivedData;

// Callback function for ESP-NOW receive
void onReceive(const esp_now_recv_info_t *info, const uint8_t *incomingData, int len) {
    memcpy(&receivedData, incomingData, sizeof(receivedData));

    int angle = receivedData.servoAngle;
    Serial.print("Received Angle: ");
    Serial.println(angle);

    servo.write(angle); // Move servo
}

void setup() {
    Serial.begin(115200);
    WiFi.mode(WIFI_STA);

    servo.attach(SERVO_PIN); // Attach servo

    // Initialize ESP-NOW
    if (esp_now_init() != ESP_OK) {
        Serial.println("ESP-NOW initialization failed!");
        return;
    }

    // Register callback function
    esp_now_register_recv_cb(onReceive);
}

void loop() {
    // No need to do anything, just waiting for messages
}

2 . f l e x - 2 . s e r v o¶

Sender Code (ESP32-C3 Super Mini)

This code reads two DIY flex sensors (on pin 0 and pin 2) and sends their values to the XIAO ESP32-C3 using ESP-NOW.

#include <esp_now.h>
#include <WiFi.h>

uint8_t receiverMac[] = {0x64, 0xE8, 0x33, 0xB6, 0xAD, 0x3C};  // XIAO MAC Address

typedef struct {
    int flex1;
    int flex2;
} SensorData;

SensorData flexData;

void sendData() {
    flexData.flex1 = analogRead(0);  // Read flex sensor 1
    flexData.flex2 = analogRead(2);  // Read flex sensor 2

    Serial.print("Sending: Flex1 = "); Serial.print(flexData.flex1);
    Serial.print(" | Flex2 = "); Serial.println(flexData.flex2);

    esp_err_t result = esp_now_send(receiverMac, (uint8_t *)&flexData, sizeof(flexData));

    if (result == ESP_OK) {
        Serial.println("Data sent successfully!");
    } else {
        Serial.println("Failed to send data...");
    }
}

void setup() {
    Serial.begin(115200);
    WiFi.mode(WIFI_STA);

    if (esp_now_init() != ESP_OK) {
        Serial.println("ESP-NOW Init Failed!");
        return;
    }

    esp_now_peer_info_t peerInfo = {};
    memcpy(peerInfo.peer_addr, receiverMac, 6);
    peerInfo.channel = 0;
    peerInfo.encrypt = false;

    if (esp_now_add_peer(&peerInfo) != ESP_OK) {
        Serial.println("Failed to add peer!");
        return;
    }

    Serial.println("ESP-NOW Sender Ready!");
}

void loop() {
    sendData();
    delay(500);  // Send data every 500ms
}

Receiver Code (XIAO ESP32-C3)

This code receives data from the Super Mini, checks if the flex sensor values are below 300, and moves the servos (on pin 0 and pin 2) to 90° when triggered.

#include <esp_now.h>
#include <WiFi.h>
#include <ESP32Servo.h>

Servo servo1;
Servo servo2;

typedef struct {
    int flex1;
    int flex2;
} SensorData;

SensorData receivedData;

void OnDataRecv(const esp_now_recv_info_t *info, const uint8_t *data, int len) {
    memcpy(&receivedData, data, sizeof(receivedData));

    Serial.print("Received: Flex1 = "); Serial.print(receivedData.flex1);
    Serial.print(" | Flex2 = "); Serial.println(receivedData.flex2);

    // If flex sensor value is below 300, move servo to 90 degrees
    if (receivedData.flex1 < 300) {
        servo1.write(90);
    } else {
        servo1.write(0);
    }

    if (receivedData.flex2 < 300) {
        servo2.write(90);
    } else {
        servo2.write(0);
    }
}

void setup() {
    Serial.begin(115200);
    WiFi.mode(WIFI_STA);

    if (esp_now_init() != ESP_OK) {
        Serial.println("ESP-NOW Init Failed");
        return;
    }

    esp_now_register_recv_cb(OnDataRecv);

    // Attach servos
    servo1.attach(0);
    servo2.attach(2);

    servo1.write(0);
    servo2.write(0);

    Serial.println("ESP-NOW Receiver Ready!");
}

void loop() {
    // Nothing to do here, everything happens in OnDataRecv()
}

¶

const int flexPin = 4;  // Use digital pin D4 (or any other digital pin)
const int bendThreshold = 600;  // Adjust based on your readings and resistor values

void setup() {
  Serial.begin(115200);  // Start serial communication
  pinMode(flexPin, INPUT);  // Set the flex pin as an input
  Serial.println("Flex sensor test started...");
}

void loop() {
  // Read the analog value from the flex sensor (digital pin)
  int flexValue = digitalRead(flexPin);  

  // Print the flex sensor state (0 or 1)
  Serial.print("Flex sensor state: ");
  Serial.println(flexValue);  

  // Check if the sensor is bent (threshold)
  if (flexValue == LOW) {
    Serial.println("Flex sensor is bent");
  } else {
    Serial.println("Flex sensor is straight");
  }

  delay(500);  // Delay for readability
}

p r e s e n t a t i o n s . d e v e l o p m e n t¶

s c h e d u l e . a n d . p l a n n i n g¶

📅 Project Schedule: The Hands Can Tell a Lot¶

Author: Anoush Arshakyan
Duration: February 3 – March 27, 2025

Week	Deadline	Goal	Tasks
WEEK 1	Feb 3–9	Concept Refinement & Reference Selection	- Narrow down 5 key references - Define your project’s unique angle and mission - Contact potential collaborators (performer, photographer, technician)
WEEK 2	Feb 10–16	Quick Prototyping & Storyboarding	- Make a “quick and dirty” prototype (glove + bioplastic) - Sketch storyboard for scenography - Start visual research
WEEK 3	Feb 17–23	Feedback Loop & Material List	- Test glove interaction with users - Gather feedback - Finalize Bill of Materials - Order parts (motors, sensors, gloves, bioplastic ingredients)
WEEK 4	Feb 24	🟢 MIDTERM Presentation	- Present concept, references, early prototype & storyboard - Share mission: “Using movement and material to trace memory through the body”
WEEK 5	Feb 25 – Mar 2	First Iteration Build	- Assemble glove + 1 motor + bioplastic element - Program motor responses - Begin documentation (video, photos, sketches)
WEEK 6	Mar 3–9	Full Interaction Build	- Test glove with full structure - Add folding/moving elements - Calibrate timing - Document experiments
WEEK 7	Mar 10–16	Material Behavior Testing	- Observe bioplastic over time (movement, humidity) - Replace weak parts - Finalize scenography and lighting - Start video planning
WEEK 8	Mar 17–20	Final Fabrication & Assembly	- Assemble final structure - Full technical testing - Final photoshoot + video shoot
FINAL WEEK	Mar 24–27	🌟 FINAL PRESENTATION	- Present final installation - Upload video & booklet - Submit fabrication files - Celebrate 🎉