Introduction: Turn Signal Suspenders
Here is a link to a video of them working! http://youtu.be/b04B_yZ8EhY
Inspired by the turn signal sweater. It sounded great, except I don't wear sweaters in summer noon heat, or on cold winter days. Enter suspenders!
I have thought of two major improvements I would like to make, which I included in the tutorial.
I had toyed with the idea of adding sound to it, but that was over-ambitious for the end of the semester.
PS, one improvement I forgot to mention in the tutorial itself was a front-visible light or sound to indicate what command was being executed, since I can't see the lights when they are on my back, and they have proven to be fickle.
Step 1: You're Gonna Want Some Supplies
- 1/4 of a very large neopixel ring!
- Don't bother buying the other 3 pieces unless you have a separate power source, and decide to make a secure frame for them to sit in. (unlike me... wa-waa!)
- 1 Arduino
- I got the lilypad USB, because I like avoiding lego-sized pieces that are important not to lose. It also sports a built in power source/ battery charger
- 1 Lithium ion battery to go with your lilypad.
- I chose an over-kill battery
- Conductive Thread
- Normal Thread (Orange worked great)
- Sewing Needle (I think embroidery needles work best for threading the thicker conductive stuff)
- SOLDERING SUPPLIES
- Very small sized knitting needles,
- I meant to use # 0, but accidentally ended up using #1, still good!
- Wires-->I picked up a telephone wire and it is *perfect*
- Glove(s)
- I had some old percussion gloves. Realize that I want to get some rubbber as a sandwich between threads and my skin... maybe buying a latex glove and putting that on top of the fabric, then more fabric (for sewing threads) on top of the rubber.
- ANKLE bands
- Suspenders
- I got mine reflective for obvious benefits, they came from amazon. huzzah!
Stuff from my class
- Resistive string/yarn stuff
- a small square of conductive fabric
- such knowledge. very help. wow.
On Further Reflection
- maybe normal Ribbon
- I spent 10 monies on 2 yards of conductive ribbon, only needed 1, and its resistance was way too much to get the 'required' voltage over to my lights, ended up using the TN wire, but it was nice to have a ribbon to guide it, or whatever.
- maybe VELCRO
- sewing a glove and two bands to a pair of suspenders makes for a very awkward thing to pick up/collect. Velcro on the bands would keep the options open.
*This is me being excited about my bands. I hadn't started sewing yet.
Step 2: Knit Those Resistive Pads!
I was averaging 5 stitches per finger, and went in a simple garter stitch until it was the length of the area between my second and third knuckles per finger.
if you don't know how to knit, consider resistive fabric (if you can find it), or just google "cast on" "garter stitch" and "bind off"
Here's a link on the garter stitch:
Step 3: Sew on the Pads...
I was just winging it.
I like to use NORMAL THREAD for attaching things together, and just save the conductive thread for "wiring".
If you are blessed with enough hand-eye coordination/pain tolerance to wear the glove while sewing, I would recommend. Great for avoiding the tragedy of sewing your finger shut and having to cut it out and tie another thread knot.
Step 4: Sew in the Conductive Thread
I started with a little rectangle (This was so awkward I could not take many pictures)
I folded it around my thumb like wrapping paper,
and cut slits into the creases, so I could over-lap them.
sew it on the inside, so that the outside looks good.
Not methodical or pro.
Started sewing around the bottom of the connection, and did my best to attach the ribbing-like bits together.
Very awkward to try and be accurate with, since I needed to keep turning it inside out. Too small to pin really.
It ended up making the slightly too short thumb too long! Partly me being afraid of sewing too much fabric down. easily fixed, I think.
Step 5: A Note on the Glove Circuit
FYI, the plan is that A pins and (+) are connected to the 4 fingers, then (-) will be your thumb, which completes the circuit and gives the A pin something different to sense depending on where along the length that you touch the pad.
(The idea from my mentor was that if A is in the middle, it will get full voltage when nothing is touching, a mix between 0 and full when touching the middle-to-finger-tip segment, and ZERO when connecting (-) and the (+) anchor before the A pin. (keep some resistive stuff between them to prevent damage to the arduino) Once I had it all sewn and reading values, though, that isn't quite what happened... But it does have variety, so that's what counts. Perhaps sewing everything but an A pin and experimenting with returned values depending on alligator clip placement would be worthwhile.)
You will have a data line leaving any digital pin, as well as (+) & (-) running along the telephone wire to the neopixels on your back.
Step 6: Add Lilypad to Glove
If you want to make a fabric-rubber-fabric sandwich to protect your hand from shorts and/or rubber-on-skin sweat, now is the time to do it! Well, maybe before the knit pads, but this definitely for ALL of the crossing lines on the top of your hand.
>>>>> I realized that I have 1 knit hobo glove that fits under this one just fine. There is my solution! Easy peasy.
Fit the lilypad To a good spot. I wanted all of the A pins flaring out to my fingers.
I held onto a convenient spool that is roughly the diameter of a bicycle handle to tighten the glove realistically, and sort of awkwardly marked an anchor for the first A pin with an extra sewing pin or two. Let it be noted: I did not draw blood. skills.
Attach the A pins to the center of the resistive pads, and the (+) pin to their close ends.
See the next step before attempting this.
Step 7: Be Very Creative in This, or Get Some Wire
But how to get the (+) over without shorting the lines? I decided to go under the arduino, and come out in the gaps between pins. pretty darn risky! Oh, what I would do for insulated wires. Fabric is as changeable and wiggly in such a situation as skin on someones back when you're trying to walk on it. Of course, using wire with a lily pad is rather awkward as well.
I continued with my "wear it as I go" technique. Resulted in some itchy/stingy pricks the next day, but no real injury.
I was rather floored about how to get the (-) over to my thumb... but realized I could just snag some excess ribbon-wire! I anchored the pin and sewed into a conductive line at the same time.
From there, sewing into the same ribbon line at the other end of the lilypad and connecting it to the thumb is a simple task.
Step 8: Make a Friend
Because you only think you're almost done sewing...
Step 9: Pin the Glove, Ribbon, and Suspenders Together
You are going to want a friend!
Remember that the RIBBON is not elastic, so if you put it on while they are stretched out, it will be a much more accurate span. Stretch your arm, in case you decide to signal anyway, or whatever.
I was vain, and tried to angle the ribbon to make an intriguing diagonal tan line when my arm is more stretched as it would be on a bike.
************
If you want to add velcro to the arm bands, sew 1/2 of the velcro onto the band FIRST,
stick the other part on,
and then pin your ribbon to the top layer.
************
Leave just a little more slack on the suspenders in case you decide to wear this over bulky cloths like a winter jacket.
I did this almost immediately, bad idea. I had to carry the super awkward set around with me just to work on the glove. Suspenders like to slide around, and the heavy clips would pull them off of desks and tables if I was not careful. So sew them together last!
***********
If you don't want any ribbon, just skip to pinning and sewing the telephone wire to the same items.
Step 10: Solder Your Neopixel, and Place on Suspenders
You don't need the extra loops I added to the side, it will sew VERY well on its own between pixels.
I was using wire from CAT6 ethernet cord... the solid copper broke far too easily! (Enter horrible soldering drama) Anything with multiple little strands making up a wire will hold up better.
Don't make ANY loops, sewing is pointless, for the resistance was too much for my weak (3.3V) voltage. If I do it again I will solder the telephone wire directly to the neopixels.
Step 11: Attach Telephone Wire!
make sure that it is long enough to strip the ends off of.
Start with ONE end cut, you might cut through some super fine wire in your first attempts at stripping them, and need the extra length for practice.
Getting the grey bit off is difficult, I ended up pushing the tip of the scissors barely into the center of a clean horizontal cut, and making tiny snips along the side.
I grazed the individual wires between scissor blades very carefully, trying to rotate the snippers around it without gouging through the super, super thin metal fibers.
Once I saw a promising line on two halves, I started pulling the insulation off.
Again, far too hand-intensive for pictures, sorry.
Once you have a good length of stripped wires on one end, pin the whole thing along your ribbon. Give it the same amount of slack. (Pinning the material close on either side of the wire will pinch it down, it has good friction)
Step 12: Prep Wire Ends for Sewing, and Pin
Use needle nose pliers or the similar jewler's tool to coil the wires into loops you can sew around.
MAKE A NOTE OF WHAT COLOR GOES TO WHAT.
I was arrogant, more on that later.
I had made notches in the thick side of the wire for my thread to get wedged in and really grab a hold.
Not necessary, with enough spaced out loops you will have a firmly stuck, grippy wire. All I did was probably damage the wires. I had 4 loop clumps on the glove, and just 2 per arm band, etc.
If you are only carrying (-) and (+), strip and coil the center wires, and you don't need to worry about any side-damage.
On the glove end top, sew or solder (+), data out pin, and (-) lines to the telephone wires.
Step 13: Attach the End of the Wire to Your Lights
Just solder them!
Here is my mess, clinging to sewing, because I don't have a soldering iron of my own.
THIS IS WHERE you refer to what you wrote earlier, to destroy any chance of becoming confused and sewing the wrong wires down. Man, it is so depressing.
Once I did start to solder, I was again too quick, and put my (-) line on my data in wire, etc etc. Ugh!
Step 14: Upload the Code...
And it SHOULD work.
Even with my wire, there was an intermittent connection. In desperation to bypass it (I only brought 1 alligator clip along) I soldered my (+) line directly to a pad. I suspect my data or (-) is still too dirty of a connection.
In an attempt to get the same display I got from alligator clip testing, I was tugging the main ribbon connection area and clenching my fist, and got a few zaps for my efforts. I wasn't even sweaty. Hence the need for an insulating layer.
I also managed to wrinkle a (-) and (+) thread together and burn a half-dime-sized hold in my glove.
><><><
the leds were giving me a rough time but suddenly decided to work. I shall name it Kitty.
*One red dot is usually all that I get got with the strand test.
Step 15: My Full-capacity Code
/*I did my best to fix the mutilation of my formatting that happened when I pasted my code into the page. Some things had even been cleared/not pasted!
Would be wise to check and make sure something important wasn't commented out once you get it in the Arduino environment.
Original compiles fine, comment if it's broken.*/
int sensor1 = A2; //sewn to my... pointer finger
int sensor2 = A3;//middle int sensor3 = A4; //ring int sensor4 = A5; //pinky
#include //yaaap, want to be including this. see their uberguide for how to install it into your arduino library.
//It's a relatively easy ~3 step process, worth it. The files and instructions are at the following site:
// https://learn.adafruit.com/adafruit-neopixel-uber...
//Then click on the file banner "Sketch" and select Add File from the menue to navigate to where the .h file is saved to add its tab to this project
static int PIN = 10; //if you forget this, where it says PIN down there is gonna get the compiler mad.
//The number is the name of the pin on your lilypad that the data is being sent from.
//the following is straight from the example "strandtest" file
// Parameter 1 = number of pixels in strip
// Parameter 2 = pin number (most are valid)
// Parameter 3 = pixel type flags, add together as needed: (left out the extra info, means little to me) Adafruit_NeoPixel strip = Adafruit_NeoPixel(15, PIN, NEO_GRB + NEO_KHZ800);
//I have 15 pixels, thus that number
/******************************************************************** *********************************************************************
* more set up *
* *
********************************************************************/
void setup() {
//for lights:
strip.begin();
strip.show();
//"Initialize all pixels to 'off'"
// initialize serial communication at 9600 bits per second:
pinMode(sensor1, INPUT); //sets pointer knit potentiometer's pin to INPUT
digitalWrite(sensor1, HIGH);//initializes the sensor
pinMode(sensor2, INPUT); //sets middle knit potentiometer's pin to INPUT
digitalWrite(sensor2, HIGH); //initializes the sensor
pinMode(sensor3, INPUT); //sets ring knit potentiometer's foil pin to INPUT
digitalWrite(sensor3, HIGH); //initializes the sensor
pinMode(sensor4, INPUT); //sets pinky knit potentiometer's pin to INPUT
digitalWrite(sensor4, HIGH); //initializes the sensor
// Serial.begin(9600); }
/******************************************************************** *********************************************************************
* *
* main function *
* *
********************************************************************* ********************************************************************/
void loop() {
int middle=8; //middle light
int right=15; //right end light (highest LED address)
int left=1; //left end light (lowest LED address)
// read the input on analog pin:
//3.3 V is 1024
//0 V is 0
//"SV" short for 'sensor value'
int SV1 = analogRead(sensor1); //300-400 lo 890-950 hi
int SV2 = analogRead(sensor2); //650-700 lo 900-1015 hi
int SV3 = analogRead(sensor3); //min avg 650-700 max avg 1000
int SV4 = analogRead(sensor4); //min 530 max 1024 - avg hi 950 avg lo 650ish
//If blending colors were the desire, mapping 0-250 to the 300-950 as the value of one RGB per finger would be cool pinky could be some weird random mixing RGB equations using the mapped value. eh.
/* //uncomment this section to use the serial print function and get your own finger pads' ranges.
// print out the value you read:
Serial.print("value 1 =") ;
Serial.print(sensorValue1);
Serial.print(" value 2 =") ;
Serial.print(sensorValue2);
Serial.print(" value 3 =") ;
Serial.print(sensorValue3);
Serial.print(" value 4 =") ;
Serial.println(sensorValue4);
*/
/********************************************************************
* IF/THEN response *
********************************************************************/
//set max response range at 950, I think this should keep them from all responding TRUE.
//for now, I will have high/low determine... shoot, number of repeats sounds good. Color too?
//uint16_t repeats=2; //initialized at two >> just throw number into function call!
//POINTER FINGER--->turn right
//300-400 lo 890-950 hi
if ((SV1<=950) && (SV1>=650))
//chose 650 since its about the middle of my "low high end" and higher "low" readings.
{
Right_then(strip.Color(250,140,0),4,middle,right); //can change color here RGB
}
if ((SV1<=649) && (SV1>=0))
{ Right_then(strip.Color(250,0,0),8,middle,right); }
//MIDDLE FINGER--->turn left
//650-700 lo 900-1015 hi
if ((SV2<=950) && (SV2>=775))
{ Left_I_go(strip.Color(250,140,0), 4, middle, left); }
if ((SV2<=774) && (SV2>=0))
{ Left_I_go(strip.Color(250,0,0), 8, middle, left); }
//RING FINGER--->cute blink
//min avg 650-700 max avg 1000
if ((SV3<=950) && (SV3>=840))
{ Notice_me_Cute(strip.Color(0,0,150), 3, left, middle, right); //blue }
if ((SV3<=839) && (SV3>=0)) //not a big difference==lower accuracy==I'm keeping the repeats short to ensure turns can be signaled
{ Notice_me_Cute(strip.Color(127,255,0), 5, left, middle, right); //lime green }
//PINKY--->meh
//min 530 max 1024 - avg hi 950 avg lo 650ish 650+(950-650)/2=middle value I choose
if ((SV4<=960) && (SV4>=800))
{ dualFade(left, right); }
if ((SV4<=799) && (SV4>=0))
{ dualFade2(left, right); }
/********************************************************************
* default blink *
********************************************************************
/later, can try to make it the "cute" one by having a generic counter, saying counter++; every loop,
//and using a % 8 to be tricky about making another variable change between 1-7
//...and swapping between + and - ? might need a third variable existing in the "if %8==0" to go %2 with and have a nested if statement about +/-
//'notice me'
for(int i=left; i>=right; i++)
{ //strip.setPixelColor(pixel#,(R,G,B) defined in function feed)
strip.setPixelColor(i,255,215,0); //"gold" color
strip.show();
}
delay(300);
//put outside of brackets to try and have lights turn on "all at once" then stay on for a bit
//now turn it off
for(int i=right; i>=left; i--)
{ //strip.setPixelColor(pixel#,R,G,B);
strip.setPixelColor(i,0,0,0);
strip.show();
}
delay(300);
// delay in between reads/blinks for stability (was 75 for the serial print.)
//><><><><><
}
/********************************************************************
* END of main function *
********************************************************************
********************************************************************
* *
* SENSOR FUNCTIONS!!!! *
* *
* I love calling functions, its so... CLEAN!!! *
* *
* Needed: blink Left half (pixels 1-8... or is that 0-7?) *
* blink Right half (pixels 8-15... or 7-14?) *
* "notice me" blink (rainbow, sure) *
* for fun: rainbow wipe *
*********************************************************************
* are my leds addressed
[1] [2 [3] [4] [5] [6] [7] [8] [9] [10] [11] [12] [13] [14] [15]
or [0] [1] [2 [3] [4] [5] [6] [7] [8] [9] [10] [11] [12] [13] [14] ?
Will change my internal for() iterations*
********************************************************************
* blink Left *
********************************************************************/
void Left_I_go(uint32_t color, uint16_t repeats, int middle, int left)
//based on colorWipe in strandtest. Here is how the "uint32_t c" was called in 'main()' 50 was the "wait"!
/*colorWipe(strip.Color(255, 0, 0), 50); // Red
colorWipe(strip.Color(0, 255, 0), 50);// Green
colorWipe(strip.Color(0, 0, 255), 50);// Blue */
//strip.Color(_,_,_),repeats,middle,left)
{ //variables
uint8_t wait=20;
uint16_t i;
uint16_t z; //'z' looks different than 'i'
//want it to blink a few times, so making a nested for loop
for(z=0; z<=repeats; z++)
{ for(i=middle; i>=left ; i--)
{
strip.setPixelColor(i,color);
strip.show();
delay(wait); }
//another delay to keep them on for a bit
delay(100);
//now turn it off
//><><
for(i=middle; i>=left; i--)
{ //strip.setPixelColor(pixel#,R,G,B);
strip.setPixelColor(i,0,0,0);
strip.show();
}
delay(100);
//><><
}
}
/********************************************************************
* blink Right *
********************************************************************/
void Right_then(uint32_t color, uint16_t repeats, int middle, int right
) { ////strip.Color(_,_,_),repeats,middle,right)
//variables
uint8_t wait=20; //make SHORT
uint16_t i;
uint16_t z;
//want it to blink a few times, so making a nested for loop
for(z=0; z<=repeats; z++)
{ for(i=middle; i<=right; i++)
{
strip.setPixelColor(i,color);
strip.show();
delay(wait);
}
//another delay to keep them on for a bit
delay(100);
//now turn it OFF
//><><
for(i=middle; i<=right; i++) //note how I flipped > to < and -- to ++
{
strip.setPixelColor(i,0,0,0);
strip.show();
}
delay(100); }
}
/********************************************************************
* cute bumping blink *
********************************************************************/
//hm. maybe there is a way to, um... word. make the default blink part of the void loop(), like put it before any sensor checks, should be fast enough, right? //could add a delay. yeah! //I'll just make this one a cute fancy version, two lights bounching off of each other in the middle and off the ends...
void Notice_me_Cute(uint32_t color, uint16_t repeats, int left, int middle, int right)
{ //strip.Color(_,_,_),repeats,left,middle,right)
//strip.setPixelColor(pixel#,R,G,B);
//variables
uint8_t wait=50; //a bit slower than 20 for the turning
uint16_t i;
uint16_t z;
for(z=0; z<=repeats; z++)
{
//set on and off middle light
strip.setPixelColor(middle,color);
strip.show();
delay(wait);
strip.setPixelColor(middle,0,0,0);
strip.show();
//now for the split
for(i=1;i
{
strip.setPixelColor(middle-i,color); //goes left from center
strip.setPixelColor(middle+i,color); //goes right from center
strip.show(); //shown together?
delay(wait);
//since 'one at a time' need to turn lights off INSIDE for loop
strip.setPixelColor(middle-i,0,0,0);
strip.setPixelColor(middle+i,0,0,0);
strip.show();
}
//now to go back UP to the middle
//checking for a few sensor input right here would be wise if I want it repeating a lot... but I dunno if that's possible/how to
for(i=1; i; i--) //did (middle-1) since I don't want the edges blinking twice, they are hit once when all the rest are gone over twice in a cycle.
{
strip.setPixelColor(middle-i,color); //this should go right from left
strip.setPixelColor(middle+i,color); // and this left from right
strip.show();
delay(wait);
strip.setPixelColor(middle-i,0,0,0);
strip.setPixelColor(middle+i,0,0,0);
strip.show(); }
}
}
/********************************************************************
* dualFade (meh!) *
4th option would be cool to attach to sound or something else instead.
********************************************************************
/something to throw on the pinky since I can't get the rainbow functions in the strandtest to work.
void dualFade(int left, int right)
{
for (int i=0 ; i<255 ; i=i+1)
{
for(int k=left;k<=right;k++)
{
int divide=k%2;
if (divide==0)
strip.setPixelColor(k, i , 0 , 255-i);
else
strip.setPixelColor(k, 0, i, 255-i);
delay(10);
strip.show(); }
}
}
/********************************************************************
* meh 2 *
********************************************************************
/ void dualFade2(int left, int right)
{ for (int i=0 ; i<255 ; i=i+1){
for(int k=left;k<=right;k++)
{ int divide=k%2;
if (divide==0)
strip.setPixelColor(k, i , 255-i ,0 );
else
strip.setPixelColor(k, 0, 255-i, i);
delay(10);
strip.show();
}
}
}
