loading

Here I sit after 1am finalizing this projects details after a week of barely any sleep while waiting for the glue on the first half of my LED lights to dry and I can't help but wonder if this particular project was worth the time, stress, pain, and money that was sunk into it. I love blinking lights, and adore props that incorporate them, so I can only hope that, after the exhaustion of college finals wear off, I will be able to appreciate this project more. If you feel that this particular project will be worth it, then here are the supplies that you'll want to have handy. (Keep in mind that this is currently a work in progress as the touch sensors are currently not functioning properly.)

Step 1: Supply Gathering

Supply list:

- Wire cutters

- Wire strippers

- Soldering iron

- Sponge

- Digital Multimeter

- Breadboard (and your preferred wires for using your breadboard)

- "Arduino Uno"

- an individual LED light (for breadboarding purposes)

- 4k ohm resistor

- 1m ohm resistor

- barrel plug

- a kill switch of some kind (preferably a button that can lock in the on and off position, but an actual switch will do as well)

- "Flora RGB Smart NeoPixel version 2 - Sheet of 20" (My wings have a total of 71 individual lights on them. If you want the same results, you'll want 4 of these sheets.)

- "Silicone Cover Stranded-Core Wire - 2m 30AWG White" (Order as needed. I wound up needing much more than expected and even 20m of this wire wasn't enough.)

- "UBEC DC/DC Step-Down (Buck) Converter - 5V @ 3A output"

- "11.1V 2200mAh 25C Li-Poly Battery Pack with Dean Connector for 400/500 Class RC Helicopter OR Airsoft Guns/Rifles"

- "Tenergy 1-4 Cells Li-PO/Li-Fe Balance Airsoft Battery Charger"

- Pieces of copper (bits of a decently thick wire work well).

- "Amazing Putty 16Oz Casting Resin Kit"

- Small paper cups

- Two trash bags

- "E6000 Fabri-Fuse Adhesive"

- Bobby pins, clothes pins, or anything in general that can hold the wires in place without damaging the wings while the glue dries.

- Sewing needle and thread or sewing machine and thread

Step 2: Solder the Lights

First of all, you'll want to break the Neopixel lights off of their boards. Be sure to but them back in their bag and don't leave them laying around. They are fairly small and it's very easy to misplace a few of them.

Once all of your lights are free, you can spread out the wings and begin placing the lights where you want them (be sure to keep count as you place them so that you know how many you'll need to complete the project.

Take your wire and begin measuring and cutting pieces off so that the pieces are long enough to reach from one light to the next one (be sure to measure an extra inch or so for soldering purposes).

After you have plenty of wiring cut out, the soldering can begin. Pigtail the wires for the positive and negative joints. Connect the positive side of each light to the positive side of the lights beside it. Do the same for the negative side. Be sure that the arrows are all connecting in the same direction as the wires that connect to the arrows control your data flow. You will need two strands of lights, one that holds 33 Neopixels while the other holds 34 Neopixels.

You should go into this step with the knowledge that it will take a while. (I'm not the most skilled with this process and my soldering was spread out to be three full afternoons per week for three weeks straight.)

Step 3: Battery

The next step involves working with the battery. Fair warning, most of these batteries seem to come fully charged. Be sure to test it with your multimeter before messing with it. If it is charged, then don't touch both the negative and positive wires at the same time or you'll get a bit of a shock.

Remove any plugs or ports from the positive and negative wires of the battery and strip the tips. Solder two wires (preferably black for the moment, if you don't have black wire handy then feel free to mark the white wire with a black marker of some kind) to the black wire of the battery. This is the negative side and one of these wires will eventually attach to the negative side of the Neopixels.

Attach the kill switch of your choice to the red wire. Then solder two more wires (preferably red or marked red in some way) onto the opposite prong of the kill switch so that the line of power can continue. One of the red wires can now be soldered to the 5V step-down converter while the other connects to the red wire of the barrel plug.

The black wires get the same treatment; one going to the 5V converter and the other going to the black wire of the barrel plug.

On the bottom of the 5V converter, attach two white wires to the black wire and two different white wires to the red wire. Be sure that these wires are long enough to reach up over your shoulders and then flow down tot he height that you want the Neopixels to rest on your wings.

Once you have this done, wrap any exposed wire in electrical tape to prevent accidental shortages and then wrap the long white wires up in twist ties, saran wrap, rubber bands, or any other such thing in order to prevent them from tangling.

Step 4: Wiring the Arduino Uno

One end of the 4k ohm resistor gets attached to PIN 2 on the Arduino Uno. The other end gets attached to two white wires long enough to reach up over your shoulders and then flow down to the height that you want the Neopixels to rest at on your wings. Wrap these wires neatly, just as you have with the previous long white wires, to prevent them from being tangled.

These two wires get attached to the data lines of the Neopixels (be sure that the arrows are pointing away from the Arduino when you attach them).

While you are attaching these wires, it would be best if you went ahead and attached the positive power line of the Neopixels to the red side of the battery and the negative power line to the black side of the battery. Be sure to attach each strand to a different one of the four battery wires. No battery wire should have more than one wire going to the Neopixels from it.

(for the capacitive sensor that is currently not working) The 1m ohm resistor has one leg bent so that it stands up vertically on the Arduino. The straight leg then goes into PIN 4 while the bent one goes into PIN 5. Attach two long white wires to the bent corner of the resistor. Measure the wires out to that they end where you would like your touch sensor to be (I want mine to be on the sticks of the wings). Cut the wires with an extra half-inch of length. Cut two small pieces of copper (as long as the tip of your thumb) and then attach one piece of copper to the end of each wire. Wrap the wire to prevent it from tangling.

Step 5: Coding

I found the following code on this website https://github.com/FastLED/FastLED and then altered it slightly to suit my needs while commenting out the information that I didn't need.

#include

#ifdef __AVR__ #include #endif

//#define PIN1 4

#define PIN2 2

//#define BRIGHTNESS 50

#define BRIGHTNESS 50

//Adafruit_NeoPixel strip = Adafruit_NeoPixel(34, PIN1, NEO_GRB + NEO_KHZ800); Adafruit_NeoPixel strip2 = Adafruit_NeoPixel(71, PIN2, NEO_GRB + NEO_KHZ800);

int gamma[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 5, 5, 5, 5, 6, 6, 6, 6, 7, 7, 7, 7, 8, 8, 8, 9, 9, 9, 10, 10, 10, 11, 11, 11, 12, 12, 13, 13, 13, 14, 14, 15, 15, 16, 16, 17, 17, 18, 18, 19, 19, 20, 20, 21, 21, 22, 22, 23, 24, 24, 25, 25, 26, 27, 27, 28, 29, 29, 30, 31, 32, 32, 33, 34, 35, 35, 36, 37, 38, 39, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 50, 51, 52, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 66, 67, 68, 69, 70, 72, 73, 74, 75, 77, 78, 79, 81, 82, 83, 85, 86, 87, 89, 90, 92, 93, 95, 96, 98, 99,101,102,104,105,107,109,110,112,114, 115,117,119,120,122,124,126,127,129,131,133,135,137,138,140,142, 144,146,148,150,152,154,156,158,160,162,164,167,169,171,173,175, 177,180,182,184,186,189,191,193,196,198,200,203,205,208,210,213, 215,218,220,223,225,228,231,233,236,239,241,244,247,249,252,255 };

void setup() { Serial.begin(115200); // This is for Trinket 5V 16MHz, you can remove these three lines if you are not using a Trinket // #if defined (__AVR_ATtiny85__) // if (F_CPU == 16000000) clock_prescale_set(clock_div_1); // #endif // End of trinket special code //strip.setBrightness(BRIGHTNESS); //strip.begin(); //strip.show(); // Initialize all pixels to 'off' strip2.setBrightness(BRIGHTNESS); strip2.begin(); strip2.show(); // Initialize all pixels to 'off' }

void loop() { // Some example procedures showing how to display to the pixels: //colorWipe(strip.Color(255,105,180), 500); // Pink //colorWipe(strip.Color(186,85,211), 500); // Purple //colorWipe(strip.Color(0,191,255), 500); // Blue //colorWipe(strip.Color(255,255,51), 500); // Yellow colorWipe(strip2.Color(255,105,180), 500); // Pink colorWipe(strip2.Color(186,85,211), 500); // Purple colorWipe(strip2.Color(0,191,255), 500); // Blue colorWipe(strip2.Color(255,255,51), 500); // Yellow

// whiteOverRainbow(20,75,5); // // pulseWhite(5); // // // fullWhite(); // // delay(2000); // // rainbowFade2White(3,3,1);

}

// Fill the dots one after the other with a color void colorWipe(uint32_t c, uint8_t wait) { //for(uint16_t i=0; i

//void pulseWhite(uint8_t wait) { // for(int j = 0; j < 256 ; j++){ // for(uint16_t i=0; i= 0 ; j--){ // for(uint16_t i=0; i 255 - fadeMax ){ // fadeVal--; // } // // strip.show(); // delay(wait); // } // // } // // // // delay(500); // // // for(int k = 0 ; k < whiteLoops ; k ++){ // // for(int j = 0; j < 256 ; j++){ // // for(uint16_t i=0; i < strip.numPixels(); i++) { // strip.setPixelColor(i, strip.Color(0,0,0, gamma[j] ) ); // } // strip.show(); // } // // delay(2000); // for(int j = 255; j >= 0 ; j--){ // // for(uint16_t i=0; i < strip.numPixels(); i++) { // strip.setPixelColor(i, strip.Color(0,0,0, gamma[j] ) ); // } // strip.show(); // } // } // // delay(500); // // //} // //void whiteOverRainbow(uint8_t wait, uint8_t whiteSpeed, uint8_t whiteLength ) { // // if(whiteLength >= strip.numPixels()) whiteLength = strip.numPixels() - 1; // // int head = whiteLength - 1; // int tail = 0; // // int loops = 3; // int loopNum = 0; // // static unsigned long lastTime = 0; // // // while(true){ // for(int j=0; j<256; j++) { // for(uint16_t i=0; i= tail && i <= head) || (tail > head && i >= tail) || (tail > head && i <= head) ){ // strip.setPixelColor(i, strip.Color(0,0,0, 255 ) ); // } // else{ // strip.setPixelColor(i, Wheel(((i * 256 / strip.numPixels()) + j) & 255)); // } // // } // // if(millis() - lastTime > whiteSpeed) { // head++; // tail++; // if(head == strip.numPixels()){ // loopNum++; // } // lastTime = millis(); // } // // if(loopNum == loops) return; // // head%=strip.numPixels(); // tail%=strip.numPixels(); // strip.show(); // delay(wait); // } // } // //} //void fullWhite() { // // for(uint16_t i=0; i> 8); //} //uint8_t green(uint32_t c) { // return (c >> 16); //} //uint8_t blue(uint32_t c) { // return (c); //} //

Step 6: Coding Error for Touch Sensor

This is less of a step and more of a side note as to why the capacitive sensor is not working.

When coding for the sensor there was an error in the if/else statement. The main issue seemed to be in the if statement. Whenever any information was placed inside of the if statement to tell the lights what to do when the sensor was touched, it caused an issue. Whenever the program would reach this step and attempt to run this step, the serial monitor would suddenly freeze and either become unresponsive or become so slow that the next number in the monitor wouldn't appear for over a minute.

Below is the in-progress coding used for the sensor. I'm hoping to eventually figure out what's going wrong with it.

#include

/* CapitiveSense Library Demo Sketch Paul Badger 2008 Uses a high value resistor e.g. 10M between send pin and receive pin Resistor effects sensitivity, experiment with values, 50K - 50M. Larger resistor values yield larger sensor values. Receive pin is the sensor pin - try different amounts of foil/metal on this pin */

CapacitiveSensor cs_4_5 = CapacitiveSensor(4, 5); // 10M resistor between pins 4 & 5, pin 5 is sensor pin, add a wire and or foil if desired

#include #ifdef __AVR__ #include #endif

//#define PIN1 4

#define PIN2 2

#define BRIGHTNESS 50

//Adafruit_NeoPixel strip = Adafruit_NeoPixel(34, PIN1, NEO_GRB + NEO_KHZ800); Adafruit_NeoPixel strip2 = Adafruit_NeoPixel(71, PIN2, NEO_GRB + NEO_KHZ800);

void setup() { cs_4_5.set_CS_AutocaL_Millis(0xFFFFFFFF); // turn off autocalibrate on channel 1 - just as an example Serial.begin(9600); // This is for Trinket 5V 16MHz, you can remove these three lines if you are not using a Trinket // #if defined (__AVR_ATtiny85__) // if (F_CPU == 16000000) clock_prescale_set(clock_div_1); // #endif // End of trinket special code //strip.setBrightness(BRIGHTNESS); //strip.begin(); //strip.show(); // Initialize all pixels to 'off' strip2.setBrightness(BRIGHTNESS); strip2.begin(); strip2.show(); // Initialize all pixels to 'off' }

void loop() {

int total1 = cs_4_5.capacitiveSensor(30); Serial.println(total1); if (total1> 800) { colorWipe(strip2.Color(255, 105, 180), 500); // Pink colorWipe(strip2.Color(186, 85, 211), 500); // Purple colorWipe(strip2.Color(0, 191, 255), 500); // Blue colorWipe(strip2.Color(255, 255, 51), 500); // Yellow } else { }

}

// Fill the dots one after the other with a color void colorWipe(uint32_t c, uint8_t wait) {

for (uint16_t i = 0; i < strip2.numPixels(); i++) { strip2.setPixelColor(i, c); strip2.show(); delay(wait); }

}

//}

//void pulseWhite(uint8_t wait) { // for(int j = 0; j < 256 ; j++){ // for(uint16_t i=0; i= 0 ; j--){ // for(uint16_t i=0; i 255 - fadeMax ){ // fadeVal--; // } // // strip.show(); // delay(wait); // } // // } // // // // delay(500); // // // for(int k = 0 ; k < whiteLoops ; k ++){ // // for(int j = 0; j < 256 ; j++){ // // for(uint16_t i=0; i < strip.numPixels(); i++) { // strip.setPixelColor(i, strip.Color(0,0,0, gamma[j] ) ); // } // strip.show(); // } // // delay(2000); // for(int j = 255; j >= 0 ; j--){ // // for(uint16_t i=0; i < strip.numPixels(); i++) { // strip.setPixelColor(i, strip.Color(0,0,0, gamma[j] ) ); // } // strip.show(); // } // } // // delay(500); // // //} // //void whiteOverRainbow(uint8_t wait, uint8_t whiteSpeed, uint8_t whiteLength ) { // // if(whiteLength >= strip.numPixels()) whiteLength = strip.numPixels() - 1; // // int head = whiteLength - 1; // int tail = 0; // // int loops = 3; // int loopNum = 0; // // static unsigned long lastTime = 0; // // // while(true){ // for(int j=0; j<256; j++) { // for(uint16_t i=0; i= tail && i <= head) || (tail > head && i >= tail) || (tail > head && i <= head) ){ // strip.setPixelColor(i, strip.Color(0,0,0, 255 ) ); // } // else{ // strip.setPixelColor(i, Wheel(((i * 256 / strip.numPixels()) + j) & 255)); // } // // } // // if(millis() - lastTime > whiteSpeed) { // head++; // tail++; // if(head == strip.numPixels()){ // loopNum++; // } // lastTime = millis(); // } // // if(loopNum == loops) return; // // head%=strip.numPixels(); // tail%=strip.numPixels(); // strip.show(); // delay(wait); // } // } // //} //void fullWhite() { // // for(uint16_t i=0; i> 8); //} //uint8_t green(uint32_t c) { // return (c >> 16); //} //uint8_t blue(uint32_t c) { // return (c); //} //

Step 7: Resin and Glue

Fair warning: these steps take forever because both the resin and the glue require time to dry. The resin takes 10-15 minutes, but only a few lights can be done at a time. The glue takes 8 hours to dry solid, though I seem to be able to get away with slight movements only an hour or so after application with a fan blowing on them.

Do a test run to ensure that your lights are turning on before coating them in resin. Once the resin and glue are on, you will not be able to adjust any of them in any way.

If the lights are working, then remove all electrical tape and use hot glue to insulate the exposed wire (on everything except for the copper of the capacitive sensors).

The resin is simple. Follow the instructions of the package when it comes to mixing the resin and then smear the resin on one side of a few lights. Repeat the process until both sides of every light are dry. Be sure to cut open some trash bags and lay them out on your work surface, it will help keep the resin from making a mess and will make it easy to lift your lights up once the resin is dry.

The gluing process is just as labor intensive. The number of lights you can glue at one time depends on the number of non-damaging clips or pins that you have. I can do around a third of my lights at a time because of the number of bobby pins I currently own. Lay your lights where you want them. I wanted mine behind the wings and a fair distance from the bottom of the wings to help prevent them from getting too abused. I folded the excess fabric out of the way to prevent it from getting bunched up as I bobby pinned the wires on either side of each light.

Once the lights are held in place, you can begin gluing. At first, I glued on the opposite side of the fabric rather than gluing directly on to the lights. This allowed the glue to leak through and fully connected the lights to the opposite side of the fabric. Once this layer is done, it is simple enough to run an extra bit of glue along the edges of each light to fasten it a bit more thoroughly.

At this point the capacitive sensors can also be glued into place if you plan on using them.

Step 8: Sewing

It is recommended that the wires receive either a zig-zag stitch in order to hold them in place and prevent them from catching on too many things.

Step 9: Insulating the Arduino

Screwing the board to a small piece of wood or hot-gluing the four corners of it to a small piece of wood is recommended. It is best to glue a pice of wood to the top as well. Whatever you do, do not block the ports of the Arduino.

Step 10: Battery Pack

The final step is to either make or find a backpack that is the right size to hold the Arduino, the battery, the step-down converter- and any excess wire that you didn't want to cut (neatly wrap the wire before putting it into the bag).

About This Instructable

323views

5favorites

License:

More by ks51:LED Isis Wings (with non-functioning capacitive touch sensors) 
Add instructable to: