5. E-textiles¶

✧Research & Ideation✧¶

☆I am so excited for ELECTRONICS WEEK☆!!!

I have absolutely no experience in this area but it is something I have always wanted to incorperate into my work but have never known where to start. For this week I really want to focus on my understanding rather than project output as I know its going to be a lot to take in and digest. However, I have big dreams about haptic and motion controlled instruments as well as one day being able to incorperate motors and lights into sculpture and wearables. I have added a moodboard of inspiration below:

Juniper by Cil- motion controlled artists instrument.
Casey Curran, Kinetic Mask- This is not powered by electronics but I am interested in incorperating motors into wearables.
Marc Koetse and Holst vccentre's foil integration program-Stretchable electronics in rubber.
Stymphalian Birds- Audrey Briot- Capacitive sensor (touch) made with feathers covered in resistive material that activates sound.
Infinite Pollination Rose 01; Rose 02; Torchon 01, Layla Klinger.
Magnetic Reverberations, Elizabeth Meiklejohn.
Stereofield by Landscape Electronics- experimental haptic synthesisers.

✙Documentation Workflow✙¶

This week we needed to:

Create one digital soft switch AND one analog soft sensor.
Connect the switch AND sensor to Arduino.
Read the incoming values using the serial monitor. (Use functions such as map() to get more meaningful data)
Connect a switch OR sensor to the Arduino to control a LED or mini vibration motor on a breadbpard.
Integrate the switch OR sensor and the output you used above in a swatch using hard/soft connections.

Assignment Criteria: Week 5

Build at least one digital and one analogue soft sensor, using different materials and techniques.
Document the sensor project as well as the readings got using the AnalogRead of Arduino
Integrate the two soft sensors into one or two textile swatches using hard soft connections
Document the circuit and its schematic
Document your swatches / samples
Upload your arduino code as text
Upload a small video of the swatches functioning
Integrate the swatch into a project (extra credit)

Top Tip!!!

Read your error messages properly! And google them if you don't understand, there are lots of friends out there who have had the same issues.

Inspiration!!!

I am obsessed with this Capacitive Fabric Slider/ Wheel Kobakant
Another beautiful analog slider project Saskia Helinska
I like the format of this e textiles swatch book- Olivia Prior

⏛Tools⏛¶

SOFTWARE:

Arduino IDE

HARDWARE:

ELECTRONICS:
LED (various colors)
Resistors
Light Dependant Resistors
Batteries (3V)
Microcontroller (Arduino uno board, XIAO ESP32C3 Board)
USB-C cable
Breadboard
Alligator clips
Jumper wires
Push button
Piezo Buzzer
Soldering Iron
Multimeter


CONDUCTIVE MATERIALS: (see more detail in documentation workflow)

Conductive Fabric
Conductive Thread
Conductive Tape
Aluminium Foil
Conductive Beads and Isolating Beads
Sewable Snaps

HAND TOOLS:

Scissors 
Straightpins
Jewellery Plyers
Felting Tool
Embroidery Needles
Beeswax
Crotchet hooks
Knitting needles
Knitting Machine

FABRICATION MACHINES:

Iron/ Heat Press
LaserCutter
Vinyl Cutter
Sewing Machine
Vinyl Cutter

⏣Getting a Grip: Learning the Basics⏣¶

There are 3 elements of e textiles that we will learn about this week and explore their vast potential on their own and in conjunction:

Electronics (circuits, breadboards, LEDs)
Fabrication (crafting, knitting, sewing)
Interaction (coding behaviours and linking to microcontrollers)

☢︎ELECTRONICS☢︎¶

In Lisa Stark's inital lecture she taught us the basic vocabulary and rules that would guide us through our making. Here are the basics but I have also linked her helpful e-textiles glossary ¹.

What is a circuit?

A circuit is a closed loop that allows electric current to flow from a power source through various components and back to the source.

In order for electricity to flow we need a circuit. Electricity moves because we have a stream of moving electrons which create an electrical current.

Electrons want:

To move from a point of greater to lesser electrical energy.
From power to ground (positive to negative).

VOLTAGE, CURRENT AND RESISTANCE:¶

What is Voltage?

VOLTAGE is the electrical pressure (or force) between 2 points. It can be measured with a multimeter in Volts (V)

Illustration by Olympia Circuits on Learning Arduino

We can use a water tower analogy to help us understand these concepts. Voltage is the height of water. High potential is at the top of the tower and low potential at the bottom.

We mainly encounter voltages when looking at power sources or components.

Power Sources:

Batteries (direct current, electricity flows in one direction: Positive to Negative)
Wall Power (alternating current, electricity flows in both directions)

All components are rated for a very specific amount of voltage and you must consider this as to not damage your components or create a fire hazard e.g LEDS require between 1.8-2.4 volts to light up.

What is current?

Current is the rate at which electrical charge flows. It can be measured with a multimeter in Amps (A).

In the water tank analogy the volume of water flowing through a hole. Whether it is a lot or a little. If we have too much water it will overwhelm our system and too little and the system can't work.

NOTE ON SERIES VS PARALLEL CIRCUITS:

In a SERIES circuit all components are connected end to end to form a single path for current flow. The current is the same flowing through each component and therefore splits the voltage.

In a PARALLEL circuit all components are connected across each other with exactly two electrically common nodes with the same voltage across each component. This splits the current between the different paths.

Illustration by Study Mind

What is Resistance?

Resistance is the amount of material that resists the flow of current. It can be measured with a multimeter in Ohms (Ω).

IMPORTANTLY:

The lower the resistance, the more current flows. The higher the resistance, less current flows.

In the water tower analogy this is the size of the hole.

If there is too much current it is important to account for the excess energy, otherwise it will dissipate as heat and possibly damage your components. (If you have extra, you can use a resistor to account for the extra energy).

You can work out how much resistance is necessary using OHMS LAW:

Resistance= Voltage/ Current

What is a short circuit?

A short circuit is when electricity bypasses your components and all the electrical current is going back into the power source.

This with cause your battery to heat up. If you feel your circuit runs hot suddenly and unexpectedly, then you should definitely check your circuit and remove the power source to troubleshoot.

We know this because of our 3 rules of Electricty:

Electrons are lazy: electrical energy always follows the path of least resistance to reach ground.
Electricity hates waste: you have to use all the electrical energy in the circuit.
Circuits are a system: different components play different roles at different times.

⍣Hard and Soft Connections⍣¶

There is an interesting design space in combining the hard plastic materials of electronics with the soft tactility of textiles.

A large focus of this is creating Traces or the physical paths of conductive material that electricity moves along in a circuit. For this we are looking for flexible and aesthetic materials which can make STRONG CONNECTIONS between components in our e-textiles so that our circuits work. Lisa and Nuria shared with us many materials we can use to achieve this.

CONDUCTIVE FABRICS

Velostat
Eeontex
Copper Conductive Fabric
Pure Copper Polyester Taffeta
VeilShield
SaniSilver
Ripstop Silver Fabric
Silver Strecth Conductive Fabric
Safety Silk
Soft and Safe Shielding Fabric
ESD Foam

More options can be found on Kobakant's website. Things that are important to consider when choosing a material are properties such as resistance, stretchability, solderability, feel and substrate/productive process it has been through.

CONDUCTIVE THREADS AND YARN

•   Elitex
•   Karl Grimm
•   Bekinox
•   Adafruit Stainless Steel
•   Silverspun Yarn

It is important to put conductive thread in the bottom bobbin of a sewing machine!

INKS AND TAPES

•   CuProCote by Less EMF
•   Bare Conductuve
•   Circuit Scribe
•   Copper Tape
•   Copper Foil Sheet
•   Conductive Fabric Tape

❖FABRICATION: making sensors❖¶

This week we are focusing on how we input data into our circuits. We can do this using switches and sensors which take information from the physical world, input them into our circuit so they can be processed and used to create an output.

There are 2 types of input:

DIGITAL: These are binary, they have 2 options e.g Switches, on/off, 01001.

ANALOG: These have a range of values e.g Sensors, 1023. 521, 34.

✢Digital Switches✢¶

A switch is a break in a circuit

If a circuit is incomplete, no electricity can flow to the components. It is either on or off.

EXAMPLES OF SWITCHES:

1.  Momentary Switch/ Push Button. Only stay open as long as you hold it in place by pressing conductive materials into contact.

2.  Toggle Switch- Stay open in one position and closed in another.

3.  Stroke Switch- close the circuit by pressing conductive materials into contact

4.  Tilt Switch- a conductive bead or pompom makes contact with conductive fabric patches based on its position.

