Larva vest

ABOUT THIS GARMENT

This vest is inspired by the first stage of the beetle life cycle, the larva. I wanted to capture the flexibility and movement that characterize these creatures, and I thought the connection to soft robotics would be an interesting way to approach the design.

My idea is to create an inflatable piece, but in a way that's different from what we're used to. While traditional puffer vests gain volume through synthetic padding, mine incorporates a simple electronic system with an air pump to inflate certain details of the vest, allowing it to take on a dynamic and transformable shape.

I chose to use low-density textiles that can be sublimated before sewing, resulting in a lightweight garment with a high-quality finish. Additionally, for the inflatable elements, I use the technique of inflatable vinyls, which I explored during Soft Robots Week.

DESIGN

Patterns

• I decided to use SolidWorks for the pattern design, as my idea is to cut them with a laser to achieve greater precision and avoid the fabric fraying before sewing.

• I started with the design of the vest front, considering the measurements of a person who wears a size large in Mexico. I used the same base to trace the lines for the back piece, which will have slight adjustments to ensure a curved shape.

• When the pieces are symmetrical, the "symmetry" tool is very useful to draw only half of the piece and mirror the lines. This way, you can visualize the full proportion of the vest, but in this case, half-drawings are sufficient.

NOTE: If for some reason the laser cutter's dimensions are limiting, the pattern can be modified to cut the fabric folded in half, especially if both sides are symmetrical.

• I did copy-paste the drawing onto the same workspace sheet to have a reference for the shape that needed to be maintained when removing all the guide lines.

NOTE: This process must be done carefully, as SOLIDWORKS generates reference points in the drawing that may be altered if any element is deliberately deleted.

• The garment's construction requires an extra 1 cm on the edges to prevent the proportions from shrinking when sewing along the edges. So, using the "Equidistant relations" tool, I selected the entire trace and applied a 1 cm distance. This way, I obtained the cutting lines for the laser cutter.

• An important aspect for cutting this design is to keep the centerline without the offset and remove it before exporting the drawing, because, when folding the fabric in half, there is no need for the laser to trace that path on the fabric.

Color & Texture

Sternotomis pulchra

The Sternotomis pulchra beetle is an insect belonging to the Buprestidae family, commonly known as "jewel beetles" or "metallic beetles." This family includes some of the most beautiful species due to their bright, metallic exoskeleton.

Specifically, Sternotomis amabilis stands out for its vibrant colors and attractive appearance. Here are some important details about this species:

Characteristics:

-Coloration: Sternotomis amabilis has an exoskeleton with striking metallic colors, typically in shades of green, blue, or gold. These colors are typical of Buprestidae beetles and result from the microscopic structure of their shell, which reflects light in a special way, creating an intense shine.

-Size: They are medium to large-sized beetles, which makes them even more impressive due to the combination of their coloration and size.

Graphic design

I used the design I created in SolidWorks as a base, and using a screenshot, I transferred the design to an Illustrator artboard, which I set up with the measurements I'll use for making the garment.

FRONT|BACK | Width 60.15 cm | Height 70.56 cm | Color CMYK BACK | Width 60.15 cm | Height 64.98 cm | Color CMYK

I worked in layers to gradually add the shapes with gradient textures, using the black piece as a reference to visualize a possible final result after incorporating the vinyl piece.

NOTE: I made a white outline of the garment to indicate which part of the design would be inside or outside the garment after laser cutting.

Sublimate test

Sublimation printing is a printing process in which special inks, when applied to the material and subjected to heat, turn into gas and bond directly into the fabric fibers. This creates vibrant and long-lasting images, especially on synthetic fabrics like polyester.

I did a couple of tests on fabrics with an 80% and 100% polyester composition, and the results were good on both, but the 100% composition had a brighter color and was more faithful to the original design. Therefore, for the final pieces, I used white gabardine with a 100% polyester composition.

Sublimate process

To sublimate the gabardine pieces, I used Wasatch's SOFTRIP program, which allows you to edit the print spooler.

Now, once you open the program, import the image in JPEG in the "WORK" tab and with the right click "Add composition" . In this way, all the images that we add are positioned in print spooler and once you arrange the images to optimize the printing space, you select the "Print" option and the instruction is automatically processed and connected to the plotter.

When I finished the prints, I arranged the pieces of fabric on the paper and secured it with masking tape and pins. That way, you prevent the sublimated design from moving. The sublimation machine runs on air, so after opening the air knob, I turned the machine on to heat up to "200". The video shows the operation of the machine, which is very simple.

LASER CUT

To cut the pieces with the laser cutter, I exported the designs in DXF format and used SmartCarve to configure the cutting parameters.

Max POWER: 32
Min POWER: 22
Working SPEED mm/s: 30

To prevent the fabric from getting stained by the cutting bed, I used cardboard to help stretch the fabric and provide support.

NOTE: An interesting fact is that cutting 100% polyester fabric with a laser is very convenient for the sewing process, since the laser cauterizes the edges of the fabric and prevents it from fraying.

VINYL PIECE

Pattern

Initially, the idea was to create two separate parts, but that compromised the number of hoses I needed to include in the electronic system. So, using SolidWorks, I joined the parts to create a single shape.

• I used the "Cut Studio" program and the first step was to import my file into a new document and I selected the "profile image" option to extract the vector from my image.
• I used the "extract contour lines" option by adjusting the darker density and automatically the program created a new file with only the cut lines.
• I deleted the jpg and rearranged the image.
• I used the "ROLAND" cutter.
• I placed the vinyl on the back of the machine and adjusted the edges with the front rollers.
• I selected "ENTER" and the cutter positioned itself at the zero point.
• In my case, I used textile Vinyl, so I raised the power from 140 to 190 with the "FORCE" button.
• And I just had to click cut.

Vinyl preparation

After removing the excess vinyl, I trimmed the edges of the pieces to make them easier to handle. I stretched a piece of kitchen paper over the figure and, using a pencil, traced the silhouette, allowing for an offset of approximately 1 cm.

NOTE: Kitchen paper tends to curl, so you can use a glue stick to secure the paper to the vinyl.

Once the pieces were aligned, I ironed them in sections for 15 seconds at a temperature of 150 degrees.

Inflatable test

To ensure the ironing was successful and that there were no air leaks, I used a toy balloon compressor and, with the help of a thin hose, began inflating the piece.

NOTE: The amount of air concentrated in the center of the piece is excessive, and air distribution through the thinner ducts is very slow. Therefore, the piece should be inflated gradually to prevent the center piece from bursting. Alternatively, increase the offset in that area to ensure the ironed material is less susceptible to bursting.

SEWING TIME

After cutting the sublimated pieces, I cut the same pieces out of black fabric to serve as the garment's lining. I used the overlock sewing machine to close the edges and sewed the entire garment with my home sewing machine.

Once I finished the seams, I laid the vinyl piece over the garment to see if the cut matched correctly.

Note: I used the same mannequin I made during Digital Bodies Week.

ELECTRONIC SYSTEM

There were two ways to create the inflatable system.

Analog: Using a manual air pump, I could create an inflatable system that would trap air in the same way that pressure gauges do. The only disadvantage is that the user had to produce the air themselves.

Digital: Replacing the manual pump with an automatic one is more effective, but it requires a programmable system that functions as a switch for the pump.

In both cases, the system must be as discreet as possible so as not to compromise the user's comfort. In the end, I decided to use a programmable system, taking advantage of the relatively small air pumps. So, I ran a small test to check the pump's power with a balloon connected to the pump outlet, and the result was successful.

Air pump test

COMPONENTS

TB6612fng DRIVER & PINOUT XIAO RP2040

SENSOR HC-SR04 TEST + neopixel

I used this code to control a NeoPixel and an HC-SR04 ultrasonic sensor with the goal of turning on the LED when an object comes within 20 cm of the sensor.

The idea was to measure the distance to an object using the ultrasonic sensor. To do this, the sensor sends a sound pulse and measures the time it takes for the echo to return. Based on that time, I can calculate the distance in centimeters. This measurement allows me to determine whether the object is near or far.

What I wanted to achieve with the NeoPixel was that, when an object was within 20 cm, the LED would light up in red to indicate it. If the object moved further than 20 cm, the LED would turn off. It's a simple way to visualize the proximity of an object using light.

Summary of the code flow:

Initialization:

• The NeoPixel is set up on pin D5, and the ultrasonic sensor is initialized with its Trig and Echo pins.
• Serial communication is enabled for debugging.

Distance Measurement:

• The code sends a signal pulse to the ultrasonic sensor (Trig pin).
• Then, it measures the time it takes for the echo to return (using pulseIn on the Echo pin).
• The distance is calculated based on the pulse's travel time, and it is displayed on the serial monitor.

NeoPixel Control:

• If the measured distance is less than 20 cm, the NeoPixel lights up in red.
• If the distance is greater than 20 cm, the NeoPixel turns off.

Interaction:

• The NeoPixel turns on or off depending on the proximity of an object to the ultrasonic sensor.
• The code waits 500 ms between measurements to avoid readings that are too fast.

Schematic

