 
 #define THEATER_SPACING (PIXELS/20)
 
-void theaterChase( unsigned char r , unsigned char g, unsigned char b, unsigned char wait ) {
-  
-  for (int j=0; j< 3 ; j++) {  
-  
-    for (int q=0; q < THEATER_SPACING ; q++) {
-      
-      unsigned int step=0;
-      
-      cli();
-      
-      for (int i=0; i < PIXELS ; i++) {
-        
-        if (step==q) {
-          
-          sendPixel( r , g , b );
-          
-        } else {
-          
-          sendPixel( 0 , 0 , 0 );
-          
-        }
-        
-        step++;
-        
-        if (step==THEATER_SPACING) step =0;
-        
-      }
-      
-      sei();
-      
-      show();
-      delay(wait);
-      
-    }
-    
-  }
-  
-}
-        
+void theaterChase(unsigned char r, unsigned char g, unsigned char b, unsigned char wait) {
+
+	for (int j = 0; j< 3; j++) {
+
+		for (int q = 0; q < THEATER_SPACING; q++) {
+
+			unsigned int step = 0;
+
+			cli();
+
+			for (int i = 0; i < PIXELS; i++) {
+
+				if (step == q) {
+
+					sendPixel(r, g, b);
+
+				}
+				else {
+
+					sendPixel(0, 0, 0);
+
+				}
+
+				step++;
+
+				if (step == THEATER_SPACING) step = 0;
+
+			}
+
+			sei();
+
+			show();
+			delay(wait);
+
+		}
+
+	}
+
+}
+
 
 
 // I rewrite this one from scrtach to use high resolution for the color wheel to look nicer on a *much* bigger string
-                                                                            
-void rainbowCycle(unsigned char frames , unsigned int frameAdvance, unsigned int pixelAdvance ) {
-  
-  // Hue is a number between 0 and 3*256 than defines a mix of r->g->b where
-  // hue of 0 = Full red
-  // hue of 128 = 1/2 red and 1/2 green
-  // hue of 256 = Full Green
-  // hue of 384 = 1/2 green and 1/2 blue
-  // ...
-  
-  unsigned int firstPixelHue = 0;     // Color for the first pixel in the string
-  
-  for(unsigned int j=0; j<frames; j++) {                                  
-    
-    unsigned int currentPixelHue = firstPixelHue;
-       
-    cli();    
-        
-    for(unsigned int i=0; i< PIXELS; i++) {
-      
-      if (currentPixelHue>=(3*256)) {                  // Normalize back down incase we incremented and overflowed
-        currentPixelHue -= (3*256);
-      }
-            
-      unsigned char phase = currentPixelHue >> 8;
-      unsigned char step = currentPixelHue & 0xff;
-                 
-      switch (phase) {
-        
-        case 0: 
-          sendPixel( ~step , step ,  0 );
-          break;
-          
-        case 1: 
-          sendPixel( 0 , ~step , step );
-          break;
-
-        case 2: 
-          sendPixel(  step ,0 , ~step );
-          break;
-          
-      }
-      
-      currentPixelHue+=pixelAdvance;                                      
-      
-                          
-    } 
-    
-    sei();
-    
-    show();
-    
-    firstPixelHue += frameAdvance;
-           
-  }
-}
-
-  
+
+void rainbowCycle(unsigned char frames, unsigned int frameAdvance, unsigned int pixelAdvance) {
+
+	// Hue is a number between 0 and 3*256 than defines a mix of r->g->b where
+	// hue of 0 = Full red
+	// hue of 128 = 1/2 red and 1/2 green
+	// hue of 256 = Full Green
+	// hue of 384 = 1/2 green and 1/2 blue
+	// ...
+
+	unsigned int firstPixelHue = 0;     // Color for the first pixel in the string
+
+	for (unsigned int j = 0; j<frames; j++) {
+
+		unsigned int currentPixelHue = firstPixelHue;
+
+		cli();
+
+		for (unsigned int i = 0; i< PIXELS; i++) {
+
+			if (currentPixelHue >= (3 * 256)) {                  // Normalize back down incase we incremented and overflowed
+				currentPixelHue -= (3 * 256);
+			}
+
+			unsigned char phase = currentPixelHue >> 8;
+			unsigned char step = currentPixelHue & 0xff;
+
+			switch (phase) {
+
+			case 0:
+				sendPixel(~step, step, 0);
+				break;
+
+			case 1:
+				sendPixel(0, ~step, step);
+				break;
+
+			case 2:
+				sendPixel(step, 0, ~step);
+				break;
+
+			}
+
+			currentPixelHue += pixelAdvance;
+
+
+		}
+
+		sei();
+
+		show();
+
+		firstPixelHue += frameAdvance;
+
+	}
+}
+
+
 // I added this one just to demonstrate how quickly you can flash the string.
 // Flashes get faster and faster until *boom* and fade to black.
 
-void detonate( unsigned char r , unsigned char g , unsigned char b , unsigned int startdelayms) {
-  while (startdelayms) {
-    
-    showColor( r , g , b );      // Flash the color 
-    showColor( 0 , 0 , 0 );
-    
-    delay( startdelayms );      
-    
-    startdelayms =  ( startdelayms * 4 ) / 5 ;           // delay between flashes is halved each time until zero
-    
-  }
-  
-  // Then we fade to black....
-  
-  for( int fade=256; fade>0; fade-- ) {
-    
-    showColor( (r * fade) / 256 ,(g*fade) /256 , (b*fade)/256 );
-        
-  }
-  
-  showColor( 0 , 0 , 0 );
-  
-    
+void detonate(unsigned char r, unsigned char g, unsigned char b, unsigned int startdelayms) {
+	while (startdelayms) {
+
+		showColor(r, g, b);      // Flash the color 
+		showColor(0, 0, 0);
+
+		delay(startdelayms);
+
+		startdelayms = (startdelayms * 4) / 5;           // delay between flashes is halved each time until zero
+
+	}
+
+	// Then we fade to black....
+
+	for (int fade = 256; fade>0; fade--) {
+
+		showColor((r * fade) / 256, (g*fade) / 256, (b*fade) / 256);
+
+	}
+
+	showColor(0, 0, 0);
+
+
 }
 
 void setup() {
-    
-  ledsetup();
-  
+
+	ledsetup();
+
 }
 
 
 void loop() {
-  
-  // Some example procedures showing how to display to the pixels:
-  colorWipe(255, 0, 0, 0); // Red
-  colorWipe(0, 255, 0, 0); // Green
-  colorWipe(0, 0, 255, 0); // Blue
-  
-  // Send a theater pixel chase in...
-  theaterChase(127, 127, 127, 0); // White
-  theaterChase(127,   0,   0, 0); // Red
-  theaterChase(  0,   0, 127, 0); // Blue
-  
-  rainbowCycle(1000 , 20 , 5 );
-  detonate( 255 , 255 , 255 , 1000);
-  
-  return;
-  
-}
-
-
-
-
-
+
+	// Some example procedures showing how to display to the pixels:
+	colorWipe(255, 0, 0, 0); // Red
+	colorWipe(0, 255, 0, 0); // Green
+	colorWipe(0, 0, 255, 0); // Blue
+
+	// Send a theater pixel chase in...
+	theaterChase(127, 127, 127, 0); // White
+	theaterChase(127, 0, 0, 0); // Red
+	theaterChase(0, 0, 127, 0); // Blue
+
+	rainbowCycle(1000, 20, 5);
+	detonate(255, 255, 255, 1000);
+
+	return;
+
+}
+


/*
 This is an example of how simple driving a Neopixel can be
 This code is optimized for understandability and changability rather than raw speed
 More info at http://wp.josh.com/2014/05/11/ws2812-neopixels-made-easy/
*/

// Change this to be at least as long as your pixel string (too long will work fine, just be a little slower)


#define NS_PER_CYCLE ( NS_PER_SEC / CYCLES_PER_SEC )

#define NS_TO_CYCLES(n) (( (n+(NS_PER_CYCLE/2)) / NS_PER_CYCLE )-1)		// Round up or down to the nearest matching number of cycles


// Actually send a bit to the string. We turn off optimizations to make sure the compile does
// not reorder things and make it so the delay happens in the wrong place.