MAKING A BUTTON TURN AN LED ON/OFF

We started by creating a simple button to control an LED.

We sandwiched a piece of fabric with holes in between two pieces of aluminium foil. This was then sandwiched between two more pieces of fabric. This way when the button is squeezed the two pieces of foil will touch through the holes and complete the circuit.

Circuit Schematic

This was a very simple circuit and the only consideration necessary was to ensure that the LED was connected in the correct direction from power to ground.

MAKING A DIGITAL ZIP SWITCH

I wanted to make a swatch using a zip switch. When the zip was up the LED would switch ON and if it was down it would turn OFF. I wanted to integrate hard and soft connections using a mixture of materials and thought this would be a good project to make a swatch with.

It was important to ensure that the connections to the LED and battery were strong and that there was a good amount of conductive thread wrapped around the zipper teeth, without blocking the zip from moving.

My deepest apologies for the shaky footage, I had my phone in my mouth to free up both hands!

⏀Analog Sensors⏀¶

A sensor uses resistance to get a broader range of values. By allowing more or less current through, you can change the brightness of an LED, the frequency of sound, speed of a motor etc.

By varying the resistance of your input, you can change the output. This is why they are called variable resistors.

In designing our sensors we are trying to create a textile interface that allows us to manipulate resistance.

FACTORS THAT EFFECTS RESISTANCE:

DISTANCE: Resistance increases over distance
CONTACT: Some materials are pressure sensitive and will decrease in resistance when pressure is applied to them.
SURFACE AREA: We increase the size of the area for electricity to flow the resistance will decrease.

MAKING AN ANALOG PRESSURE SENSOR

For our first analog pressure sensor we used an amazing material called Velostat..

Velostat is a specific material which decreases in resistance when pressure is applied to it. A button can be created with velostat which acts as a variable resistor in the circuit and can controls the brightness of the LED within our circuit.

Here is the code we used to connect this pressure sensor to an Arduino Uno board and instruct it to read an analog input on pin 0, converts it to resistance, and prints the result to the serial monitor.

Reads an analog input on pin 0, converts it to resistance, and prints the result to the serial monitor.
Using a 9,5k ohm resistor as known resistor
*/
int ledPin = 5;  // LED connected to digital pin 9

int lowerBoundResistance = 500;
int upperBoundResistance = 1500;

// the setup routine runs once when you press reset:
void setup() {
// initialize serial communication at 9600 bits per second:
Serial.begin(9600);
}

// the loop routine runs over and over again forever:
void loop() {
// read the input on analog pin 0:
int sensorValue = analogRead(A0);

// Convert the analog reading (which goes from 0 - 1023) to a voltage (0 - 5V):
float voltage = sensorValue * (5.0 / 1024.0);

int resistorvalue = 9500; 
float I = voltage / resistorvalue;
float VRx = 5 - voltage;
float Rx = VRx / I;
Rx = (5 - voltage) / I;

int mappedValue = map(Rx, lowerBoundResistance, upperBoundResistance, 0, 255);
mappedValue = constrain(mappedValue, 0, 255);

// print out the value you read:
Serial.print("Resistance:");
Serial.print(Rx);
Serial.print(" Ohms");
Serial.print(" and mapped value is ");
Serial.println(mappedValue);
analogWrite(ledPin, mappedValue);
delay(100);
}

MAKING AN ANALOG STRETCH SENSOR WITH CONDUCTIVE THREAD

For our next sensor we used Michelle's Knitting Machine to knit together a swatch of ordinary yarn and conductive thread. As knitwear has a particular STRETCHABILITY we would use the swatch as another variable resistor in a circuit. The more the swatch is stretched the higher the resistance and this variable can be used to effect output

Once we had our swatch we were able to test its conductivity using the multimeter. You can see in the video that we played with the range on the multimeter (2k-20k)to try and get a stable reading. Our swatch had an "okay" conductivity. We would be able to use it as a sensor but we would have a better range by using more conductive thread or changing the blend.

Now that we had our Stretch Sensor we wanted to use a MICROCONTROLLER so that we could map its resistance values and play with the outputs we could create with it.

〠PROGRAMMING SENSOR BEHAVIOUR WITH THE XIAO ESP32S3〠¶

How do I program sensor behaviour?

In short, we use a Microcontrollers such as Arduino or in our case the Xiao ESP32S3 board alongside a software such as Arduino IDE.

