What Do I Build Next? An Arduino Nano Minicar

/*-------------------------------------------------------------------------
 *  Arduino library to control a wide variety of WS2811- and WS2812-based RGB
 *  LED devices such as Adafruit FLORA RGB Smart Pixels and NeoPixel strips.
 *  Currently handles 400 and 800 KHz bitstreams on 8, 12 and 16 MHz ATmega
 *  MCUs, with LEDs wired for various color orders.  8 MHz MCUs provide
 *  output on PORTB and PORTD, while 16 MHz chips can handle most output pins
 *  (possible exception with upper PORT registers on the Arduino Mega).
 *
 *  Written by Phil Burgess / Paint Your Dragon for Adafruit Industries,
 *  contributions by PJRC, Michael Miller and other members of the open
 *  source community.
 *
 *  Adafruit invests time and resources providing this open source code,
 *  please support Adafruit and open-source hardware by purchasing products
 *  from Adafruit!
 *
 *  -------------------------------------------------------------------------
 *  This file is part of the Adafruit NeoPixel library.
 *
 *  NeoPixel is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU Lesser General Public License as
 *  published by the Free Software Foundation, either version 3 of
 *  the License, or (at your option) any later version.
 *
 *  NeoPixel is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU Lesser General Public License for more details.
 *
 *  You should have received a copy of the GNU Lesser General Public
 *  License along with NeoPixel.  If not, see
 *  <http://www.gnu.org/licenses/>.
 *  -------------------------------------------------------------------------*/

#include "Adafruit_NeoPixel.h"
// Constructor when length, pin and type are known at compile-time:
Adafruit_NeoPixel::Adafruit_NeoPixel(uint16_t n, uint8_t p, neoPixelType t) :
	begun(false), brightness(0), pixels(NULL), endTime(0)
{
	updateType(t);
	updateLength(n);
	setPin(p);
}


// via Michael Vogt/neophob: empty constructor is used when strand length
// isn't known at compile-time; situations where program config might be
// read from internal flash memory or an SD card, or arrive via serial
// command.  If using this constructor, MUST follow up with updateType(),
// updateLength(), etc. to establish the strand type, length and pin number!
Adafruit_NeoPixel::Adafruit_NeoPixel() :
#ifdef NEO_KHZ400
	is800KHz(true),
#endif
	begun(false), numLEDs(0), numBytes(0), pin(-1), brightness(0), pixels(NULL),
	rOffset(1), gOffset(0), bOffset(2), wOffset(1), endTime(0)
{
}


Adafruit_NeoPixel::~Adafruit_NeoPixel()
{
	if (pixels) {
		free(pixels);
	}
	if (pin >= 0) {
		pinMode(pin, INPUT);
	}
}


void Adafruit_NeoPixel::begin(void)
{
	if (pin >= 0) {
		pinMode(pin, OUTPUT);
		digitalWrite(pin, LOW);
	}
	begun = true;
}


void Adafruit_NeoPixel::updateLength(uint16_t n)
{
	if (pixels) {
		free(pixels); // Free existing data (if any)
	}
	// Allocate new data -- note: ALL PIXELS ARE CLEARED
	numBytes = n * ((wOffset == rOffset) ? 3 : 4);
	if ((pixels = (uint8_t *)malloc(numBytes))) {
		memset(pixels, 0, numBytes);
		numLEDs = n;
	} else {
		numLEDs = numBytes = 0;
	}
}


void Adafruit_NeoPixel::updateType(neoPixelType t)
{
	boolean oldThreeBytesPerPixel = (wOffset == rOffset);   // false if RGBW

	wOffset = (t >> 6) & 0b11;                              // See notes in header file
	rOffset = (t >> 4) & 0b11;                              // regarding R/G/B/W offsets
	gOffset = (t >> 2) & 0b11;
	bOffset = t       & 0b11;
#ifdef NEO_KHZ400
	is800KHz = (t < 256); // 400 KHz flag is 1<<8
#endif

	// If bytes-per-pixel has changed (and pixel data was previously
	// allocated), re-allocate to new size.  Will clear any data.
	if (pixels) {
		boolean newThreeBytesPerPixel = (wOffset == rOffset);
		if (newThreeBytesPerPixel != oldThreeBytesPerPixel) {
			updateLength(numLEDs);
		}
	}
}


#ifdef ESP8266
// ESP8266 show() is external to enforce ICACHE_RAM_ATTR execution
extern "C" void ICACHE_RAM_ATTR espShow(
	uint8_t pin, uint8_t *pixels, uint32_t numBytes, uint8_t type);

#endif // ESP8266