void sendBit(bool bitVal) {

	if (bitVal) {

		asm volatile (
			"sbi %[port], %[bit] \n\t"				// Set the output bit
			".rept %[onCycles] \n\t"
			"nop \n\t"
			".endr \n\t"
			"cbi %[port], %[bit] \n\t"
			".rept %[offCycles] \n\t"
			"nop \n\t"
			".endr \n\t"
			::
			[port]		"I" (_SFR_IO_ADDR(PIXEL_PORT)),
			[bit]		"I" (PIXEL_BIT),
			[onCycles]	"I" (NS_TO_CYCLES(T1H) - 2),		// 1-bit width less overhead  for the actual bit setting, note that this delay could be longer and everything would still work
			[offCycles] "I" (NS_TO_CYCLES(T1L) - 2)			// Minimum interbit delay. Note that we probably don't need this at all since the loop overhead will be enough, but here for correctness

			);
		

	} else {


		// **************************************************************************
		// This line is really the only tight goldilocks timing in the whole program!
		// **************************************************************************


		asm volatile (
			"sbi %[port], %[bit] \n\t"				// Set the output bit
			".rept %[onCycles] \n\t"				// Now timing actually matters. The 0-bit must be long enough to be detected but not too long or it will be a 1-bit
			"nop \n\t"
			".endr \n\t"
			"cbi %[port], %[bit] \n\t"
			".rept %[offCycles] \n\t"
			"nop \n\t"
			".endr \n\t"
			::
			[port]		"I" (_SFR_IO_ADDR(PIXEL_PORT)),
			[bit]		"I" (PIXEL_BIT),
			[onCycles]	"I" (NS_TO_CYCLES(T0H) - 2),
			[offCycles] "I" (NS_TO_CYCLES(T0L) - 2)

			);

	}

	// Note that the inter-bit gap can be as long as you want as long as it doesn't exceed the 5us reset timeout (which is A long time)
	// Here I have been generous and not tried to squeeze the gap tight but instead erred on the side of lots of extra time.
	// This has thenice side effect of avoid glitches on very long strings becuase 


}


void sendByte(unsigned char byte) {

	for (unsigned char bit = 0; bit < 8; bit++) {

		sendBit(bitRead(byte, 7));                // Neopixel wants bit in highest-to-lowest order
		// so send highest bit (bit #7 in an 8-bit byte since they start at 0)
		byte <<= 1;                                    // and then shift left so bit 6 moves into 7, 5 moves into 6, etc

	}
}

/*

The following three functions are the public API:

ledSetup() - set up the pin that is connected to the string. Call once at the begining of the program.
sendPixel( r g , b ) - send a single pixel to the string. Call this once for each pixel in a frame.
show() - show the recently sent pixel on the LEDs . Call once per frame.

*/


// Set the specified pin up as digital out

void ledsetup() {

	bitSet(PIXEL_DDR, PIXEL_BIT);

}

void sendPixel(unsigned char r, unsigned char g, unsigned char b)  {

	sendByte(g);          // Neopixel wants colors in green then red then blue order
	sendByte(r);
	sendByte(b);

}


// Just wait long enough without sending any bots to cause the pixels to latch and display the last sent frame

void show() {

	_delay_us( (RES / 1000UL) + 1);				// Round up to nearest us since the delay must be _at_least_ this long (too short might not work, too long not a problem)

}


/*

That is the whole API. What follows are some demo functions rewriten from the AdaFruit strandtest code...

https://github.com/adafruit/Adafruit_NeoPixel/blob/master/examples/strandtest/strandtest.ino

Note that we always turn off interrupts while we are sending pixels becuase an interupt
could happen just when we were in the middle of somehting time sensitive.

If we wanted to minimize the time interrupts were off, we could instead
could get away with only turning off interrupts just for the very brief moment
when we are actually sending a 0 bit (~1us), as long as we were sure that the total time
taken by any interrupts + the time in our pixel generation code never exceeded the reset time (5us).

*/


// Display a single color on the whole string

void showColor(unsigned char r, unsigned char g, unsigned char b) {

	cli();
	for (int p = 0; p<PIXELS; p++) {
		sendPixel(r, g, b);
	}
	sei();
	show();

}

// Fill the dots one after the other with a color
// rewrite to lift the compare out of the loop
void colorWipe(unsigned char r, unsigned char g, unsigned char b, unsigned  char wait) {
	for (unsigned int i = 0; i<PIXELS; i += (PIXELS / 60)) {

		cli();
		unsigned int p = 0;

		while (p++ <= i) {
			sendPixel(r, g, b);
		}

		while (p++ <= PIXELS) {
			sendPixel(0, 0, 0);

		}

		sei();
		show();
		delay(wait);
	}
}

// Theatre-style crawling lights.