In Arduino IDE we can write code to programme our microcontroller. Arduino IDE has a built in compiler which translates the C++ code we type and upload into binary lower level machine code so the microcontroller can read it.

So, it is important to know how the compiler works:

It runs sequentially.
Anything in setup() happens once
Anything in loop() happens forever

If there are errors, copy the message and put it into google.

In the code we can specify the input and outputs communicating with the microcontroller. We do this through the PINS!

This is a pinout for the Xiao ESP32S3 board. It shows the different types of pin which you can use to connect different types of input and outputs such as digital, analogue, touch and PWM pins as well as power and ground pins.

To get to know the way Arduino works we started by using an example code to Fade an LED. This can be found in File> Examples> Basic> Blink.

⌿FADING AN LED WITH THE XIAO BOARD⍀¶

To get to know the way Arduino works we started by using an example code to Fade an LED. This can be found in File> Examples> Basic> Fade.

This code uses a Pulse Width Modulation Pin (~), which can control power delivered to devices by rapidly switching the signal on and off. This can fake analogue output . E.g to fade a led.

I will use this code to document the basics of how the code operates.

We started by using our breadboard to set up our circuit. A breadboard is a tool used to build and test circuits without soldering, making it easy to rearrange components.

On a breadboard, the two bus lines are connected vertically and the smaller horizontal rows are connected horizontally. The ditch separates each side.

For this interaction we needed to set up the circuit as such:

Connect + of the LED through a 220 Ohm resistor to pin A0
Connect - of the LED to GND

⌳Fade LED⌳¶

Connect + of the LED through a 220 Ohm resistor to pin A0
Connect - of the LED to GND

*/

int LED_pin = A0;  // Pin the LED is attached to

int brightness = 0;  // how bright the LED is
int fadeAmount = 5;  // how many points to fade the LED by

// the setup function runs once when you press reset or power the board
void setup() {
// initialize LED_pin as an output
pinMode(LED_pin, OUTPUT);
}

// the loop routine runs over and over again forever:
void loop() {
// set the brightness of the LED:
analogWrite(LED_pin, brightness);

// change the brightness for next time through the loop:
brightness = brightness + fadeAmount;

// reverse the direction of the fading at the ends of the fade:
if (brightness <= 0 || brightness >= 255) {  // if brightness is smaller or equal to 0 or if brightness is bigger or equal to 255
    fadeAmount = -fadeAmount;
}
// wait for 30 milliseconds to see the dimming effect
delay(30);
}

In this code it sets out a few basics:

VARIABLES

A variable is a place to store a piece of data. It has a name, a value, and a type.

You can declare variables to store values like the pin number you want to read or write from.

e.g int LED_pin = A0;  // Pin the LED is attached to.

This creates a variable whose name is LED_pin, pin is A0, and whose type is int. Later on in the program, you can refer to this variable by its name, at which point its pin will be looked up and used.

PREMADE FUNCTIONS

Functions are chunks of code that let us perform different actions. These are built into Arduino IDE so we don’t have describe the whole instruction.

The syntax of functions go as follows, always ending with a semi colon:

Function name (parameter);

e.g
pinMode(LED_pin, OUTPUT);// This configures the LED as the output.

analogWrite(LED_pin, brightness); // The microcontroller is set to write the brightness of the LED.

delay(30); // wait for 30 milliseconds to see the dimming effect

Functions are either in void setup(), where they happen once or in void loop() where they are repeated forever or you tell it not to.

Conditionals

Conditionals allow you to ask questions and make decisions. For example, is the button pressed? If yes turn on the light.

In this case if the brightness is smaller or equal to 0 or greater than or equal to 255 the fading amount will reverse.

if (brightness <= 0 || brightness >= 255) {  
fadeAmount = -fadeAmount;
}

You can add multiple conditionals and also add else clauses such as:

    else{
    FUNCTION
    }

As you can see this code acts to increase the brightness of the LED by 5 until it hits 255 and then it reverses hits 0, delays for 30 milliseconds then begins again.

CONTROLLING A LED WITH A LIGHT DEPENDANT RESISTOR¶

To our original set up, we connected one leg of the LDR to pin A1 through a 10k ohm resistor and then to ground; and the other leg to 3.3V.

The code we used to map LDR input to LED output was:

int sensor_pin = A1;  // Pin the LDR is attached to
int LED_pin = A0;     // Pin the LED is attached to
int brightness = 0;   // how bright the LED is

void setup() {
// initialize serial communication at 115200 bits per second:
Serial.begin(115200);

// initialising LED pin as an output.
pinMode(LED_pin, OUTPUT);
}

Then the code we added to read the Analog input from the LDR and print it in the Serial Monitor so we can see the changes and range of resistance:

void setup() {
// initialize serial communication at 115200 bits per second:
Serial.begin(115200);
pinMode(LED_pin, OUTPUT);
}

// the loop routine runs over and over again forever:
void loop() {
// read the input on analog pin 0:
int sensorValue = analogRead(sensor_pin);
// print out the value you read:
Serial.println("Reading of Sensor A1:");
Serial.println(sensorValue);
brightness= map(sensorValue, 2000, 4000,0, 255);
brightness= constrain(brightness, 0, 255);
Serial.println("Mapped brightness value:");
Serial.println(brightness);
analogWrite(LED_pin, brightness);
delay(1);  // delay in between reads for stability

}

This code allows us to use the serial monitor to send and receive messages from our microcontroller. We will mainly use this for debugging and reading sensor values.

The function Serial.println(“"); sends a message in the serial monitor.

Similarly we used the mapping function to get better readings and control the range of the resistor as it went outside its limits. With this function we can map a number from one range onto another: controlling the values of a sensor range.

The Mapping Syntax is 
Map(value, fromLow, fromHigh, to Low, toHigh)
e.g brightness= map(sensorValue, 2000, 4000,0, 255);
// which maps the LDR range (sensor value) onto the range of LED.

Here are more shaky videos of the results:

⚡︎PROGRAMMING THE BEHAVIOUR OF THE ANALOG STRETCH SENSOR⚡︎¶

☏SYNTHY FUN TIME☏¶

First we had great fun connecting our stretch sensor to Michelle's Korg Volca Sample/ JBL speaker set up. We used the resistance of the stretch sensor to trigger the sample sounds and were able to effect and distort the sound and make a whole lot of noise. I would love to do this again with a sensor with more range.

␥STRETCH SENSOR CONTROLS LED OUTPUT¶

Next, we used our stretch sensor to control the output of an LED. First we programmed the microcontroller to use the input of the sensor being touched to turn the LED ON and OFF..

To set this up we connect + of the LED through a 220 Ohm resistor to pin A0 and connect - of the LED to GND.

We wanted to turn on an LED when touch pin T2 is touched so we connect a jumper/aligator wire from the T2 pin to the stretch sensor (shown in the circuit as a variable resistor).

The code we used to program this behaviour is below:

*/

int LED_pin = A0;    // Pin the LED is attached to
int touch_pin = T2;  // Pin that we're going to touch

// change with your threshold value
int threshold = 60000;
// variable for storing the touch pin value
int touchValue;

// the setup function runs once when you press reset or power the board
void setup() {
// initialize serial communication at 115200 bits per second:
Serial.begin(115200);
// initialize LED_pin as an output
pinMode(LED_pin, OUTPUT);
}

// the loop function runs over and over again forever
void loop() {
touchValue = touchRead(touch_pin);
Serial.println(touchValue);

if (touchValue > threshold) {
    // turn LED on
    digitalWrite(LED_pin, HIGH);
    Serial.println("LED on");
} else {
    // turn LED off
    digitalWrite(LED_pin, LOW);
    Serial.println("LED off");
}
delay(50);

// while (touch_pin == 1) {
//   digitalWrite(LED_pin, HIGH);  // keep the LED on as long as touch pin 1 is touched (HIGH)
// }

// while (touch_pin == 0) {
//   digitalWrite(LED_pin, LOW);  // keep the LED off as long as touch pin 1 is not touched (LOW)
// }
}

As you can see from the code we also used the Serial Print function to tell us in the Serial Monitor when the LED is ON and OFF and also the touchValue from the stretch sensor:

We then modified this code so that the brightness was effected by the amount of stretch put on the sensor.

The code is below:

*/

int LED_pin = A0;    // Pin the LED is attached to
int touch_pin = T2;  // Pin that we're going to touch
int brightness = 1;   // how bright the LED is

// change with your threshold value
int threshold = 65000;
// variable for storing the touch pin value
int touchValue;

// the setup function runs once when you press reset or power the board
void setup() {
// initialize serial communication at 115200 bits per second:
Serial.begin(115200);
// initialize LED_pin as an output
pinMode(LED_pin, OUTPUT);
}

// the loop function runs over and over again forever
void loop() {
touchValue = touchRead(touch_pin);
Serial.println(touchValue);

brightness = constrain(touchValue, 200, 100000);
// the min and max values for the LDR depend on the light conditions and the interaction you want to achieve. the min and max values for the LED range from 0-255
brightness = map(touchValue, 200, 100000, 0, 255);

    // set the brightness of the LED with the mapped touchValue:
analogWrite(LED_pin, brightness);

delay(50);
}

Here are the results:

⑇STRETCH SENSOR CONTROLS AUDIO OUTPUT⑇¶

Finally, we used the ToneMelody function and a Piezo Buzzer to create a sound output from our stretch sensor.

CORRECTION TO THE SCHEMATIC ABOVE! The negative of the piezo buzzer should be connected to GROUND NOT 5V as it is in the image!

The set up was the same as before but we added a Pieso buzzer in Pin D2 which was then connected to Ground.

*/

#include "pitch.h"

int speaker_pin = A2;  // Pin the LED is attached to
int touch_pin = T2;    // Pin that we're going to touch
int melody[] = {
NOTE_C4, NOTE_G3, NOTE_G3, NOTE_A3, NOTE_G3, 0, NOTE_B3, NOTE_C4
};

// note durations: 4 = quarter note, 8 = eighth note, etc.:
int noteDurations[] = {
4, 8, 8, 4, 4, 4, 4, 4
};

// change with your threshold value
int threshold = 100000;
// variable for storing the touch pin value
int touchValue;

// the setup function runs once when you press reset or power the board
void setup() {
// initialize serial communication at 115200 bits per second:
Serial.begin(115200);
// initialize LED_pin as an output
pinMode(A2, OUTPUT);
}

// the loop function runs over and over again forever
void loop() {
touchValue = touchRead(touch_pin);
Serial.println(touchValue);

if (touchValue > threshold) {


    for (int thisNote = 0; thisNote < 8; thisNote++) {

    // to calculate the note duration, take one second divided by the note type.
    //e.g. quarter note = 1000 / 4, eighth note = 1000/8, etc.
    int noteDuration = 1000 / noteDurations[thisNote];
tone(1, melody[thisNote], noteDuration);

// to distinguish the notes, set a minimum time between them.
// the note's duration + 30% seems to work well:
int pauseBetweenNotes = noteDuration * 1.30;
delay(pauseBetweenNotes);
// stop the tone playing:
noTone(1);

delay(50);
}

And this is the pitch values or the "pitch.h" refered to in the code downloadable here: ²

Here are the results:

Having used the Touch pins on the Xiao board I am now really keen to make a capacitive touch slider/wheel like I showed in my inspiration examples. I began the project but didn't have time this week to complete it- BUT WATCH THIS SPACE:

⚙︎ANALOG SENSOR SWATCH⚙︎¶

I wanted to incorperate all we had learnt with our stretch sensor into my analog swatch. This meant I had to battle with integrating the Xiao Board into the textile as well as ensuring strong connections between all the components.

I decided to try and make a swatch with LED and Sound output so that I could use the swatch to run all the code we had worked on that uses the sensor connected to a touch pin.

SCHEMATIC AND SWATCH CORRECTION! For the audio output section of the circuit, the negative connection of the speaker should be connected to Ground NOT 5V. This correction will also have to be made to the swatch traces in the image below when I replace the speaker with a working one!

I discoved quickly that this design would require me to carefully solder the microcontroller to very thin traces so that nothing would touch and cause a short circuit. I decided to use special pin extenders and fabric tape (which I cut very thin) to make these connections and was very careful to keep the paths seperate with the non conductive fabric.

This is the final result! Its a bit ugly but it was just an exercise in integrating microcontrollers and hard and soft connections! We will make it pretty next time! Unfortunately my speaker was broken and I didn't have time to get another before the upload but I will update this with the audio output when I can. For now please enjoy watching my stretch sensor control the brightness of the embedded LED:

The last video shows my Serial Monitor readings and you can see the wide range I was getting from the stretch sensor!

This was so much fun and is definetly laying the foundations for some exciting projects!

Fabrication files¶

File: Lisa Stark's etextile Vocabulary List. ↩
File: pitch.h file ↩