void Adafruit_NeoPixel::show(void)
{
	if (!pixels) {
		return;
	}

	// Data latch = 50+ microsecond pause in the output stream.  Rather than
	// put a delay at the end of the function, the ending time is noted and
	// the function will simply hold off (if needed) on issuing the
	// subsequent round of data until the latch time has elapsed.  This
	// allows the mainline code to start generating the next frame of data
	// rather than stalling for the latch.
	while (!canShow())
	{
	}
	// endTime is a private member (rather than global var) so that mutliple
	// instances on different pins can be quickly issued in succession (each
	// instance doesn't delay the next).

	// In order to make this code runtime-configurable to work with any pin,
	// SBI/CBI instructions are eschewed in favor of full PORT writes via the
	// OUT or ST instructions.  It relies on two facts: that peripheral
	// functions (such as PWM) take precedence on output pins, so our PORT-
	// wide writes won't interfere, and that interrupts are globally disabled
	// while data is being issued to the LEDs, so no other code will be
	// accessing the PORT.  The code takes an initial 'snapshot' of the PORT
	// state, computes 'pin high' and 'pin low' values, and writes these back
	// to the PORT register as needed.

	noInterrupts(); // Need 100% focus on instruction timing


#ifdef __AVR__
// AVR MCUs -- ATmega & ATtiny (no XMEGA) ---------------------------------

	volatile uint16_t
	    i = numBytes;       // Loop counter
	volatile uint8_t
	*ptr = pixels,          // Pointer to next byte
	    b = *ptr++,         // Current byte value
	    hi,                 // PORT w/output bit set high
	    lo;                 // PORT w/output bit set low

	// Hand-tuned assembly code issues data to the LED drivers at a specific
	// rate.  There's separate code for different CPU speeds (8, 12, 16 MHz)
	// for both the WS2811 (400 KHz) and WS2812 (800 KHz) drivers.  The
	// datastream timing for the LED drivers allows a little wiggle room each
	// way (listed in the datasheets), so the conditions for compiling each
	// case are set up for a range of frequencies rather than just the exact
	// 8, 12 or 16 MHz values, permitting use with some close-but-not-spot-on
	// devices (e.g. 16.5 MHz DigiSpark).  The ranges were arrived at based
	// on the datasheet figures and have not been extensively tested outside
	// the canonical 8/12/16 MHz speeds; there's no guarantee these will work
	// close to the extremes (or possibly they could be pushed further).
	// Keep in mind only one CPU speed case actually gets compiled; the
	// resulting program isn't as massive as it might look from source here.

// 8 MHz(ish) AVR ---------------------------------------------------------
#if (F_CPU >= 7400000UL) && (F_CPU <= 9500000UL)
#ifdef NEO_KHZ400 // 800 KHz check needed only if 400 KHz support enabled
	if (is800KHz) {
#endif

	volatile uint8_t n1, n2 = 0; // First, next bits out

	// Squeezing an 800 KHz stream out of an 8 MHz chip requires code
	// specific to each PORT register.  At present this is only written
	// to work with pins on PORTD or PORTB, the most likely use case --
	// this covers all the pins on the Adafruit Flora and the bulk of
	// digital pins on the Arduino Pro 8 MHz (keep in mind, this code
	// doesn't even get compiled for 16 MHz boards like the Uno, Mega,
	// Leonardo, etc., so don't bother extending this out of hand).
	// Additional PORTs could be added if you really need them, just
	// duplicate the else and loop and change the PORT.  Each add'l
	// PORT will require about 150(ish) bytes of program space.

	// 10 instruction clocks per bit: HHxxxxxLLL
	// OUT instructions:              ^ ^    ^   (T=0,2,7)

#ifdef PORTD // PORTD isn't present on ATtiny85, etc.
	if (port == &PORTD) {
		hi = PORTD |  pinMask;
		lo = PORTD & ~pinMask;
		n1 = lo;
		if (b & 0x80) {
			n1 = hi;
		}

		// Dirty trick: RJMPs proceeding to the next instruction are used
		// to delay two clock cycles in one instruction word (rather than
		// using two NOPs).  This was necessary in order to squeeze the
		// loop down to exactly 64 words -- the maximum possible for a
		// relative branch.

		asm volatile (
			"headD:"                   "\n\t"       // Clk  Pseudocode
			// Bit 7:
			"out  %[port] , %[hi]"    "\n\t"        // 1    PORT = hi
			"mov  %[n2]   , %[lo]"    "\n\t"        // 1    n2   = lo
			"out  %[port] , %[n1]"    "\n\t"        // 1    PORT = n1
			"rjmp .+0"                "\n\t"        // 2    nop nop
			"sbrc %[byte] , 6"        "\n\t"        // 1-2  if(b & 0x40)
			"mov %[n2]   , %[hi]"    "\n\t"         // 0-1   n2 = hi
			"out  %[port] , %[lo]"    "\n\t"        // 1    PORT = lo
			"rjmp .+0"                "\n\t"        // 2    nop nop
			// Bit 6:
			"out  %[port] , %[hi]"    "\n\t"        // 1    PORT = hi
			"mov  %[n1]   , %[lo]"    "\n\t"        // 1    n1   = lo
			"out  %[port] , %[n2]"    "\n\t"        // 1    PORT = n2
			"rjmp .+0"                "\n\t"        // 2    nop nop
			"sbrc %[byte] , 5"        "\n\t"        // 1-2  if(b & 0x20)
			"mov %[n1]   , %[hi]"    "\n\t"         // 0-1   n1 = hi
			"out  %[port] , %[lo]"    "\n\t"        // 1    PORT = lo
			"rjmp .+0"                "\n\t"        // 2    nop nop
			// Bit 5:
			"out  %[port] , %[hi]"    "\n\t"        // 1    PORT = hi
			"mov  %[n2]   , %[lo]"    "\n\t"        // 1    n2   = lo
			"out  %[port] , %[n1]"    "\n\t"        // 1    PORT = n1
			"rjmp .+0"                "\n\t"        // 2    nop nop
			"sbrc %[byte] , 4"        "\n\t"        // 1-2  if(b & 0x10)
			"mov %[n2]   , %[hi]"    "\n\t"         // 0-1   n2 = hi
			"out  %[port] , %[lo]"    "\n\t"        // 1    PORT = lo
			"rjmp .+0"                "\n\t"        // 2    nop nop
			// Bit 4:
			"out  %[port] , %[hi]"    "\n\t"        // 1    PORT = hi
			"mov  %[n1]   , %[lo]"    "\n\t"        // 1    n1   = lo
			"out  %[port] , %[n2]"    "\n\t"        // 1    PORT = n2
			"rjmp .+0"                "\n\t"        // 2    nop nop
			"sbrc %[byte] , 3"        "\n\t"        // 1-2  if(b & 0x08)
			"mov %[n1]   , %[hi]"    "\n\t"         // 0-1   n1 = hi
			"out  %[port] , %[lo]"    "\n\t"        // 1    PORT = lo
			"rjmp .+0"                "\n\t"        // 2    nop nop
			// Bit 3:
			"out  %[port] , %[hi]"    "\n\t"        // 1    PORT = hi
			"mov  %[n2]   , %[lo]"    "\n\t"        // 1    n2   = lo
			"out  %[port] , %[n1]"    "\n\t"        // 1    PORT = n1
			"rjmp .+0"                "\n\t"        // 2    nop nop
			"sbrc %[byte] , 2"        "\n\t"        // 1-2  if(b & 0x04)
			"mov %[n2]   , %[hi]"    "\n\t"         // 0-1   n2 = hi
			"out  %[port] , %[lo]"    "\n\t"        // 1    PORT = lo
			"rjmp .+0"                "\n\t"        // 2    nop nop
			// Bit 2:
			"out  %[port] , %[hi]"    "\n\t"        // 1    PORT = hi
			"mov  %[n1]   , %[lo]"    "\n\t"        // 1    n1   = lo
			"out  %[port] , %[n2]"    "\n\t"        // 1    PORT = n2
			"rjmp .+0"                "\n\t"        // 2    nop nop
			"sbrc %[byte] , 1"        "\n\t"        // 1-2  if(b & 0x02)
			"mov %[n1]   , %[hi]"    "\n\t"         // 0-1   n1 = hi
			"out  %[port] , %[lo]"    "\n\t"        // 1    PORT = lo
			"rjmp .+0"                "\n\t"        // 2    nop nop
			// Bit 1:
			"out  %[port] , %[hi]"    "\n\t"        // 1    PORT = hi
			"mov  %[n2]   , %[lo]"    "\n\t"        // 1    n2   = lo
			"out  %[port] , %[n1]"    "\n\t"        // 1    PORT = n1
			"rjmp .+0"                "\n\t"        // 2    nop nop
			"sbrc %[byte] , 0"        "\n\t"        // 1-2  if(b & 0x01)
			"mov %[n2]   , %[hi]"    "\n\t"         // 0-1   n2 = hi
			"out  %[port] , %[lo]"    "\n\t"        // 1    PORT = lo
			"sbiw %[count], 1"        "\n\t"        // 2    i-- (don't act on Z flag yet)
			// Bit 0:
			"out  %[port] , %[hi]"    "\n\t"        // 1    PORT = hi
			"mov  %[n1]   , %[lo]"    "\n\t"        // 1    n1   = lo
			"out  %[port] , %[n2]"    "\n\t"        // 1    PORT = n2
			"ld   %[byte] , %a[ptr]+" "\n\t"        // 2    b = *ptr++
			"sbrc %[byte] , 7"        "\n\t"        // 1-2  if(b & 0x80)
			"mov %[n1]   , %[hi]"    "\n\t"         // 0-1   n1 = hi
			"out  %[port] , %[lo]"    "\n\t"        // 1    PORT = lo
			"brne headD"              "\n"          // 2    while(i) (Z flag set above)
			: [byte]  "+r" (b),
			[n1]    "+r" (n1),
			[n2]    "+r" (n2),
			[count] "+w" (i)
			: [port]   "I" (_SFR_IO_ADDR(PORTD)),
			[ptr]    "e" (ptr),
			[hi]     "r" (hi),
			[lo]     "r" (lo));
	} else if (port == &PORTB) {
#endif // PORTD

	// Same as above, just switched to PORTB and stripped of comments.
	hi = PORTB |  pinMask;
	lo = PORTB & ~pinMask;
	n1 = lo;
	if (b & 0x80) {
		n1 = hi;
	}

	asm volatile (
		"headB:"                   "\n\t"
		"out  %[port] , %[hi]"    "\n\t"
		"mov  %[n2]   , %[lo]"    "\n\t"
		"out  %[port] , %[n1]"    "\n\t"
		"rjmp .+0"                "\n\t"
		"sbrc %[byte] , 6"        "\n\t"
		"mov %[n2]   , %[hi]"    "\n\t"
		"out  %[port] , %[lo]"    "\n\t"
		"rjmp .+0"                "\n\t"
		"out  %[port] , %[hi]"    "\n\t"
		"mov  %[n1]   , %[lo]"    "\n\t"
		"out  %[port] , %[n2]"    "\n\t"
		"rjmp .+0"                "\n\t"
		"sbrc %[byte] , 5"        "\n\t"
		"mov %[n1]   , %[hi]"    "\n\t"
		"out  %[port] , %[lo]"    "\n\t"
		"rjmp .+0"                "\n\t"
		"out  %[port] , %[hi]"    "\n\t"
		"mov  %[n2]   , %[lo]"    "\n\t"
		"out  %[port] , %[n1]"    "\n\t"
		"rjmp .+0"                "\n\t"
		"sbrc %[byte] , 4"        "\n\t"
		"mov %[n2]   , %[hi]"    "\n\t"
		"out  %[port] , %[lo]"    "\n\t"
		"rjmp .+0"                "\n\t"
		"out  %[port] , %[hi]"    "\n\t"
		"mov  %[n1]   , %[lo]"    "\n\t"
		"out  %[port] , %[n2]"    "\n\t"
		"rjmp .+0"                "\n\t"
		"sbrc %[byte] , 3"        "\n\t"
		"mov %[n1]   , %[hi]"    "\n\t"
		"out  %[port] , %[lo]"    "\n\t"
		"rjmp .+0"                "\n\t"
		"out  %[port] , %[hi]"    "\n\t"
		"mov  %[n2]   , %[lo]"    "\n\t"
		"out  %[port] , %[n1]"    "\n\t"
		"rjmp .+0"                "\n\t"
		"sbrc %[byte] , 2"        "\n\t"
		"mov %[n2]   , %[hi]"    "\n\t"
		"out  %[port] , %[lo]"    "\n\t"
		"rjmp .+0"                "\n\t"
		"out  %[port] , %[hi]"    "\n\t"
		"mov  %[n1]   , %[lo]"    "\n\t"
		"out  %[port] , %[n2]"    "\n\t"
		"rjmp .+0"                "\n\t"
		"sbrc %[byte] , 1"        "\n\t"
		"mov %[n1]   , %[hi]"    "\n\t"
		"out  %[port] , %[lo]"    "\n\t"
		"rjmp .+0"                "\n\t"
		"out  %[port] , %[hi]"    "\n\t"
		"mov  %[n2]   , %[lo]"    "\n\t"
		"out  %[port] , %[n1]"    "\n\t"
		"rjmp .+0"                "\n\t"
		"sbrc %[byte] , 0"        "\n\t"
		"mov %[n2]   , %[hi]"    "\n\t"
		"out  %[port] , %[lo]"    "\n\t"
		"sbiw %[count], 1"        "\n\t"
		"out  %[port] , %[hi]"    "\n\t"
		"mov  %[n1]   , %[lo]"    "\n\t"
		"out  %[port] , %[n2]"    "\n\t"
		"ld   %[byte] , %a[ptr]+" "\n\t"
		"sbrc %[byte] , 7"        "\n\t"
		"mov %[n1]   , %[hi]"    "\n\t"
		"out  %[port] , %[lo]"    "\n\t"
		"brne headB"              "\n"
		: [byte] "+r" (b), [n1] "+r" (n1), [n2] "+r" (n2), [count] "+w" (i)
		: [port] "I" (_SFR_IO_ADDR(PORTB)), [ptr] "e" (ptr), [hi] "r" (hi),
		[lo] "r" (lo));

#ifdef PORTD
}        // endif PORTB
#endif

#ifdef NEO_KHZ400
} else {   // end 800 KHz, do 400 KHz
	   // Timing is more relaxed; unrolling the inner loop for each bit is
	   // not necessary.  Still using the peculiar RJMPs as 2X NOPs, not out
	   // of need but just to trim the code size down a little.
	   // This 400-KHz-datastream-on-8-MHz-CPU code is not quite identical
	   // to the 800-on-16 code later -- the hi/lo timing between WS2811 and
	   // WS2812 is not simply a 2:1 scale!

	// 20 inst. clocks per bit: HHHHxxxxxxLLLLLLLLLL
	// ST instructions:         ^   ^     ^          (T=0,4,10)

	volatile uint8_t next, bit;

	hi = *port |  pinMask;
	lo = *port & ~pinMask;
	next = lo;
	bit = 8;

	asm volatile (
		"head20:"                  "\n\t"       // Clk  Pseudocode    (T =  0)
		"st   %a[port], %[hi]"    "\n\t"        // 2    PORT = hi     (T =  2)
		"sbrc %[byte] , 7"        "\n\t"        // 1-2  if(b & 128)
		"mov  %[next], %[hi]"    "\n\t"         // 0-1   next = hi    (T =  4)
		"st   %a[port], %[next]"  "\n\t"        // 2    PORT = next   (T =  6)
		"mov  %[next] , %[lo]"    "\n\t"        // 1    next = lo     (T =  7)
		"dec  %[bit]"             "\n\t"        // 1    bit--         (T =  8)
		"breq nextbyte20"         "\n\t"        // 1-2  if(bit == 0)
		"rol  %[byte]"            "\n\t"        // 1    b <<= 1       (T = 10)
		"st   %a[port], %[lo]"    "\n\t"        // 2    PORT = lo     (T = 12)
		"rjmp .+0"                "\n\t"        // 2    nop nop       (T = 14)
		"rjmp .+0"                "\n\t"        // 2    nop nop       (T = 16)
		"rjmp .+0"                "\n\t"        // 2    nop nop       (T = 18)
		"rjmp head20"             "\n\t"        // 2    -> head20 (next bit out)
		"nextbyte20:"              "\n\t"       //                    (T = 10)
		"st   %a[port], %[lo]"    "\n\t"        // 2    PORT = lo     (T = 12)
		"nop"                     "\n\t"        // 1    nop           (T = 13)
		"ldi  %[bit]  , 8"        "\n\t"        // 1    bit = 8       (T = 14)
		"ld   %[byte] , %a[ptr]+" "\n\t"        // 2    b = *ptr++    (T = 16)
		"sbiw %[count], 1"        "\n\t"        // 2    i--           (T = 18)
		"brne head20"             "\n"          // 2    if(i != 0) -> (next byte)
		: [port]  "+e" (port),
		[byte]  "+r" (b),
		[bit]   "+r" (bit),
		[next]  "+r" (next),
		[count] "+w" (i)
		: [hi]    "r" (hi),
		[lo]    "r" (lo),
		[ptr]   "e" (ptr));
}
#endif // NEO_KHZ400

// 12 MHz(ish) AVR --------------------------------------------------------
#elif (F_CPU >= 11100000UL) && (F_CPU <= 14300000UL)
#ifdef NEO_KHZ400 // 800 KHz check needed only if 400 KHz support enabled
	if (is800KHz) {
#endif

	// In the 12 MHz case, an optimized 800 KHz datastream (no dead time
	// between bytes) requires a PORT-specific loop similar to the 8 MHz
	// code (but a little more relaxed in this case).

	// 15 instruction clocks per bit: HHHHxxxxxxLLLLL
	// OUT instructions:              ^   ^     ^     (T=0,4,10)

	volatile uint8_t next;

#ifdef PORTD
	if (port == &PORTD) {
		hi = PORTD |  pinMask;
		lo = PORTD & ~pinMask;
		next = lo;
		if (b & 0x80) {
			next = hi;
		}

		// Don't "optimize" the OUT calls into the bitTime subroutine;
		// we're exploiting the RCALL and RET as 3- and 4-cycle NOPs!
		asm volatile (
			"headD:"                   "\n\t"       //        (T =  0)
			"out   %[port], %[hi]"    "\n\t"        //        (T =  1)
			"rcall bitTimeD"          "\n\t"        // Bit 7  (T = 15)
			"out   %[port], %[hi]"    "\n\t"
			"rcall bitTimeD"          "\n\t"        // Bit 6
			"out   %[port], %[hi]"    "\n\t"
			"rcall bitTimeD"          "\n\t"        // Bit 5
			"out   %[port], %[hi]"    "\n\t"
			"rcall bitTimeD"          "\n\t"        // Bit 4
			"out   %[port], %[hi]"    "\n\t"
			"rcall bitTimeD"          "\n\t"        // Bit 3
			"out   %[port], %[hi]"    "\n\t"
			"rcall bitTimeD"          "\n\t"        // Bit 2
			"out   %[port], %[hi]"    "\n\t"
			"rcall bitTimeD"          "\n\t"        // Bit 1
			// Bit 0:
			"out  %[port] , %[hi]"    "\n\t"        // 1    PORT = hi    (T =  1)
			"rjmp .+0"                "\n\t"        // 2    nop nop      (T =  3)
			"ld   %[byte] , %a[ptr]+" "\n\t"        // 2    b = *ptr++   (T =  5)
			"out  %[port] , %[next]"  "\n\t"        // 1    PORT = next  (T =  6)
			"mov  %[next] , %[lo]"    "\n\t"        // 1    next = lo    (T =  7)
			"sbrc %[byte] , 7"        "\n\t"        // 1-2  if(b & 0x80) (T =  8)
			"mov %[next] , %[hi]"    "\n\t"         // 0-1    next = hi  (T =  9)
			"nop"                     "\n\t"        // 1                 (T = 10)
			"out  %[port] , %[lo]"    "\n\t"        // 1    PORT = lo    (T = 11)
			"sbiw %[count], 1"        "\n\t"        // 2    i--          (T = 13)
			"brne headD"              "\n\t"        // 2    if(i != 0) -> (next byte)
			"rjmp doneD"             "\n\t"
			"bitTimeD:"               "\n\t"        //      nop nop nop     (T =  4)
			"out  %[port], %[next]"  "\n\t"         // 1    PORT = next     (T =  5)
			"mov  %[next], %[lo]"    "\n\t"         // 1    next = lo       (T =  6)
			"rol  %[byte]"           "\n\t"         // 1    b <<= 1         (T =  7)
			"sbrc %[byte], 7"        "\n\t"         // 1-2  if(b & 0x80)    (T =  8)
			"mov %[next], %[hi]"    "\n\t"          // 0-1   next = hi      (T =  9)
			"nop"                    "\n\t"         // 1                    (T = 10)
			"out  %[port], %[lo]"    "\n\t"         // 1    PORT = lo       (T = 11)
			"ret"                    "\n\t"         // 4    nop nop nop nop (T = 15)
			"doneD:"                 "\n"
			: [byte]  "+r" (b),
			[next]  "+r" (next),
			[count] "+w" (i)
			: [port]   "I" (_SFR_IO_ADDR(PORTD)),
			[ptr]    "e" (ptr),
			[hi]     "r" (hi),
			[lo]     "r" (lo));
	} else if (port == &PORTB) {
#endif // PORTD

	hi = PORTB |  pinMask;
	lo = PORTB & ~pinMask;
	next = lo;
	if (b & 0x80) {
		next = hi;
	}

	// Same as above, just set for PORTB & stripped of comments
	asm volatile (
		"headB:"                   "\n\t"
		"out   %[port], %[hi]"    "\n\t"
		"rcall bitTimeB"          "\n\t"
		"out   %[port], %[hi]"    "\n\t"
		"rcall bitTimeB"          "\n\t"
		"out   %[port], %[hi]"    "\n\t"
		"rcall bitTimeB"          "\n\t"
		"out   %[port], %[hi]"    "\n\t"
		"rcall bitTimeB"          "\n\t"
		"out   %[port], %[hi]"    "\n\t"
		"rcall bitTimeB"          "\n\t"
		"out   %[port], %[hi]"    "\n\t"
		"rcall bitTimeB"          "\n\t"
		"out   %[port], %[hi]"    "\n\t"
		"rcall bitTimeB"          "\n\t"
		"out  %[port] , %[hi]"    "\n\t"
		"rjmp .+0"                "\n\t"
		"ld   %[byte] , %a[ptr]+" "\n\t"
		"out  %[port] , %[next]"  "\n\t"
		"mov  %[next] , %[lo]"    "\n\t"
		"sbrc %[byte] , 7"        "\n\t"
		"mov %[next] , %[hi]"    "\n\t"
		"nop"                     "\n\t"
		"out  %[port] , %[lo]"    "\n\t"
		"sbiw %[count], 1"        "\n\t"
		"brne headB"              "\n\t"
		"rjmp doneB"             "\n\t"
		"bitTimeB:"               "\n\t"
		"out  %[port], %[next]"  "\n\t"
		"mov  %[next], %[lo]"    "\n\t"
		"rol  %[byte]"           "\n\t"
		"sbrc %[byte], 7"        "\n\t"
		"mov %[next], %[hi]"    "\n\t"
		"nop"                    "\n\t"
		"out  %[port], %[lo]"    "\n\t"
		"ret"                    "\n\t"
		"doneB:"                 "\n"
		: [byte] "+r" (b), [next] "+r" (next), [count] "+w" (i)
		: [port] "I" (_SFR_IO_ADDR(PORTB)), [ptr] "e" (ptr), [hi] "r" (hi),
		[lo] "r" (lo));

#ifdef PORTD
}
#endif

#ifdef NEO_KHZ400
} else {   // 400 KHz
	   // 30 instruction clocks per bit: HHHHHHxxxxxxxxxLLLLLLLLLLLLLLL
	   // ST instructions:               ^     ^        ^    (T=0,6,15)

	volatile uint8_t next, bit;

	hi = *port |  pinMask;
	lo = *port & ~pinMask;
	next = lo;
	bit = 8;

	asm volatile (
		"head30:"                  "\n\t"       // Clk  Pseudocode    (T =  0)
		"st   %a[port], %[hi]"    "\n\t"        // 2    PORT = hi     (T =  2)
		"sbrc %[byte] , 7"        "\n\t"        // 1-2  if(b & 128)
		"mov  %[next], %[hi]"    "\n\t"         // 0-1   next = hi    (T =  4)
		"rjmp .+0"                "\n\t"        // 2    nop nop       (T =  6)
		"st   %a[port], %[next]"  "\n\t"        // 2    PORT = next   (T =  8)
		"rjmp .+0"                "\n\t"        // 2    nop nop       (T = 10)
		"rjmp .+0"                "\n\t"        // 2    nop nop       (T = 12)
		"rjmp .+0"                "\n\t"        // 2    nop nop       (T = 14)
		"nop"                     "\n\t"        // 1    nop           (T = 15)
		"st   %a[port], %[lo]"    "\n\t"        // 2    PORT = lo     (T = 17)
		"rjmp .+0"                "\n\t"        // 2    nop nop       (T = 19)
		"dec  %[bit]"             "\n\t"        // 1    bit--         (T = 20)
		"breq nextbyte30"         "\n\t"        // 1-2  if(bit == 0)
		"rol  %[byte]"            "\n\t"        // 1    b <<= 1       (T = 22)
		"rjmp .+0"                "\n\t"        // 2    nop nop       (T = 24)
		"rjmp .+0"                "\n\t"        // 2    nop nop       (T = 26)
		"rjmp .+0"                "\n\t"        // 2    nop nop       (T = 28)
		"rjmp head30"             "\n\t"        // 2    -> head30 (next bit out)
		"nextbyte30:"              "\n\t"       //                    (T = 22)
		"nop"                     "\n\t"        // 1    nop           (T = 23)
		"ldi  %[bit]  , 8"        "\n\t"        // 1    bit = 8       (T = 24)
		"ld   %[byte] , %a[ptr]+" "\n\t"        // 2    b = *ptr++    (T = 26)
		"sbiw %[count], 1"        "\n\t"        // 2    i--           (T = 28)
		"brne head30"             "\n"          // 1-2  if(i != 0) -> (next byte)
		: [port]  "+e" (port),
		[byte]  "+r" (b),
		[bit]   "+r" (bit),
		[next]  "+r" (next),
		[count] "+w" (i)
		: [hi]     "r" (hi),
		[lo]     "r" (lo),
		[ptr]    "e" (ptr));
}
#endif // NEO_KHZ400

// 16 MHz(ish) AVR --------------------------------------------------------
#elif (F_CPU >= 15400000UL) && (F_CPU <= 19000000L)
#ifdef NEO_KHZ400 // 800 KHz check needed only if 400 KHz support enabled
	if (is800KHz) {
#endif

	// WS2811 and WS2812 have different hi/lo duty cycles; this is
	// similar but NOT an exact copy of the prior 400-on-8 code.

	// 20 inst. clocks per bit: HHHHHxxxxxxxxLLLLLLL
	// ST instructions:         ^   ^        ^       (T=0,5,13)

	volatile uint8_t next, bit;

	hi = *port |  pinMask;
	lo = *port & ~pinMask;
	next = lo;
	bit = 8;

	asm volatile (
		"head20:"                   "\n\t"      // Clk  Pseudocode    (T =  0)
		"st   %a[port],  %[hi]"    "\n\t"       // 2    PORT = hi     (T =  2)
		"sbrc %[byte],  7"         "\n\t"       // 1-2  if(b & 128)
		"mov  %[next], %[hi]"     "\n\t"        // 0-1   next = hi    (T =  4)
		"dec  %[bit]"              "\n\t"       // 1    bit--         (T =  5)
		"st   %a[port],  %[next]"  "\n\t"       // 2    PORT = next   (T =  7)
		"mov  %[next] ,  %[lo]"    "\n\t"       // 1    next = lo     (T =  8)
		"breq nextbyte20"          "\n\t"       // 1-2  if(bit == 0) (from dec above)
		"rol  %[byte]"             "\n\t"       // 1    b <<= 1       (T = 10)
		"rjmp .+0"                 "\n\t"       // 2    nop nop       (T = 12)
		"nop"                      "\n\t"       // 1    nop           (T = 13)
		"st   %a[port],  %[lo]"    "\n\t"       // 2    PORT = lo     (T = 15)
		"nop"                      "\n\t"       // 1    nop           (T = 16)
		"rjmp .+0"                 "\n\t"       // 2    nop nop       (T = 18)
		"rjmp head20"              "\n\t"       // 2    -> head20 (next bit out)
		"nextbyte20:"               "\n\t"      //                    (T = 10)
		"ldi  %[bit]  ,  8"        "\n\t"       // 1    bit = 8       (T = 11)
		"ld   %[byte] ,  %a[ptr]+" "\n\t"       // 2    b = *ptr++    (T = 13)
		"st   %a[port], %[lo]"     "\n\t"       // 2    PORT = lo     (T = 15)
		"nop"                      "\n\t"       // 1    nop           (T = 16)
		"sbiw %[count], 1"         "\n\t"       // 2    i--           (T = 18)
		"brne head20"             "\n"          // 2    if(i != 0) -> (next byte)
		: [port]  "+e" (port),
		[byte]  "+r" (b),
		[bit]   "+r" (bit),
		[next]  "+r" (next),
		[count] "+w" (i)
		: [ptr]    "e" (ptr),
		[hi]     "r" (hi),
		[lo]     "r" (lo));

#ifdef NEO_KHZ400
} else {   // 400 KHz
	   // The 400 KHz clock on 16 MHz MCU is the most 'relaxed' version.

	// 40 inst. clocks per bit: HHHHHHHHxxxxxxxxxxxxLLLLLLLLLLLLLLLLLLLL
	// ST instructions:         ^       ^           ^         (T=0,8,20)

	volatile uint8_t next, bit;

	hi = *port |  pinMask;
	lo = *port & ~pinMask;
	next = lo;
	bit = 8;

	asm volatile (
		"head40:"                  "\n\t"       // Clk  Pseudocode    (T =  0)
		"st   %a[port], %[hi]"    "\n\t"        // 2    PORT = hi     (T =  2)
		"sbrc %[byte] , 7"        "\n\t"        // 1-2  if(b & 128)
		"mov  %[next] , %[hi]"   "\n\t"         // 0-1   next = hi    (T =  4)
		"rjmp .+0"                "\n\t"        // 2    nop nop       (T =  6)
		"rjmp .+0"                "\n\t"        // 2    nop nop       (T =  8)
		"st   %a[port], %[next]"  "\n\t"        // 2    PORT = next   (T = 10)
		"rjmp .+0"                "\n\t"        // 2    nop nop       (T = 12)
		"rjmp .+0"                "\n\t"        // 2    nop nop       (T = 14)
		"rjmp .+0"                "\n\t"        // 2    nop nop       (T = 16)
		"rjmp .+0"                "\n\t"        // 2    nop nop       (T = 18)
		"rjmp .+0"                "\n\t"        // 2    nop nop       (T = 20)
		"st   %a[port], %[lo]"    "\n\t"        // 2    PORT = lo     (T = 22)
		"nop"                     "\n\t"        // 1    nop           (T = 23)
		"mov  %[next] , %[lo]"    "\n\t"        // 1    next = lo     (T = 24)
		"dec  %[bit]"             "\n\t"        // 1    bit--         (T = 25)
		"breq nextbyte40"         "\n\t"        // 1-2  if(bit == 0)
		"rol  %[byte]"            "\n\t"        // 1    b <<= 1       (T = 27)
		"nop"                     "\n\t"        // 1    nop           (T = 28)
		"rjmp .+0"                "\n\t"        // 2    nop nop       (T = 30)
		"rjmp .+0"                "\n\t"        // 2    nop nop       (T = 32)
		"rjmp .+0"                "\n\t"        // 2    nop nop       (T = 34)
		"rjmp .+0"                "\n\t"        // 2    nop nop       (T = 36)
		"rjmp .+0"                "\n\t"        // 2    nop nop       (T = 38)
		"rjmp head40"             "\n\t"        // 2    -> head40 (next bit out)
		"nextbyte40:"              "\n\t"       //                    (T = 27)
		"ldi  %[bit]  , 8"        "\n\t"        // 1    bit = 8       (T = 28)
		"ld   %[byte] , %a[ptr]+" "\n\t"        // 2    b = *ptr++    (T = 30)
		"rjmp .+0"                "\n\t"        // 2    nop nop       (T = 32)
		"st   %a[port], %[lo]"    "\n\t"        // 2    PORT = lo     (T = 34)
		"rjmp .+0"                "\n\t"        // 2    nop nop       (T = 36)
		"sbiw %[count], 1"        "\n\t"        // 2    i--           (T = 38)
		"brne head40"             "\n"          // 1-2  if(i != 0) -> (next byte)
		: [port]  "+e" (port),
		[byte]  "+r" (b),
		[bit]   "+r" (bit),
		[next]  "+r" (next),
		[count] "+w" (i)
		: [ptr]    "e" (ptr),
		[hi]     "r" (hi),
		[lo]     "r" (lo));
}
#endif // NEO_KHZ400
#else
#error "CPU SPEED NOT SUPPORTED"
#endif // end F_CPU ifdefs on __AVR__

// END AVR ----------------------------------------------------------------
#elif defined(__arm__)
// ARM MCUs -- Teensy 3.0, 3.1, LC, Arduino Due ---------------------------

#if defined(__MK20DX128__) || defined(__MK20DX256__) // Teensy 3.0 & 3.1
#define CYCLES_800_T0H		(F_CPU / 4000000)
#define CYCLES_800_T1H		(F_CPU / 1250000)
#define CYCLES_800		(F_CPU /  800000)
#define CYCLES_400_T0H		(F_CPU / 2000000)
#define CYCLES_400_T1H		(F_CPU /  833333)
#define CYCLES_400		(F_CPU /  400000)

	uint8_t *p = pixels,
	    *end = p + numBytes, pix, mask;
	volatile uint8_t *set = portSetRegister(pin),
	    *clr = portClearRegister(pin);
	uint32_t cyc;

	ARM_DEMCR |= ARM_DEMCR_TRCENA;
	ARM_DWT_CTRL |= ARM_DWT_CTRL_CYCCNTENA;

#ifdef NEO_KHZ400 // 800 KHz check needed only if 400 KHz support enabled
	if (is800KHz) {
#endif
	cyc = ARM_DWT_CYCCNT + CYCLES_800;
	while (p < end)
	{
		pix = *p++;
		for (mask = 0x80; mask; mask >>= 1)
		{
			while (ARM_DWT_CYCCNT - cyc < CYCLES_800)
			{
			}
			cyc = ARM_DWT_CYCCNT;
			*set = 1;
			if (pix & mask) {
				while (ARM_DWT_CYCCNT - cyc < CYCLES_800_T1H)
				{
				}
			} else {
				while (ARM_DWT_CYCCNT - cyc < CYCLES_800_T0H)
				{
				}
			}
			*clr = 1;
		}
	}
	while (ARM_DWT_CYCCNT - cyc < CYCLES_800)
	{
	}
#ifdef NEO_KHZ400
} else {   // 400 kHz bitstream
	cyc = ARM_DWT_CYCCNT + CYCLES_400;
	while (p < end)
	{
		pix = *p++;
		for (mask = 0x80; mask; mask >>= 1)
		{
			while (ARM_DWT_CYCCNT - cyc < CYCLES_400)
			{
			}
			cyc = ARM_DWT_CYCCNT;
			*set = 1;
			if (pix & mask) {
				while (ARM_DWT_CYCCNT - cyc < CYCLES_400_T1H)
				{
				}
			} else {
				while (ARM_DWT_CYCCNT - cyc < CYCLES_400_T0H)
				{
				}
			}
			*clr = 1;
		}
	}
	while (ARM_DWT_CYCCNT - cyc < CYCLES_400)
	{
	}
}
#endif // NEO_KHZ400
#elif defined(__MKL26Z64__) // Teensy-LC
#if F_CPU == 48000000
	uint8_t *p = pixels,
	    pix, count, dly,
	    bitmask = digitalPinToBitMask(pin);
	volatile uint8_t *reg = portSetRegister(pin);
	uint32_t num = numBytes;
	asm volatile (
		"L%=_begin:"                            "\n\t"
		"ldrb	%[pix], [%[p], #0]"       "\n\t"
		"lsl	%[pix], #24"           "\n\t"
		"movs	%[count], #7"             "\n\t"
		"L%=_loop:"                             "\n\t"
		"lsl	%[pix], #1"            "\n\t"
		"bcs	L%=_loop_one"          "\n\t"
		"L%=_loop_zero:"
		"strb	%[bitmask], [%[reg], #0]" "\n\t"
		"movs	%[dly], #4"               "\n\t"
		"L%=_loop_delay_T0H:"                   "\n\t"
		"sub	%[dly], #1"            "\n\t"
		"bne	L%=_loop_delay_T0H"    "\n\t"
		"strb	%[bitmask], [%[reg], #4]" "\n\t"
		"movs	%[dly], #13"              "\n\t"
		"L%=_loop_delay_T0L:"                   "\n\t"
		"sub	%[dly], #1"            "\n\t"
		"bne	L%=_loop_delay_T0L"    "\n\t"
		"b	L%=_next"        "\n\t"
		"L%=_loop_one:"
		"strb	%[bitmask], [%[reg], #0]" "\n\t"
		"movs	%[dly], #13"              "\n\t"
		"L%=_loop_delay_T1H:"                   "\n\t"
		"sub	%[dly], #1"            "\n\t"
		"bne	L%=_loop_delay_T1H"    "\n\t"
		"strb	%[bitmask], [%[reg], #4]" "\n\t"
		"movs	%[dly], #4"               "\n\t"
		"L%=_loop_delay_T1L:"                   "\n\t"
		"sub	%[dly], #1"            "\n\t"
		"bne	L%=_loop_delay_T1L"    "\n\t"
		"nop"                                   "\n\t"
		"L%=_next:"                             "\n\t"
		"sub	%[count], #1"          "\n\t"
		"bne	L%=_loop"              "\n\t"
		"lsl	%[pix], #1"            "\n\t"
		"bcs	L%=_last_one"          "\n\t"
		"L%=_last_zero:"
		"strb	%[bitmask], [%[reg], #0]" "\n\t"
		"movs	%[dly], #4"               "\n\t"
		"L%=_last_delay_T0H:"                   "\n\t"
		"sub	%[dly], #1"            "\n\t"
		"bne	L%=_last_delay_T0H"    "\n\t"
		"strb	%[bitmask], [%[reg], #4]" "\n\t"
		"movs	%[dly], #10"              "\n\t"
		"L%=_last_delay_T0L:"                   "\n\t"
		"sub	%[dly], #1"            "\n\t"
		"bne	L%=_last_delay_T0L"    "\n\t"
		"b	L%=_repeat"      "\n\t"
		"L%=_last_one:"
		"strb	%[bitmask], [%[reg], #0]" "\n\t"
		"movs	%[dly], #13"              "\n\t"
		"L%=_last_delay_T1H:"                   "\n\t"
		"sub	%[dly], #1"            "\n\t"
		"bne	L%=_last_delay_T1H"    "\n\t"
		"strb	%[bitmask], [%[reg], #4]" "\n\t"
		"movs	%[dly], #1"               "\n\t"
		"L%=_last_delay_T1L:"                   "\n\t"
		"sub	%[dly], #1"            "\n\t"
		"bne	L%=_last_delay_T1L"    "\n\t"
		"nop"                                   "\n\t"
		"L%=_repeat:"                           "\n\t"
		"add	%[p], #1"              "\n\t"
		"sub	%[num], #1"            "\n\t"
		"bne	L%=_begin"             "\n\t"
		"L%=_done:"                             "\n\t"
		: [p] "+r" (p),
		[pix] "=&r" (pix),
		[count] "=&r" (count),
		[dly] "=&r" (dly),
		[num] "+r" (num)
		: [bitmask] "r" (bitmask),
		[reg] "r" (reg)
		);
#else
#error "Sorry, only 48 MHz is supported, please set Tools > CPU Speed to 48 MHz"
#endif // F_CPU == 48000000
#elif defined(__SAMD21G18A__) // Arduino Zero
	// Tried this with a timer/counter, couldn't quite get adequate
	// resolution.  So yay, you get a load of goofball NOPs...

	uint8_t *ptr, *end, p, bitMask, portNum;
	uint32_t pinMask;

	portNum = g_APinDescription[pin].ulPort;
	pinMask = 1ul << g_APinDescription[pin].ulPin;
	ptr = pixels;
	end = ptr + numBytes;
	p = *ptr++;
	bitMask = 0x80;

	volatile uint32_t *set = &(PORT->Group[portNum].OUTSET.reg),
	    *clr = &(PORT->Group[portNum].OUTCLR.reg);

#ifdef NEO_KHZ400 // 800 KHz check needed only if 400 KHz support enabled
	if (is800KHz) {
#endif
	for ( ; ;)
	{
		*set = pinMask;
		asm ("nop; nop; nop; nop; nop; nop; nop; nop;");
		if (p & bitMask) {
			asm ("nop; nop; nop; nop; nop; nop; nop; nop;"
			"nop; nop; nop; nop; nop; nop; nop; nop;"
			"nop; nop; nop; nop;");
			*clr = pinMask;
		} else {
			*clr = pinMask;
			asm ("nop; nop; nop; nop; nop; nop; nop; nop;"
			"nop; nop; nop; nop; nop; nop; nop; nop;"
			"nop; nop; nop; nop;");
		}
		if (bitMask >>= 1) {
			asm ("nop; nop; nop; nop; nop; nop; nop; nop; nop;");
		} else {
			if (ptr >= end) {
				break;
			}
			p = *ptr++;
			bitMask = 0x80;
		}
	}
#ifdef NEO_KHZ400
} else {   // 400 KHz bitstream
	for ( ; ;)
	{
		*set = pinMask;
		asm ("nop; nop; nop; nop; nop; nop; nop; nop; nop; nop; nop;");
		if (p & bitMask) {
			asm ("nop; nop; nop; nop; nop; nop; nop; nop;"
			"nop; nop; nop; nop; nop; nop; nop; nop;"
			"nop; nop; nop; nop; nop; nop; nop; nop;"
			"nop; nop; nop;");
			*clr = pinMask;
		} else {
			*clr = pinMask;
			asm ("nop; nop; nop; nop; nop; nop; nop; nop;"
			"nop; nop; nop; nop; nop; nop; nop; nop;"
			"nop; nop; nop; nop; nop; nop; nop; nop;"
			"nop; nop; nop;");
		}
		asm ("nop; nop; nop; nop; nop; nop; nop; nop;"
		"nop; nop; nop; nop; nop; nop; nop; nop;"
		"nop; nop; nop; nop; nop; nop; nop; nop;"
		"nop; nop; nop; nop; nop; nop; nop; nop;");
		if (bitMask >>= 1) {
			asm ("nop; nop; nop; nop; nop; nop; nop;");
		} else {
			if (ptr >= end) {
				break;
			}
			p = *ptr++;
			bitMask = 0x80;
		}
	}
}
#endif
#elif defined (ARDUINO_STM32_FEATHER) // FEATHER WICED (120MHz)
	// Tried this with a timer/counter, couldn't quite get adequate
	// resolution.  So yay, you get a load of goofball NOPs...

	uint8_t *ptr, *end, p, bitMask;
	uint32_t pinMask;

	pinMask = BIT(PIN_MAP[pin].gpio_bit);
	ptr = pixels;
	end = ptr + numBytes;
	p = *ptr++;
	bitMask = 0x80;

	volatile uint16_t *set = &(PIN_MAP[pin].gpio_device->regs->BSRRL);
	volatile uint16_t *clr = &(PIN_MAP[pin].gpio_device->regs->BSRRH);

#ifdef NEO_KHZ400 // 800 KHz check needed only if 400 KHz support enabled
	if (is800KHz) {
#endif
	for ( ; ;)
	{
		if (p & bitMask) { // ONE
			// High 800ns
			*set = pinMask;
			asm ("nop; nop; nop; nop; nop; nop; nop; nop;"
...

This file has been truncated, please download it to see its full contents.

/*--------------------------------------------------------------------
 *  This file is part of the Adafruit NeoPixel library.
 *
 *  NeoPixel is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU Lesser General Public License as
 *  published by the Free Software Foundation, either version 3 of
 *  the License, or (at your option) any later version.
 *
 *  NeoPixel is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU Lesser General Public License for more details.
 *
 *  You should have received a copy of the GNU Lesser General Public
 *  License along with NeoPixel.  If not, see
 *  <http://www.gnu.org/licenses/>.
 *  --------------------------------------------------------------------*/

#ifndef ADAFRUIT_NEOPIXEL_H
#define ADAFRUIT_NEOPIXEL_H

#if (ARDUINO >= 100)
#include <Arduino.h>
#else
#include <WProgram.h>
#include <pins_arduino.h>
#endif

// The order of primary colors in the NeoPixel data stream can vary
// among device types, manufacturers and even different revisions of
// the same item.  The third parameter to the Adafruit_NeoPixel
// constructor encodes the per-pixel byte offsets of the red, green
// and blue primaries (plus white, if present) in the data stream --
// the following #defines provide an easier-to-use named version for
// each permutation.  e.g. NEO_GRB indicates a NeoPixel-compatible
// device expecting three bytes per pixel, with the first byte
// containing the green value, second containing red and third
// containing blue.  The in-memory representation of a chain of
// NeoPixels is the same as the data-stream order; no re-ordering of
// bytes is required when issuing data to the chain.

// Bits 5,4 of this value are the offset (0-3) from the first byte of
// a pixel to the location of the red color byte.  Bits 3,2 are the
// green offset and 1,0 are the blue offset.  If it is an RGBW-type
// device (supporting a white primary in addition to R,G,B), bits 7,6
// are the offset to the white byte...otherwise, bits 7,6 are set to
// the same value as 5,4 (red) to indicate an RGB (not RGBW) device.
// i.e. binary representation:
// 0bWWRRGGBB for RGBW devices
// 0bRRRRGGBB for RGB

// RGB NeoPixel permutations; white and red offsets are always same
// Offset:         W          R          G          B
#define NEO_RGB		((0 << 6) | (0 << 4) | (1 << 2) | (2))
#define NEO_RBG		((0 << 6) | (0 << 4) | (2 << 2) | (1))
#define NEO_GRB		((1 << 6) | (1 << 4) | (0 << 2) | (2))
#define NEO_GBR		((2 << 6) | (2 << 4) | (0 << 2) | (1))
#define NEO_BRG		((1 << 6) | (1 << 4) | (2 << 2) | (0))
#define NEO_BGR		((2 << 6) | (2 << 4) | (1 << 2) | (0))

// RGBW NeoPixel permutations; all 4 offsets are distinct
// Offset:         W          R          G          B
#define NEO_WRGB	((0 << 6) | (1 << 4) | (2 << 2) | (3))
#define NEO_WRBG	((0 << 6) | (1 << 4) | (3 << 2) | (2))
#define NEO_WGRB	((0 << 6) | (2 << 4) | (1 << 2) | (3))
#define NEO_WGBR	((0 << 6) | (3 << 4) | (1 << 2) | (2))
#define NEO_WBRG	((0 << 6) | (2 << 4) | (3 << 2) | (1))
#define NEO_WBGR	((0 << 6) | (3 << 4) | (2 << 2) | (1))

#define NEO_RWGB	((1 << 6) | (0 << 4) | (2 << 2) | (3))
#define NEO_RWBG	((1 << 6) | (0 << 4) | (3 << 2) | (2))
#define NEO_RGWB	((2 << 6) | (0 << 4) | (1 << 2) | (3))
#define NEO_RGBW	((3 << 6) | (0 << 4) | (1 << 2) | (2))
#define NEO_RBWG	((2 << 6) | (0 << 4) | (3 << 2) | (1))
#define NEO_RBGW	((3 << 6) | (0 << 4) | (2 << 2) | (1))

#define NEO_GWRB	((1 << 6) | (2 << 4) | (0 << 2) | (3))
#define NEO_GWBR	((1 << 6) | (3 << 4) | (0 << 2) | (2))
#define NEO_GRWB	((2 << 6) | (1 << 4) | (0 << 2) | (3))
#define NEO_GRBW	((3 << 6) | (1 << 4) | (0 << 2) | (2))
#define NEO_GBWR	((2 << 6) | (3 << 4) | (0 << 2) | (1))
#define NEO_GBRW	((3 << 6) | (2 << 4) | (0 << 2) | (1))

#define NEO_BWRG	((1 << 6) | (2 << 4) | (3 << 2) | (0))
#define NEO_BWGR	((1 << 6) | (3 << 4) | (2 << 2) | (0))
#define NEO_BRWG	((2 << 6) | (1 << 4) | (3 << 2) | (0))
#define NEO_BRGW	((3 << 6) | (1 << 4) | (2 << 2) | (0))
#define NEO_BGWR	((2 << 6) | (3 << 4) | (1 << 2) | (0))
#define NEO_BGRW	((3 << 6) | (2 << 4) | (1 << 2) | (0))

// Add NEO_KHZ400 to the color order value to indicate a 400 KHz
// device.  All but the earliest v1 NeoPixels expect an 800 KHz data
// stream, this is the default if unspecified.  Because flash space
// is very limited on ATtiny devices (e.g. Trinket, Gemma), v1
// NeoPixels aren't handled by default on those chips, though it can
// be enabled by removing the ifndef/endif below -- but code will be
// bigger.  Conversely, can disable the NEO_KHZ400 line on other MCUs
// to remove v1 support and save a little space.

#define NEO_KHZ800	0x0000  // 800 KHz datastream
#ifndef __AVR_ATtiny85__
#define NEO_KHZ400	0x0100  // 400 KHz datastream
#endif

// If 400 KHz support is enabled, the third parameter to the constructor
// requires a 16-bit value (in order to select 400 vs 800 KHz speed).
// If only 800 KHz is enabled (as is default on ATtiny), an 8-bit value
// is sufficient to encode pixel color order, saving some space.

#ifdef NEO_KHZ400
typedef uint16_t	neoPixelType;
#else
typedef uint8_t		neoPixelType;
#endif

class Adafruit_NeoPixel {
public:

	// Constructor: number of LEDs, pin number, LED type
	Adafruit_NeoPixel(uint16_t n, uint8_t p = 6, neoPixelType t = NEO_GRB + NEO_KHZ800);
	Adafruit_NeoPixel(void);
	~Adafruit_NeoPixel();

	void
	begin(void),
	show(void),
	setPin(uint8_t p),
	setPixelColor(uint16_t n, uint8_t r, uint8_t g, uint8_t b),
	setPixelColor(uint16_t n, uint8_t r, uint8_t g, uint8_t b, uint8_t w),
	setPixelColor(uint16_t n, uint32_t c),
	setBrightness(uint8_t),
	clear(),
	updateLength(uint16_t n),
	updateType(neoPixelType t);
	uint8_t
	*getPixels(void) const,
	getBrightness(void) const;
	uint16_t
	numPixels(void) const;
	static uint32_t
	Color(uint8_t r, uint8_t g, uint8_t b),
	Color(uint8_t r, uint8_t g, uint8_t b, uint8_t w);
	uint32_t
	getPixelColor(uint16_t n) const;

	inline bool
	canShow(void)
	{
		return ((micros() - endTime) >= 50L);
	}


private:

	boolean
#ifdef NEO_KHZ400       // If 400 KHz NeoPixel support enabled...
	is800KHz,       // ...true if 800 KHz pixels
#endif
	begun;          // true if begin() previously called
	uint16_t
	    numLEDs,    // Number of RGB LEDs in strip
	    numBytes;   // Size of 'pixels' buffer below (3 or 4 bytes/pixel)
	int8_t
	    pin;        // Output pin number (-1 if not yet set)
	uint8_t
	    brightness,
	    *pixels,    // Holds LED color values (3 or 4 bytes each)
	    rOffset,    // Index of red byte within each 3- or 4-byte pixel
	    gOffset,    // Index of green byte
	    bOffset,    // Index of blue byte
	    wOffset;    // Index of white byte (same as rOffset if no white)
	uint32_t
	    endTime;    // Latch timing reference
#ifdef __AVR__
	volatile uint8_t
	*port;          // Output PORT register
	uint8_t
	    pinMask;    // Output PORT bitmask
#endif
};

#endif // ADAFRUIT_NEOPIXEL_H

//
#define Note1_0 -1
#define Note1_1 262
#define Note1_2 294
#define Note1_3 330
#define Note1_4 350
#define Note1_5 393
#define Note1_6 441
#define Note1_7 495

#define NOTE1_LEN 32 //

//
int note1[] = {
    Note1_1, Note1_2, Note1_3, Note1_1, Note1_1,
    Note1_2, Note1_3, Note1_1, Note1_3, Note1_4,
    Note1_5, Note1_3, Note1_4, Note1_5, Note1_5,
    Note1_6, Note1_5, Note1_4, Note1_3, Note1_1,
    Note1_5, Note1_6, Note1_5, Note1_4, Note1_3,
    Note1_1, Note1_1, Note1_5, Note1_1, Note1_1,
    Note1_5, Note1_1};

//
float beat1[] = {
    1, 1, 1, 1, 1,
    1, 1, 1, 1, 1,
    2, 1, 1, 2, 0.75,
    0.25, 0.75, 0.25, 1, 1,
    0.75, 0.25, 0.75, 0.25, 1,
    1, 1, 1, 2, 1,
    1, 2};

void play1()
{
    for (int i = 0; i < NOTE1_LEN; i++)
    {
        tone(BEEP_PIN, note1[i]);
        delay(400 * beat1[i]);
        noTone(BEEP_PIN);
    }
}

#define PCINT_VERSION 2402
#define	detachPinChangeInterrupt(pin)				PCintPort::detachInterrupt(pin)
#define	attachPinChangeInterrupt(pin,userFunc,mode)	PCintPort::attachInterrupt(pin, &userFunc,mode)
#define getInterruptedPin()							PCintPort::getArduinoPin()
#ifndef PinChangeInt_h
#define	PinChangeInt_h
#include "stddef.h"
#include <Arduino.h>
#include <new.h>
#include <wiring_private.h>
#undef DEBUG
#undef	INLINE_PCINT
#define INLINE_PCINT
#if defined __AVR_ATmega2560__ || defined __AVR_ATmega1280__ || defined __AVR_ATmega1281__ || defined __AVR_ATmega2561__ || defined __AVR_ATmega640__
	#define __USE_PORT_JK
	#define NO_PORTA_PINCHANGES
	#define NO_PORTC_PINCHANGES
	#define NO_PORTD_PINCHANGES
	#if ((defined(NO_PORTB_PINCHANGES) && defined(NO_PORTJ_PINCHANGES)) || \
			(defined(NO_PORTJ_PINCHANGES) && defined(NO_PORTK_PINCHANGES)) || \
			(defined(NO_PORTK_PINCHANGES) && defined(NO_PORTB_PINCHANGES)))
		#define	INLINE_PCINT inline
	#endif
#else
	#define NO_PORTJ_PINCHANGES
	#define NO_PORTK_PINCHANGES
	#if defined(__AVR_ATmega644P__) || defined(__AVR_ATmega644__)
		#ifndef NO_PORTA_PINCHANGES
			#define __USE_PORT_A
		#endif
	#else
		#define NO_PORTA_PINCHANGES
	#endif
	#if (   (defined(NO_PORTA_PINCHANGES) && defined(NO_PORTB_PINCHANGES) && defined(NO_PORTC_PINCHANGES)) || \
			(defined(NO_PORTA_PINCHANGES) && defined(NO_PORTB_PINCHANGES) && defined(NO_PORTD_PINCHANGES)) || \
			(defined(NO_PORTA_PINCHANGES) && defined(NO_PORTC_PINCHANGES) && defined(NO_PORTD_PINCHANGES)) || \
			(defined(NO_PORTB_PINCHANGES) && defined(NO_PORTC_PINCHANGES) && defined(NO_PORTD_PINCHANGES)) )
		#define	INLINE_PCINT inline
	#endif
#endif
#define	PCdetachInterrupt(pin)	PCintPort::detachInterrupt(pin)
#define	PCattachInterrupt(pin,userFunc,mode) PCintPort::attachInterrupt(pin, userFunc,mode)
#define PCgetArduinoPin() PCintPort::getArduinoPin()
typedef void (*PCIntvoidFuncPtr)(void);
class PCintPort {
public:
	PCintPort(int index,int pcindex, volatile uint8_t& maskReg) :
	portInputReg(*portInputRegister(index)),
	portPCMask(maskReg),
	PCICRbit(1 << pcindex),
	portRisingPins(0),
	portFallingPins(0),
	firstPin(NULL)
#ifdef PINMODE
	,intrCount(0)
#endif
	{
		#ifdef FLASH
		ledsetup();
		#endif
	}
	volatile	uint8_t&		portInputReg;
	static		int8_t attachInterrupt(uint8_t pin, PCIntvoidFuncPtr userFunc, int mode);
	static		void detachInterrupt(uint8_t pin);
	INLINE_PCINT void PCint();
	static volatile uint8_t curr;
	#ifndef NO_PIN_NUMBER
	static	volatile uint8_t	arduinoPin;
	#endif
	#ifndef NO_PIN_STATE
	static volatile	uint8_t	pinState;
	#endif
	#ifdef PINMODE
	static volatile uint8_t pinmode;
	static volatile uint8_t s_portRisingPins;
	static volatile uint8_t s_portFallingPins;
	static volatile uint8_t s_lastPinView;
	static volatile uint8_t s_pmask;
	static volatile char s_PORT;
	static volatile uint8_t s_changedPins;
	static volatile uint8_t s_portRisingPins_nCurr;
	static volatile uint8_t s_portFallingPins_nNCurr;
	static volatile uint8_t s_currXORlastPinView;
	volatile uint8_t intrCount;
	static volatile uint8_t s_count;
	static volatile uint8_t pcint_multi;
	static volatile uint8_t PCIFRbug;
	#endif
	#ifdef FLASH
	static void ledsetup(void);
	#endif
protected:
	class PCintPin {
	public:
		PCintPin() :
		PCintFunc((PCIntvoidFuncPtr)NULL),
		mode(0) {}
		PCIntvoidFuncPtr PCintFunc;
		uint8_t 	mode;
		uint8_t		mask;
		uint8_t arduinoPin;
		PCintPin* next;
	};
	void 		enable(PCintPin* pin, PCIntvoidFuncPtr userFunc, uint8_t mode);
	int8_t		addPin(uint8_t arduinoPin,PCIntvoidFuncPtr userFunc, uint8_t mode);
	volatile	uint8_t&		portPCMask;
	const		uint8_t			PCICRbit;
	volatile	uint8_t			portRisingPins;
	volatile	uint8_t			portFallingPins;
	volatile uint8_t		lastPinView;
	PCintPin*	firstPin;
};
#ifndef LIBCALL_PINCHANGEINT
volatile uint8_t PCintPort::curr=0;
#ifndef NO_PIN_NUMBER
volatile uint8_t PCintPort::arduinoPin=0;
#endif
#ifndef NO_PIN_STATE
volatile uint8_t PCintPort::pinState=0;
#endif
#ifdef PINMODE
volatile uint8_t PCintPort::pinmode=0;
volatile uint8_t PCintPort::s_portRisingPins=0;
volatile uint8_t PCintPort::s_portFallingPins=0;
volatile uint8_t PCintPort::s_lastPinView=0;
volatile uint8_t PCintPort::s_pmask=0;
volatile char	 PCintPort::s_PORT='x';
volatile uint8_t PCintPort::s_changedPins=0;
volatile uint8_t PCintPort::s_portRisingPins_nCurr=0;
volatile uint8_t PCintPort::s_portFallingPins_nNCurr=0;
volatile uint8_t PCintPort::s_currXORlastPinView=0;
volatile uint8_t PCintPort::s_count=0;
volatile uint8_t PCintPort::pcint_multi=0;
volatile uint8_t PCintPort::PCIFRbug=0;
#endif
#ifdef FLASH
#define PINLED 13
volatile uint8_t *led_port;
uint8_t led_mask;
uint8_t not_led_mask;
boolean ledsetup_run=false;
void PCintPort::ledsetup(void) {
	if (! ledsetup_run) {
		led_port=portOutputRegister(digitalPinToPort(PINLED));
		led_mask=digitalPinToBitMask(PINLED);
		not_led_mask=led_mask^0xFF;
		pinMode(PINLED, OUTPUT); digitalWrite(PINLED, LOW);
		ledsetup_run=true;
	}
};
#endif
#if defined(__AVR_ATmega644P__) || defined(__AVR_ATmega644__) 
#ifndef NO_PORTA_PINCHANGES
PCintPort portA=PCintPort(1, 0,PCMSK0);
#endif
#ifndef NO_PORTB_PINCHANGES
PCintPort portB=PCintPort(2, 1,PCMSK1);
#endif
#ifndef NO_PORTC_PINCHANGES
PCintPort portC=PCintPort(3, 2,PCMSK2);
#endif
#ifndef NO_PORTD_PINCHANGES
PCintPort portD=PCintPort(4, 3,PCMSK3);
#endif
#else
#ifndef NO_PORTB_PINCHANGES
PCintPort portB=PCintPort(2, 0,PCMSK0);
#endif
#ifndef NO_PORTC_PINCHANGES
PCintPort portC=PCintPort(3, 1,PCMSK1);
#endif
#ifndef NO_PORTD_PINCHANGES
PCintPort portD=PCintPort(4, 2,PCMSK2);
#endif
#endif
#ifdef __USE_PORT_JK
#ifndef NO_PORTJ_PINCHANGES
PCintPort portJ=PCintPort(10,1,PCMSK1);
#endif
#ifndef NO_PORTK_PINCHANGES
PCintPort portK=PCintPort(11,2,PCMSK2);
#endif
#endif
static PCintPort *lookupPortNumToPort( int portNum ) {
    PCintPort *port = NULL;
	switch (portNum) {
#ifndef NO_PORTA_PINCHANGES
	case 1:
		port=&portA;
		break;
#endif
#ifndef NO_PORTB_PINCHANGES
	case 2:
		port=&portB;
		break;
#endif
#ifndef NO_PORTC_PINCHANGES
	case 3:
		port=&portC;
		break;
#endif
#ifndef NO_PORTD_PINCHANGES
	case 4:
		port=&portD;
		break;
#endif
#ifdef __USE_PORT_JK
#ifndef NO_PORTJ_PINCHANGES
	case 10:
		port=&portJ;
		break;
#endif
#ifndef NO_PORTK_PINCHANGES
	case 11:
		port=&portK;
		break;
#endif
#endif
    }
    return port;
}
void PCintPort::enable(PCintPin* p, PCIntvoidFuncPtr userFunc, uint8_t mode) {
	p->mode=mode;
	p->PCintFunc=userFunc;
#ifndef NO_PORTJ_PINCHANGES
	if ((p->arduinoPin == 14) || (p->arduinoPin == 15)) {
		portPCMask |= (p->mask << 1);
	}
	else {
		portPCMask |= p->mask;
	}
#else
    portPCMask |= p->mask;
#endif
	if ((p->mode == RISING) || (p->mode == CHANGE)) portRisingPins |= p->mask;
	if ((p->mode == FALLING) || (p->mode == CHANGE)) portFallingPins |= p->mask;
	PCICR |= PCICRbit;
}
int8_t PCintPort::addPin(uint8_t arduinoPin, PCIntvoidFuncPtr userFunc, uint8_t mode)
{
	PCintPin* tmp;
	tmp=firstPin;
	if (firstPin != NULL) {
		do {
			if (tmp->arduinoPin == arduinoPin) { enable(tmp, userFunc, mode); return(0); }
			if (tmp->next == NULL) break;
			tmp=tmp->next;
		} while (true);
	}
	PCintPin* p=new PCintPin;
	if (p == NULL) return(-1);
	p->arduinoPin=arduinoPin;
	p->mode = mode;
	p->next=NULL;
	p->mask = digitalPinToBitMask(arduinoPin);
	if (firstPin == NULL) firstPin=p;
	else tmp->next=p;
#ifdef DEBUG
	Serial.print("addPin. pin given: "); Serial.print(arduinoPin, DEC);
	int addr = (int) p;
	Serial.print(" instance addr: "); Serial.println(addr, HEX);
	Serial.print("userFunc addr: "); Serial.println((int)p->PCintFunc, HEX);
#endif
	enable(p, userFunc, mode);
#ifdef DEBUG
	Serial.print("addPin. pin given: "); Serial.print(arduinoPin, DEC), Serial.print (" pin stored: ");
	int addr = (int) p;
	Serial.print(" instance addr: "); Serial.println(addr, HEX);
#endif
	return(1);
}
int8_t PCintPort::attachInterrupt(uint8_t arduinoPin, PCIntvoidFuncPtr userFunc, int mode)
{
	PCintPort *port;
	uint8_t portNum = digitalPinToPort(arduinoPin);
	if ((portNum == NOT_A_PORT) || (userFunc == NULL)) return(-1);
	port=lookupPortNumToPort(portNum);
	port->lastPinView=port->portInputReg;
#ifdef DEBUG
	Serial.print("attachInterrupt- pin: "); Serial.println(arduinoPin, DEC);
#endif
	return(port->addPin(arduinoPin,userFunc,mode));
}
void PCintPort::detachInterrupt(uint8_t arduinoPin)
{
	PCintPort *port;
	PCintPin* current;
	uint8_t mask;
	uint8_t portNum = digitalPinToPort(arduinoPin);
	if (portNum == NOT_A_PORT) return;
	port=lookupPortNumToPort(portNum);
	mask=digitalPinToBitMask(arduinoPin);
	current=port->firstPin;
	while (current) {
		if (current->mask == mask) {
			uint8_t oldSREG = SREG;
			cli();
#ifndef NO_PORTJ_PINCHANGES
			if ((arduinoPin == 14) || (arduinoPin == 15)) {
				port->portPCMask &= ~(mask << 1);
			}
			else {
				port->portPCMask &= ~mask;
			}
#else
			port->portPCMask &= ~mask;
#endif
			if (port->portPCMask == 0) PCICR &= ~(port->PCICRbit);
			port->portRisingPins &= ~current->mask; port->portFallingPins &= ~current->mask;
			SREG = oldSREG; 
			return;
		}
		current=current->next;
	}
}
void PCintPort::PCint() {
	#ifdef FLASH
	if (*led_port & led_mask) *led_port&=not_led_mask;
	else *led_port|=led_mask;
    #endif
	#ifndef DISABLE_PCINT_MULTI_SERVICE
	uint8_t pcifr;
	while (true) {
	#endif
		#ifdef PINMODE
		PCintPort::s_lastPinView=lastPinView;
		intrCount++;
		PCintPort::s_count=intrCount;
		#endif
		uint8_t changedPins = (PCintPort::curr ^ lastPinView) &
							  ((portRisingPins & PCintPort::curr ) | ( portFallingPins & ~PCintPort::curr ));
		#ifdef PINMODE
		PCintPort::s_currXORlastPinView=PCintPort::curr ^ lastPinView;
		PCintPort::s_portRisingPins_nCurr=portRisingPins & PCintPort::curr;
		PCintPort::s_portFallingPins_nNCurr=portFallingPins & ~PCintPort::curr;
		#endif
		lastPinView = PCintPort::curr;
		PCintPin* p = firstPin;
		while (p) {
			if (p->mask & changedPins) {
				#ifndef NO_PIN_STATE
				PCintPort::pinState=PCintPort::curr & p->mask ? HIGH : LOW;
				#endif
				#ifndef NO_PIN_NUMBER
				PCintPort::arduinoPin=p->arduinoPin;
				#endif
				#ifdef PINMODE
				PCintPort::pinmode=p->mode;
				PCintPort::s_portRisingPins=portRisingPins;
				PCintPort::s_portFallingPins=portFallingPins;
				PCintPort::s_pmask=p->mask;
				PCintPort::s_changedPins=changedPins;
				#endif
				p->PCintFunc();
			}
			p=p->next;
		}
	#ifndef DISABLE_PCINT_MULTI_SERVICE
		pcifr = PCIFR & PCICRbit;
		if (pcifr == 0) break;
		PCIFR |= PCICRbit;
		#ifdef PINMODE
		PCintPort::pcint_multi++;
		if (PCIFR & PCICRbit) PCintPort::PCIFRbug=1;
		#endif
		PCintPort::curr=portInputReg;
	}
	#endif
}
#ifndef NO_PORTA_PINCHANGES
ISR(PCINT0_vect) {
	#ifdef PINMODE
	PCintPort::s_PORT='A';
	#endif
	PCintPort::curr = portA.portInputReg;
	portA.PCint();
}
#define PORTBVECT PCINT1_vect
#define PORTCVECT PCINT2_vect
#define PORTDVECT PCINT3_vect
#else
#define PORTBVECT PCINT0_vect
#define PORTCVECT PCINT1_vect
#define PORTDVECT PCINT2_vect
#endif
#ifndef NO_PORTB_PINCHANGES
ISR(PORTBVECT) {
	#ifdef PINMODE
	PCintPort::s_PORT='B';
	#endif
	PCintPort::curr = portB.portInputReg;
	portB.PCint();
}
#endif
#ifndef NO_PORTC_PINCHANGES
ISR(PORTCVECT) {
	#ifdef PINMODE
	PCintPort::s_PORT='C';
	#endif
	PCintPort::curr = portC.portInputReg;
	portC.PCint();
}
#endif
#ifndef NO_PORTD_PINCHANGES
ISR(PORTDVECT){
	#ifdef PINMODE
	PCintPort::s_PORT='D';
	#endif
	PCintPort::curr = portD.portInputReg;
	portD.PCint();
}
#endif
#ifdef __USE_PORT_JK
#ifndef NO_PORTJ_PINCHANGES
ISR(PCINT1_vect) {
	#ifdef PINMODE
	PCintPort::s_PORT='J';
	#endif
	PCintPort::curr = portJ.portInputReg;
	portJ.PCint();
}
#endif
#ifndef NO_PORTK_PINCHANGES
ISR(PCINT2_vect){
	#ifdef PINMODE
	PCintPort::s_PORT='K';
	#endif
	PCintPort::curr = portK.portInputReg;
	portK.PCint();
}
#endif
#endif
#ifdef GET_PCINT_VERSION
uint16_t getPCIntVersion () {
	return ((uint16_t) PCINT_VERSION);
}
#endif
#endif
#endif