Arduino code

#include <Adafruit_NeoPixel.h>

// Define the NeoPixel pin and the number of pixels
const int neoPixelPin = D5; // Data pin for NeoPixel
const int numPixels = 1; // Number of NeoPixels (you can add more if needed)

Adafruit_NeoPixel strip = Adafruit_NeoPixel(numPixels, neoPixelPin, NEO_GRB + NEO_KHZ800);

// Define the ultrasonic sensor pins
const int trigPin = D7;  // Trig pin of the HC-SR04
const int echoPin = D8;  // Echo pin of the HC-SR04

long duration;
int distance;
bool neoPixelEncendido = false; // Flag to track NeoPixel state

void setup() {
  // Initialize the NeoPixel
  strip.begin();
  strip.show(); // Initialize NeoPixel to "off"

  // Initialize the ultrasonic sensor pins
  pinMode(trigPin, OUTPUT);
  pinMode(echoPin, INPUT);

  Serial.begin(9600); // Start serial communication for debugging
}

void loop() {
  // Send a pulse to measure distance
  digitalWrite(trigPin, LOW);
  delayMicroseconds(2);
  digitalWrite(trigPin, HIGH);
  delayMicroseconds(10);
  digitalWrite(trigPin, LOW);

  // Read the pulse return time
  duration = pulseIn(echoPin, HIGH);

  // Calculate the distance
  distance = duration * 0.0344 / 2;  // Speed of sound in cm/µs

  Serial.print("Distance: ");
  Serial.println(distance);

  // If the distance is less than 20 cm, turn on the NeoPixel
  if (distance < 20 && !neoPixelEncendido) {
    strip.setPixelColor(0, strip.Color(255, 0, 0)); // Red (you can change the color here)
    strip.show(); // Update the NeoPixel
    neoPixelEncendido = true;
    Serial.println("NeoPixel turned on");
  }

  // If the distance is greater than 20 cm, turn off the NeoPixel
  if (distance > 20 && neoPixelEncendido) {
    strip.setPixelColor(0, strip.Color(0, 0, 0)); // Turn off the NeoPixel
    strip.show(); // Update the NeoPixel
    neoPixelEncendido = false;
    Serial.println("NeoPixel turned off");
  }

  delay(500);  // Wait half a second before the next measurement
}

Air pump test / TB6612fng DRIVER

I used this code to control a DC motor through a TB6612FNG motor driver in order to turn on and off a pump at full speed.

The purpose of this code is to power the pump on (which is driven by a DC motor) and keep it on for 5 seconds before turning it off. The motor driver (TB6612FNG) is used to control the motor's direction and speed. The pins for controlling the motor are defined, and the pump is powered with a PWM signal.

Code breakdown:

Pin Definition:

• motorPin1 (D9) and motorPin2 (D10) control the motor's direction.
• pwmPin (D6) controls the motor's speed (via PWM).
• standbyPin (D7) enables the motor (STBY pin on the TB6612FNG).

Setup:

• The pins are initialized as outputs using pinMode().
• StandbyPin is set to HIGH to enable the motor driver.
• The pump is turned on by setting motorPin1 to HIGH (to make the motor spin in one direction) and motorPin2 to LOW (to control the motor's rotation).
• The motor speed is set to maximum by sending a PWM value of 255 to pwmPin.
• Serial communication is initialized to print debug messages.
• The program waits for 5 seconds (using delay(5000)) while the pump is running.
• After this delay, the pump is turned off by setting PWM to 0, and both motorPin1 and motorPin2 to LOW (stopping the motor).

Loop:

The loop() function is empty because we only need to execute this once during setup.

Schematic

Arduino code

// Define the pins
const int motorPin1 = D9;    // AIN1 of the TB6612FNG
const int motorPin2 = D10;   // AIN2 of the TB6612FNG
const int pwmPin = D6;       // PWMA of the TB6612FNG (speed control)
const int standbyPin = D7;   // STBY of the TB6612FNG (enable motor)

void setup() {
  // Initialize the pins
  pinMode(motorPin1, OUTPUT);
  pinMode(motorPin2, OUTPUT);
  pinMode(pwmPin, OUTPUT);
  pinMode(standbyPin, OUTPUT);

  // Enable the motor (set STBY to HIGH)
  digitalWrite(standbyPin, HIGH);

  // Turn on the pump at maximum speed (PWM = 255)
  analogWrite(pwmPin, 255);  
  digitalWrite(motorPin1, HIGH);  // Rotation direction
  digitalWrite(motorPin2, LOW);

  Serial.begin(9600);  // Start serial communication for debugging
  Serial.println("Pump turned on");

  // Wait for 5 seconds
  delay(5000);

  // Turn off the pump (PWM = 0)
  analogWrite(pwmPin, 0);  
  digitalWrite(motorPin1, LOW);  // Stop the motor
  digitalWrite(motorPin2, LOW);
  Serial.println("Pump turned off");
}

void loop() {
  // The loop is empty because we only need to run this once
}

System complete - balloon test

I used this code to control a pump through a DC motor with a TB6612FNG motor driver and to measure the distance to an object using an HC-SR04 ultrasonic sensor. The goal is to turn on the pump when an object comes within 20 cm of the sensor and turn it off when the object is more than 20 cm away.

Code Explanation:

Pin Definition:

• motorPin1 (D9) and motorPin2 (D10) control the motor's direction.
• pwmPin (D6) controls the motor's speed (via PWM).
• standbyPin (D7) enables the motor (STBY pin on the TB6612FNG).
• trigPin (D2) and echoPin (D4) are used for the HC-SR04 ultrasonic sensor.

Setup:

• The pins are set up as outputs or inputs as needed.
• standbyPin is set to HIGH to enable the motor driver.
• Serial communication is initialized to display the measured distance and other debug messages.

Distance Measurement (loop):-

• The code sends a pulse to the trigPin to measure the distance to the object.
• Then, it measures the time it takes for the pulse to return to the echoPin using the pulseIn() function.
• The distance is calculated using the formula distance = time * speed of sound / 2, and the value is displayed in the Serial Monitor.

Motor Control (pump):

• If the measured distance is less than 20 cm, the pump (motor) is turned on at maximum speed (PWM = 255). The motor is set to rotate in one direction by setting motorPin1 to HIGH and motorPin2 to LOW.
• If the distance is greater than 20 cm, the pump (motor) is turned off by setting PWM to 0, and both motorPin1 and motorPin2 to LOW to stop the motor.

Delay:

• The code waits for half a second (500 ms) between measurements to prevent too fast readings.

Schematic

Arduino code

// Define the pins for the motor and the sensor
const int motorPin1 = D9;    // AIN1 of the TB6612FNG
const int motorPin2 = D10;   // AIN2 of the TB6612FNG
const int pwmPin = D6;       // PWMA of the TB6612FNG (speed control)
const int standbyPin = D7;   // STBY of the TB6612FNG (enable motor)
const int trigPin = D2;      // TRIG pin of the HC-SR04
const int echoPin = D4;      // ECHO pin of the HC-SR04

long duration;
int distance;
bool motorState = false;  // Motor state (on or off)

void setup() {
  // Initialize the pins
  pinMode(motorPin1, OUTPUT);
  pinMode(motorPin2, OUTPUT);
  pinMode(pwmPin, OUTPUT);
  pinMode(standbyPin, OUTPUT);
  pinMode(trigPin, OUTPUT);
  pinMode(echoPin, INPUT);

  // Enable the motor (set STBY to HIGH)
  digitalWrite(standbyPin, HIGH);

  Serial.begin(9600);  // Start serial communication for debugging
}

void loop() {
  // Send a pulse to the trigPin to measure distance
  digitalWrite(trigPin, LOW);
  delayMicroseconds(2);  // Wait for 2 microseconds
  digitalWrite(trigPin, HIGH);
  delayMicroseconds(10);  // 10-microsecond pulse
  digitalWrite(trigPin, LOW);

  // Read the time it takes for the pulse to go out and return to the echoPin
  duration = pulseIn(echoPin, HIGH);

  // Calculate the distance in centimeters
  distance = duration * 0.0344 / 2;  // Speed of sound in cm/µs

  // Print the distance to the Serial Monitor
  Serial.print("Distance: ");
  Serial.println(distance);

  // If the distance is less than 20 cm, turn on the pump
  if (distance < 20 && !motorState) {
    // Turn on the pump at full speed (PWM = 255)
    analogWrite(pwmPin, 255);  
    digitalWrite(motorPin1, HIGH);  // Rotation direction
    digitalWrite(motorPin2, LOW);
    motorState = true;
    Serial.println("Pump turned on");
  }

  // If the distance is greater than 20 cm, turn off the pump
  if (distance > 20 && motorState) {
    // Turn off the pump (PWM = 0)
    analogWrite(pwmPin, 0);  
    digitalWrite(motorPin1, LOW);  // Stop the motor
    digitalWrite(motorPin2, LOW);
    motorState = false;
    Serial.println("Pump turned off");
  }

  delay(500);  // Wait half a second before the next measurement
}

System complete - Vinyl piece test