visus
/
framework-arduinoteensy-cxx20
Bevaka 1
Stjärnmärk 0
Förgrening 0
Kod Ärenden 0 Pull-förfrågningar 0 Släpp 0 Wiki Aktiviteter
PlatformIO package of the Teensy core framework compatible with GCC 10 & C++20
Du kan inte välja fler än 25 ämnen Ämnen måste starta med en bokstav eller siffra, kan innehålla bindestreck ('-') och vara max 35 tecken långa.
1 Commit
1 Gren
Träd: 4aaa09bd80
Grenar Taggar
${ item.name }
Skapa branchen ${ searchTerm }
från '4aaa09bd80'
${ noResults }
framework-arduinoteensy-cxx20/libraries/Adafruit_NeoPixel/Adafruit_NeoPixel.cpp

2330 lines
88KB
Rå Blame Historik 

  1. /*-------------------------------------------------------------------------

  2.   Arduino library to control a wide variety of WS2811- and WS2812-based RGB

  3.   LED devices such as Adafruit FLORA RGB Smart Pixels and NeoPixel strips.

  4.   Currently handles 400 and 800 KHz bitstreams on 8, 12 and 16 MHz ATmega

  5.   MCUs, with LEDs wired for various color orders.  Handles most output pins

  6.   (possible exception with upper PORT registers on the Arduino Mega).

  7. 

  8.   Written by Phil Burgess / Paint Your Dragon for Adafruit Industries,

  9.   contributions by PJRC, Michael Miller and other members of the open

  10.   source community.

  11. 

  12.   Adafruit invests time and resources providing this open source code,

  13.   please support Adafruit and open-source hardware by purchasing products

  14.   from Adafruit!

  15. 

  16.   -------------------------------------------------------------------------

  17.   This file is part of the Adafruit NeoPixel library.

  18. 

  19.   NeoPixel is free software: you can redistribute it and/or modify

  20.   it under the terms of the GNU Lesser General Public License as

  21.   published by the Free Software Foundation, either version 3 of

  22.   the License, or (at your option) any later version.

  23. 

  24.   NeoPixel is distributed in the hope that it will be useful,

  25.   but WITHOUT ANY WARRANTY; without even the implied warranty of

  26.   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

  27.   GNU Lesser General Public License for more details.

  28. 

  29.   You should have received a copy of the GNU Lesser General Public

  30.   License along with NeoPixel.  If not, see

  31.   <http://www.gnu.org/licenses/>.

  32.   -------------------------------------------------------------------------*/

  33. 

  34. #include "Adafruit_NeoPixel.h"

  35. 

  36. #if defined(NRF52) || defined(NRF52_SERIES)

  37. #include "nrf.h"

  38. 

  39. // Interrupt is only disabled if there is no PWM device available

  40. // Note: Adafruit Bluefruit nrf52 does not use this option

  41. //#define NRF52_DISABLE_INT

  42. #endif

  43. 

  44. // Constructor when length, pin and type are known at compile-time:

  45. Adafruit_NeoPixel::Adafruit_NeoPixel(uint16_t n, uint8_t p, neoPixelType t) :

  46.   begun(false), brightness(0), pixels(NULL), endTime(0)

  47. {

  48.   updateType(t);

  49.   updateLength(n);

  50.   setPin(p);

  51. }

  52. 

  53. // via Michael Vogt/neophob: empty constructor is used when strand length

  54. // isn't known at compile-time; situations where program config might be

  55. // read from internal flash memory or an SD card, or arrive via serial

  56. // command.  If using this constructor, MUST follow up with updateType(),

  57. // updateLength(), etc. to establish the strand type, length and pin number!

  58. Adafruit_NeoPixel::Adafruit_NeoPixel() :

  59. #ifdef NEO_KHZ400

  60.   is800KHz(true),

  61. #endif

  62.   begun(false), numLEDs(0), numBytes(0), pin(-1), brightness(0), pixels(NULL),

  63.   rOffset(1), gOffset(0), bOffset(2), wOffset(1), endTime(0)

  64. {

  65. }

  66. 

  67. Adafruit_NeoPixel::~Adafruit_NeoPixel() {

  68.   if(pixels)   free(pixels);

  69.   if(pin >= 0) pinMode(pin, INPUT);

  70. }

  71. 

  72. void Adafruit_NeoPixel::begin(void) {

  73.   if(pin >= 0) {

  74.     pinMode(pin, OUTPUT);

  75.     digitalWrite(pin, LOW);

  76.   }

  77.   begun = true;

  78. 

  79. }

  80. 

  81. void Adafruit_NeoPixel::updateLength(uint16_t n) {

  82.   if(pixels) free(pixels); // Free existing data (if any)

  83. 

  84.   // Allocate new data -- note: ALL PIXELS ARE CLEARED

  85.   numBytes = n * ((wOffset == rOffset) ? 3 : 4);

  86.   if((pixels = (uint8_t *)malloc(numBytes))) {

  87.     memset(pixels, 0, numBytes);

  88.     numLEDs = n;

  89.   } else {

  90.     numLEDs = numBytes = 0;

  91.   }

  92. }

  93. 

  94. void Adafruit_NeoPixel::updateType(neoPixelType t) {

  95.   boolean oldThreeBytesPerPixel = (wOffset == rOffset); // false if RGBW

  96. 

  97.   wOffset = (t >> 6) & 0b11; // See notes in header file

  98.   rOffset = (t >> 4) & 0b11; // regarding R/G/B/W offsets

  99.   gOffset = (t >> 2) & 0b11;

  100.   bOffset =  t       & 0b11;

  101. #ifdef NEO_KHZ400

  102.   is800KHz = (t < 256);      // 400 KHz flag is 1<<8

  103. #endif

  104. 

  105.   // If bytes-per-pixel has changed (and pixel data was previously

  106.   // allocated), re-allocate to new size.  Will clear any data.

  107.   if(pixels) {

  108.     boolean newThreeBytesPerPixel = (wOffset == rOffset);

  109.     if(newThreeBytesPerPixel != oldThreeBytesPerPixel) updateLength(numLEDs);

  110.   }

  111. }

  112. 

  113. #if defined(ESP8266)

  114. // ESP8266 show() is external to enforce ICACHE_RAM_ATTR execution

  115. extern "C" void ICACHE_RAM_ATTR espShow(

  116.   uint8_t pin, uint8_t *pixels, uint32_t numBytes, uint8_t type);

  117. #elif defined(ESP32)

  118. extern "C" void espShow(

  119.   uint8_t pin, uint8_t *pixels, uint32_t numBytes, uint8_t type);

  120. #endif // ESP8266

  121. 

  122. void Adafruit_NeoPixel::show(void) {

  123. 

  124.   if(!pixels) return;

  125. 

  126.   // Data latch = 300+ microsecond pause in the output stream.  Rather than

  127.   // put a delay at the end of the function, the ending time is noted and

  128.   // the function will simply hold off (if needed) on issuing the

  129.   // subsequent round of data until the latch time has elapsed.  This

  130.   // allows the mainline code to start generating the next frame of data

  131.   // rather than stalling for the latch.

  132.   while(!canShow());

  133.   // endTime is a private member (rather than global var) so that multiple

  134.   // instances on different pins can be quickly issued in succession (each

  135.   // instance doesn't delay the next).

  136. 

  137.   // In order to make this code runtime-configurable to work with any pin,

  138.   // SBI/CBI instructions are eschewed in favor of full PORT writes via the

  139.   // OUT or ST instructions.  It relies on two facts: that peripheral

  140.   // functions (such as PWM) take precedence on output pins, so our PORT-

  141.   // wide writes won't interfere, and that interrupts are globally disabled

  142.   // while data is being issued to the LEDs, so no other code will be

  143.   // accessing the PORT.  The code takes an initial 'snapshot' of the PORT

  144.   // state, computes 'pin high' and 'pin low' values, and writes these back

  145.   // to the PORT register as needed.

  146. 

  147.   // NRF52 may use PWM + DMA (if available), may not need to disable interrupt

  148. #if !( defined(NRF52) || defined(NRF52_SERIES) )

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

  150. #endif

  151. 

  152. #ifdef __AVR__

  153. // AVR MCUs -- ATmega & ATtiny (no XMEGA) ---------------------------------

  154. 

  155.   volatile uint16_t

  156.     i   = numBytes; // Loop counter

  157.   volatile uint8_t

  158.    *ptr = pixels,   // Pointer to next byte

  159.     b   = *ptr++,   // Current byte value

  160.     hi,             // PORT w/output bit set high

  161.     lo;             // PORT w/output bit set low

  162. 

  163.   // Hand-tuned assembly code issues data to the LED drivers at a specific

  164.   // rate.  There's separate code for different CPU speeds (8, 12, 16 MHz)

  165.   // for both the WS2811 (400 KHz) and WS2812 (800 KHz) drivers.  The

  166.   // datastream timing for the LED drivers allows a little wiggle room each

  167.   // way (listed in the datasheets), so the conditions for compiling each

  168.   // case are set up for a range of frequencies rather than just the exact

  169.   // 8, 12 or 16 MHz values, permitting use with some close-but-not-spot-on

  170.   // devices (e.g. 16.5 MHz DigiSpark).  The ranges were arrived at based

  171.   // on the datasheet figures and have not been extensively tested outside

  172.   // the canonical 8/12/16 MHz speeds; there's no guarantee these will work

  173.   // close to the extremes (or possibly they could be pushed further).

  174.   // Keep in mind only one CPU speed case actually gets compiled; the

  175.   // resulting program isn't as massive as it might look from source here.

  176. 

  177. // 8 MHz(ish) AVR ---------------------------------------------------------

  178. #if (F_CPU >= 7400000UL) && (F_CPU <= 9500000UL)

  179. 

  180. #ifdef NEO_KHZ400 // 800 KHz check needed only if 400 KHz support enabled

  181.   if(is800KHz) {

  182. #endif

  183. 

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

  185. 

  186.     // Squeezing an 800 KHz stream out of an 8 MHz chip requires code

  187.     // specific to each PORT register.

  188. 

  189.     // 10 instruction clocks per bit: HHxxxxxLLL

  190.     // OUT instructions:              ^ ^    ^   (T=0,2,7)

  191. 

  192.     // PORTD OUTPUT ----------------------------------------------------

  193. 

  194. #if defined(PORTD)

  195.  #if defined(PORTB) || defined(PORTC) || defined(PORTF)

  196.     if(port == &PORTD) {

  197.  #endif // defined(PORTB/C/F)

  198. 

  199.       hi = PORTD |  pinMask;

  200.       lo = PORTD & ~pinMask;

  201.       n1 = lo;

  202.       if(b & 0x80) n1 = hi;

  203. 

  204.       // Dirty trick: RJMPs proceeding to the next instruction are used

  205.       // to delay two clock cycles in one instruction word (rather than

  206.       // using two NOPs).  This was necessary in order to squeeze the

  207.       // loop down to exactly 64 words -- the maximum possible for a

  208.       // relative branch.

  209. 

  210.       asm volatile(

  211.        "headD:"                   "\n\t" // Clk  Pseudocode

  212.         // Bit 7:

  213.         "out  %[port] , %[hi]"    "\n\t" // 1    PORT = hi

  214.         "mov  %[n2]   , %[lo]"    "\n\t" // 1    n2   = lo

  215.         "out  %[port] , %[n1]"    "\n\t" // 1    PORT = n1

  216.         "rjmp .+0"                "\n\t" // 2    nop nop

  217.         "sbrc %[byte] , 6"        "\n\t" // 1-2  if(b & 0x40)

  218.          "mov %[n2]   , %[hi]"    "\n\t" // 0-1   n2 = hi

  219.         "out  %[port] , %[lo]"    "\n\t" // 1    PORT = lo

  220.         "rjmp .+0"                "\n\t" // 2    nop nop

  221.         // Bit 6:

  222.         "out  %[port] , %[hi]"    "\n\t" // 1    PORT = hi

  223.         "mov  %[n1]   , %[lo]"    "\n\t" // 1    n1   = lo

  224.         "out  %[port] , %[n2]"    "\n\t" // 1    PORT = n2

  225.         "rjmp .+0"                "\n\t" // 2    nop nop

  226.         "sbrc %[byte] , 5"        "\n\t" // 1-2  if(b & 0x20)

  227.          "mov %[n1]   , %[hi]"    "\n\t" // 0-1   n1 = hi

  228.         "out  %[port] , %[lo]"    "\n\t" // 1    PORT = lo

  229.         "rjmp .+0"                "\n\t" // 2    nop nop

  230.         // Bit 5:

  231.         "out  %[port] , %[hi]"    "\n\t" // 1    PORT = hi

  232.         "mov  %[n2]   , %[lo]"    "\n\t" // 1    n2   = lo

  233.         "out  %[port] , %[n1]"    "\n\t" // 1    PORT = n1

  234.         "rjmp .+0"                "\n\t" // 2    nop nop

  235.         "sbrc %[byte] , 4"        "\n\t" // 1-2  if(b & 0x10)

  236.          "mov %[n2]   , %[hi]"    "\n\t" // 0-1   n2 = hi

  237.         "out  %[port] , %[lo]"    "\n\t" // 1    PORT = lo

  238.         "rjmp .+0"                "\n\t" // 2    nop nop

  239.         // Bit 4:

  240.         "out  %[port] , %[hi]"    "\n\t" // 1    PORT = hi

  241.         "mov  %[n1]   , %[lo]"    "\n\t" // 1    n1   = lo

  242.         "out  %[port] , %[n2]"    "\n\t" // 1    PORT = n2

  243.         "rjmp .+0"                "\n\t" // 2    nop nop

  244.         "sbrc %[byte] , 3"        "\n\t" // 1-2  if(b & 0x08)

  245.          "mov %[n1]   , %[hi]"    "\n\t" // 0-1   n1 = hi

  246.         "out  %[port] , %[lo]"    "\n\t" // 1    PORT = lo

  247.         "rjmp .+0"                "\n\t" // 2    nop nop

  248.         // Bit 3:

  249.         "out  %[port] , %[hi]"    "\n\t" // 1    PORT = hi

  250.         "mov  %[n2]   , %[lo]"    "\n\t" // 1    n2   = lo

  251.         "out  %[port] , %[n1]"    "\n\t" // 1    PORT = n1

  252.         "rjmp .+0"                "\n\t" // 2    nop nop

  253.         "sbrc %[byte] , 2"        "\n\t" // 1-2  if(b & 0x04)

  254.          "mov %[n2]   , %[hi]"    "\n\t" // 0-1   n2 = hi

  255.         "out  %[port] , %[lo]"    "\n\t" // 1    PORT = lo

  256.         "rjmp .+0"                "\n\t" // 2    nop nop

  257.         // Bit 2:

  258.         "out  %[port] , %[hi]"    "\n\t" // 1    PORT = hi

  259.         "mov  %[n1]   , %[lo]"    "\n\t" // 1    n1   = lo

  260.         "out  %[port] , %[n2]"    "\n\t" // 1    PORT = n2

  261.         "rjmp .+0"                "\n\t" // 2    nop nop

  262.         "sbrc %[byte] , 1"        "\n\t" // 1-2  if(b & 0x02)

  263.          "mov %[n1]   , %[hi]"    "\n\t" // 0-1   n1 = hi

  264.         "out  %[port] , %[lo]"    "\n\t" // 1    PORT = lo

  265.         "rjmp .+0"                "\n\t" // 2    nop nop

  266.         // Bit 1:

  267.         "out  %[port] , %[hi]"    "\n\t" // 1    PORT = hi

  268.         "mov  %[n2]   , %[lo]"    "\n\t" // 1    n2   = lo

  269.         "out  %[port] , %[n1]"    "\n\t" // 1    PORT = n1

  270.         "rjmp .+0"                "\n\t" // 2    nop nop

  271.         "sbrc %[byte] , 0"        "\n\t" // 1-2  if(b & 0x01)

  272.          "mov %[n2]   , %[hi]"    "\n\t" // 0-1   n2 = hi

  273.         "out  %[port] , %[lo]"    "\n\t" // 1    PORT = lo

  274.         "sbiw %[count], 1"        "\n\t" // 2    i-- (don't act on Z flag yet)

  275.         // Bit 0:

  276.         "out  %[port] , %[hi]"    "\n\t" // 1    PORT = hi

  277.         "mov  %[n1]   , %[lo]"    "\n\t" // 1    n1   = lo

  278.         "out  %[port] , %[n2]"    "\n\t" // 1    PORT = n2

  279.         "ld   %[byte] , %a[ptr]+" "\n\t" // 2    b = *ptr++

  280.         "sbrc %[byte] , 7"        "\n\t" // 1-2  if(b & 0x80)

  281.          "mov %[n1]   , %[hi]"    "\n\t" // 0-1   n1 = hi

  282.         "out  %[port] , %[lo]"    "\n\t" // 1    PORT = lo

  283.         "brne headD"              "\n"   // 2    while(i) (Z flag set above)

  284.       : [byte]  "+r" (b),

  285.         [n1]    "+r" (n1),

  286.         [n2]    "+r" (n2),

  287.         [count] "+w" (i)

  288.       : [port]   "I" (_SFR_IO_ADDR(PORTD)),

  289.         [ptr]    "e" (ptr),

  290.         [hi]     "r" (hi),

  291.         [lo]     "r" (lo));

  292. 

  293.  #if defined(PORTB) || defined(PORTC) || defined(PORTF)

  294.     } else // other PORT(s)

  295.  #endif // defined(PORTB/C/F)

  296. #endif // defined(PORTD)

  297. 

  298.     // PORTB OUTPUT ----------------------------------------------------

  299. 

  300. #if defined(PORTB)

  301.  #if defined(PORTD) || defined(PORTC) || defined(PORTF)

  302.     if(port == &PORTB) {

  303.  #endif // defined(PORTD/C/F)

  304. 

  305.       // Same as above, just switched to PORTB and stripped of comments.

  306.       hi = PORTB |  pinMask;

  307.       lo = PORTB & ~pinMask;

  308.       n1 = lo;

  309.       if(b & 0x80) n1 = hi;

  310. 

  311.       asm volatile(

  312.        "headB:"                   "\n\t"

  313.         "out  %[port] , %[hi]"    "\n\t"

  314.         "mov  %[n2]   , %[lo]"    "\n\t"

  315.         "out  %[port] , %[n1]"    "\n\t"

  316.         "rjmp .+0"                "\n\t"

  317.         "sbrc %[byte] , 6"        "\n\t"

  318.          "mov %[n2]   , %[hi]"    "\n\t"

  319.         "out  %[port] , %[lo]"    "\n\t"

  320.         "rjmp .+0"                "\n\t"

  321.         "out  %[port] , %[hi]"    "\n\t"

  322.         "mov  %[n1]   , %[lo]"    "\n\t"

  323.         "out  %[port] , %[n2]"    "\n\t"

  324.         "rjmp .+0"                "\n\t"

  325.         "sbrc %[byte] , 5"        "\n\t"

  326.          "mov %[n1]   , %[hi]"    "\n\t"

  327.         "out  %[port] , %[lo]"    "\n\t"

  328.         "rjmp .+0"                "\n\t"

  329.         "out  %[port] , %[hi]"    "\n\t"

  330.         "mov  %[n2]   , %[lo]"    "\n\t"

  331.         "out  %[port] , %[n1]"    "\n\t"

  332.         "rjmp .+0"                "\n\t"

  333.         "sbrc %[byte] , 4"        "\n\t"

  334.          "mov %[n2]   , %[hi]"    "\n\t"

  335.         "out  %[port] , %[lo]"    "\n\t"

  336.         "rjmp .+0"                "\n\t"

  337.         "out  %[port] , %[hi]"    "\n\t"

  338.         "mov  %[n1]   , %[lo]"    "\n\t"

  339.         "out  %[port] , %[n2]"    "\n\t"

  340.         "rjmp .+0"                "\n\t"

  341.         "sbrc %[byte] , 3"        "\n\t"

  342.          "mov %[n1]   , %[hi]"    "\n\t"

  343.         "out  %[port] , %[lo]"    "\n\t"

  344.         "rjmp .+0"                "\n\t"

  345.         "out  %[port] , %[hi]"    "\n\t"

  346.         "mov  %[n2]   , %[lo]"    "\n\t"

  347.         "out  %[port] , %[n1]"    "\n\t"

  348.         "rjmp .+0"                "\n\t"

  349.         "sbrc %[byte] , 2"        "\n\t"

  350.          "mov %[n2]   , %[hi]"    "\n\t"

  351.         "out  %[port] , %[lo]"    "\n\t"

  352.         "rjmp .+0"                "\n\t"

  353.         "out  %[port] , %[hi]"    "\n\t"

  354.         "mov  %[n1]   , %[lo]"    "\n\t"

  355.         "out  %[port] , %[n2]"    "\n\t"

  356.         "rjmp .+0"                "\n\t"

  357.         "sbrc %[byte] , 1"        "\n\t"

  358.          "mov %[n1]   , %[hi]"    "\n\t"

  359.         "out  %[port] , %[lo]"    "\n\t"

  360.         "rjmp .+0"                "\n\t"

  361.         "out  %[port] , %[hi]"    "\n\t"

  362.         "mov  %[n2]   , %[lo]"    "\n\t"

  363.         "out  %[port] , %[n1]"    "\n\t"

  364.         "rjmp .+0"                "\n\t"

  365.         "sbrc %[byte] , 0"        "\n\t"

  366.          "mov %[n2]   , %[hi]"    "\n\t"

  367.         "out  %[port] , %[lo]"    "\n\t"

  368.         "sbiw %[count], 1"        "\n\t"

  369.         "out  %[port] , %[hi]"    "\n\t"

  370.         "mov  %[n1]   , %[lo]"    "\n\t"

  371.         "out  %[port] , %[n2]"    "\n\t"

  372.         "ld   %[byte] , %a[ptr]+" "\n\t"

  373.         "sbrc %[byte] , 7"        "\n\t"

  374.          "mov %[n1]   , %[hi]"    "\n\t"

  375.         "out  %[port] , %[lo]"    "\n\t"

  376.         "brne headB"              "\n"

  377.       : [byte] "+r" (b), [n1] "+r" (n1), [n2] "+r" (n2), [count] "+w" (i)

  378.       : [port] "I" (_SFR_IO_ADDR(PORTB)), [ptr] "e" (ptr), [hi] "r" (hi),

  379.         [lo] "r" (lo));

  380. 

  381.  #if defined(PORTD) || defined(PORTC) || defined(PORTF)

  382.     }

  383.  #endif

  384.  #if defined(PORTC) || defined(PORTF)

  385.     else

  386.  #endif // defined(PORTC/F)

  387. #endif // defined(PORTB)

  388. 

  389.     // PORTC OUTPUT ----------------------------------------------------

  390. 

  391. #if defined(PORTC)

  392.  #if defined(PORTD) || defined(PORTB) || defined(PORTF)

  393.     if(port == &PORTC) {

  394.  #endif // defined(PORTD/B/F)

  395. 

  396.       // Same as above, just switched to PORTC and stripped of comments.

  397.       hi = PORTC |  pinMask;

  398.       lo = PORTC & ~pinMask;

  399.       n1 = lo;

  400.       if(b & 0x80) n1 = hi;

  401. 

  402.       asm volatile(

  403.        "headC:"                   "\n\t"

  404.         "out  %[port] , %[hi]"    "\n\t"

  405.         "mov  %[n2]   , %[lo]"    "\n\t"

  406.         "out  %[port] , %[n1]"    "\n\t"

  407.         "rjmp .+0"                "\n\t"

  408.         "sbrc %[byte] , 6"        "\n\t"

  409.          "mov %[n2]   , %[hi]"    "\n\t"

  410.         "out  %[port] , %[lo]"    "\n\t"

  411.         "rjmp .+0"                "\n\t"

  412.         "out  %[port] , %[hi]"    "\n\t"

  413.         "mov  %[n1]   , %[lo]"    "\n\t"

  414.         "out  %[port] , %[n2]"    "\n\t"

  415.         "rjmp .+0"                "\n\t"

  416.         "sbrc %[byte] , 5"        "\n\t"

  417.          "mov %[n1]   , %[hi]"    "\n\t"

  418.         "out  %[port] , %[lo]"    "\n\t"

  419.         "rjmp .+0"                "\n\t"

  420.         "out  %[port] , %[hi]"    "\n\t"

  421.         "mov  %[n2]   , %[lo]"    "\n\t"

  422.         "out  %[port] , %[n1]"    "\n\t"

  423.         "rjmp .+0"                "\n\t"

  424.         "sbrc %[byte] , 4"        "\n\t"

  425.          "mov %[n2]   , %[hi]"    "\n\t"

  426.         "out  %[port] , %[lo]"    "\n\t"

  427.         "rjmp .+0"                "\n\t"

  428.         "out  %[port] , %[hi]"    "\n\t"

  429.         "mov  %[n1]   , %[lo]"    "\n\t"

  430.         "out  %[port] , %[n2]"    "\n\t"

  431.         "rjmp .+0"                "\n\t"

  432.         "sbrc %[byte] , 3"        "\n\t"

  433.          "mov %[n1]   , %[hi]"    "\n\t"

  434.         "out  %[port] , %[lo]"    "\n\t"

  435.         "rjmp .+0"                "\n\t"

  436.         "out  %[port] , %[hi]"    "\n\t"

  437.         "mov  %[n2]   , %[lo]"    "\n\t"

  438.         "out  %[port] , %[n1]"    "\n\t"

  439.         "rjmp .+0"                "\n\t"

  440.         "sbrc %[byte] , 2"        "\n\t"

  441.          "mov %[n2]   , %[hi]"    "\n\t"

  442.         "out  %[port] , %[lo]"    "\n\t"

  443.         "rjmp .+0"                "\n\t"

  444.         "out  %[port] , %[hi]"    "\n\t"

  445.         "mov  %[n1]   , %[lo]"    "\n\t"

  446.         "out  %[port] , %[n2]"    "\n\t"

  447.         "rjmp .+0"                "\n\t"

  448.         "sbrc %[byte] , 1"        "\n\t"

  449.          "mov %[n1]   , %[hi]"    "\n\t"

  450.         "out  %[port] , %[lo]"    "\n\t"

  451.         "rjmp .+0"                "\n\t"

  452.         "out  %[port] , %[hi]"    "\n\t"

  453.         "mov  %[n2]   , %[lo]"    "\n\t"

  454.         "out  %[port] , %[n1]"    "\n\t"

  455.         "rjmp .+0"                "\n\t"

  456.         "sbrc %[byte] , 0"        "\n\t"

  457.          "mov %[n2]   , %[hi]"    "\n\t"

  458.         "out  %[port] , %[lo]"    "\n\t"

  459.         "sbiw %[count], 1"        "\n\t"

  460.         "out  %[port] , %[hi]"    "\n\t"

  461.         "mov  %[n1]   , %[lo]"    "\n\t"

  462.         "out  %[port] , %[n2]"    "\n\t"

  463.         "ld   %[byte] , %a[ptr]+" "\n\t"

  464.         "sbrc %[byte] , 7"        "\n\t"

  465.          "mov %[n1]   , %[hi]"    "\n\t"

  466.         "out  %[port] , %[lo]"    "\n\t"

  467.         "brne headC"              "\n"

  468.       : [byte] "+r" (b), [n1] "+r" (n1), [n2] "+r" (n2), [count] "+w" (i)

  469.       : [port] "I" (_SFR_IO_ADDR(PORTC)), [ptr] "e" (ptr), [hi] "r" (hi),

  470.         [lo] "r" (lo));

  471. 

  472.  #if defined(PORTD) || defined(PORTB) || defined(PORTF)

  473.     }

  474.  #endif // defined(PORTD/B/F)

  475.  #if defined(PORTF)

  476.     else

  477.  #endif

  478. #endif // defined(PORTC)

  479. 

  480.     // PORTF OUTPUT ----------------------------------------------------

  481. 

  482. #if defined(PORTF)

  483.  #if defined(PORTD) || defined(PORTB) || defined(PORTC)

  484.     if(port == &PORTF) {

  485.  #endif // defined(PORTD/B/C)

  486. 

  487.       hi = PORTF |  pinMask;

  488.       lo = PORTF & ~pinMask;

  489.       n1 = lo;

  490.       if(b & 0x80) n1 = hi;

  491. 

  492.       asm volatile(

  493.        "headF:"                   "\n\t"

  494.         "out  %[port] , %[hi]"    "\n\t"

  495.         "mov  %[n2]   , %[lo]"    "\n\t"

  496.         "out  %[port] , %[n1]"    "\n\t"

  497.         "rjmp .+0"                "\n\t"

  498.         "sbrc %[byte] , 6"        "\n\t"

  499.          "mov %[n2]   , %[hi]"    "\n\t"

  500.         "out  %[port] , %[lo]"    "\n\t"

  501.         "rjmp .+0"                "\n\t"

  502.         "out  %[port] , %[hi]"    "\n\t"

  503.         "mov  %[n1]   , %[lo]"    "\n\t"

  504.         "out  %[port] , %[n2]"    "\n\t"

  505.         "rjmp .+0"                "\n\t"

  506.         "sbrc %[byte] , 5"        "\n\t"

  507.          "mov %[n1]   , %[hi]"    "\n\t"

  508.         "out  %[port] , %[lo]"    "\n\t"

  509.         "rjmp .+0"                "\n\t"

  510.         "out  %[port] , %[hi]"    "\n\t"

  511.         "mov  %[n2]   , %[lo]"    "\n\t"

  512.         "out  %[port] , %[n1]"    "\n\t"

  513.         "rjmp .+0"                "\n\t"

  514.         "sbrc %[byte] , 4"        "\n\t"

  515.          "mov %[n2]   , %[hi]"    "\n\t"

  516.         "out  %[port] , %[lo]"    "\n\t"

  517.         "rjmp .+0"                "\n\t"

  518.         "out  %[port] , %[hi]"    "\n\t"

  519.         "mov  %[n1]   , %[lo]"    "\n\t"

  520.         "out  %[port] , %[n2]"    "\n\t"

  521.         "rjmp .+0"                "\n\t"

  522.         "sbrc %[byte] , 3"        "\n\t"

  523.          "mov %[n1]   , %[hi]"    "\n\t"

  524.         "out  %[port] , %[lo]"    "\n\t"

  525.         "rjmp .+0"                "\n\t"

  526.         "out  %[port] , %[hi]"    "\n\t"

  527.         "mov  %[n2]   , %[lo]"    "\n\t"

  528.         "out  %[port] , %[n1]"    "\n\t"

  529.         "rjmp .+0"                "\n\t"

  530.         "sbrc %[byte] , 2"        "\n\t"

  531.          "mov %[n2]   , %[hi]"    "\n\t"

  532.         "out  %[port] , %[lo]"    "\n\t"

  533.         "rjmp .+0"                "\n\t"

  534.         "out  %[port] , %[hi]"    "\n\t"

  535.         "mov  %[n1]   , %[lo]"    "\n\t"

  536.         "out  %[port] , %[n2]"    "\n\t"

  537.         "rjmp .+0"                "\n\t"

  538.         "sbrc %[byte] , 1"        "\n\t"

  539.          "mov %[n1]   , %[hi]"    "\n\t"

  540.         "out  %[port] , %[lo]"    "\n\t"

  541.         "rjmp .+0"                "\n\t"

  542.         "out  %[port] , %[hi]"    "\n\t"

  543.         "mov  %[n2]   , %[lo]"    "\n\t"

  544.         "out  %[port] , %[n1]"    "\n\t"

  545.         "rjmp .+0"                "\n\t"

  546.         "sbrc %[byte] , 0"        "\n\t"

  547.          "mov %[n2]   , %[hi]"    "\n\t"

  548.         "out  %[port] , %[lo]"    "\n\t"

  549.         "sbiw %[count], 1"        "\n\t"

  550.         "out  %[port] , %[hi]"    "\n\t"

  551.         "mov  %[n1]   , %[lo]"    "\n\t"

  552.         "out  %[port] , %[n2]"    "\n\t"

  553.         "ld   %[byte] , %a[ptr]+" "\n\t"

  554.         "sbrc %[byte] , 7"        "\n\t"

  555.          "mov %[n1]   , %[hi]"    "\n\t"

  556.         "out  %[port] , %[lo]"    "\n\t"

  557.         "brne headF"              "\n"

  558.       : [byte] "+r" (b), [n1] "+r" (n1), [n2] "+r" (n2), [count] "+w" (i)

  559.       : [port] "I" (_SFR_IO_ADDR(PORTF)), [ptr] "e" (ptr), [hi] "r" (hi),

  560.         [lo] "r" (lo));

  561. 

  562.  #if defined(PORTD) || defined(PORTB) || defined(PORTC)

  563.     }

  564.  #endif // defined(PORTD/B/C)

  565. #endif // defined(PORTF)

  566. 

  567. #ifdef NEO_KHZ400

  568.   } else { // end 800 KHz, do 400 KHz

  569. 

  570.     // Timing is more relaxed; unrolling the inner loop for each bit is

  571.     // not necessary.  Still using the peculiar RJMPs as 2X NOPs, not out

  572.     // of need but just to trim the code size down a little.

  573.     // This 400-KHz-datastream-on-8-MHz-CPU code is not quite identical

  574.     // to the 800-on-16 code later -- the hi/lo timing between WS2811 and

  575.     // WS2812 is not simply a 2:1 scale!

  576. 

  577.     // 20 inst. clocks per bit: HHHHxxxxxxLLLLLLLLLL

  578.     // ST instructions:         ^   ^     ^          (T=0,4,10)

  579. 

  580.     volatile uint8_t next, bit;

  581. 

  582.     hi   = *port |  pinMask;

  583.     lo   = *port & ~pinMask;

  584.     next = lo;

  585.     bit  = 8;

  586. 

  587.     asm volatile(

  588.      "head20:"                  "\n\t" // Clk  Pseudocode    (T =  0)

  589.       "st   %a[port], %[hi]"    "\n\t" // 2    PORT = hi     (T =  2)

  590.       "sbrc %[byte] , 7"        "\n\t" // 1-2  if(b & 128)

  591.        "mov  %[next], %[hi]"    "\n\t" // 0-1   next = hi    (T =  4)

  592.       "st   %a[port], %[next]"  "\n\t" // 2    PORT = next   (T =  6)

  593.       "mov  %[next] , %[lo]"    "\n\t" // 1    next = lo     (T =  7)

  594.       "dec  %[bit]"             "\n\t" // 1    bit--         (T =  8)

  595.       "breq nextbyte20"         "\n\t" // 1-2  if(bit == 0)

  596.       "rol  %[byte]"            "\n\t" // 1    b <<= 1       (T = 10)

  597.       "st   %a[port], %[lo]"    "\n\t" // 2    PORT = lo     (T = 12)

  598.       "rjmp .+0"                "\n\t" // 2    nop nop       (T = 14)

  599.       "rjmp .+0"                "\n\t" // 2    nop nop       (T = 16)

  600.       "rjmp .+0"                "\n\t" // 2    nop nop       (T = 18)

  601.       "rjmp head20"             "\n\t" // 2    -> head20 (next bit out)

  602.      "nextbyte20:"              "\n\t" //                    (T = 10)

  603.       "st   %a[port], %[lo]"    "\n\t" // 2    PORT = lo     (T = 12)

  604.       "nop"                     "\n\t" // 1    nop           (T = 13)

  605.       "ldi  %[bit]  , 8"        "\n\t" // 1    bit = 8       (T = 14)

  606.       "ld   %[byte] , %a[ptr]+" "\n\t" // 2    b = *ptr++    (T = 16)

  607.       "sbiw %[count], 1"        "\n\t" // 2    i--           (T = 18)

  608.       "brne head20"             "\n"   // 2    if(i != 0) -> (next byte)

  609.       : [port]  "+e" (port),

  610.         [byte]  "+r" (b),

  611.         [bit]   "+r" (bit),

  612.         [next]  "+r" (next),

  613.         [count] "+w" (i)

  614.       : [hi]    "r" (hi),

  615.         [lo]    "r" (lo),

  616.         [ptr]   "e" (ptr));

  617.   }

  618. #endif // NEO_KHZ400

  619. 

  620. // 12 MHz(ish) AVR --------------------------------------------------------

  621. #elif (F_CPU >= 11100000UL) && (F_CPU <= 14300000UL)

  622. 

  623. #ifdef NEO_KHZ400 // 800 KHz check needed only if 400 KHz support enabled

  624.   if(is800KHz) {

  625. #endif

  626. 

  627.     // In the 12 MHz case, an optimized 800 KHz datastream (no dead time

  628.     // between bytes) requires a PORT-specific loop similar to the 8 MHz

  629.     // code (but a little more relaxed in this case).

  630. 

  631.     // 15 instruction clocks per bit: HHHHxxxxxxLLLLL

  632.     // OUT instructions:              ^   ^     ^     (T=0,4,10)

  633. 

  634.     volatile uint8_t next;

  635. 

  636.     // PORTD OUTPUT ----------------------------------------------------

  637. 

  638. #if defined(PORTD)

  639.  #if defined(PORTB) || defined(PORTC) || defined(PORTF)

  640.     if(port == &PORTD) {

  641.  #endif // defined(PORTB/C/F)

  642. 

  643.       hi   = PORTD |  pinMask;

  644.       lo   = PORTD & ~pinMask;

  645.       next = lo;

  646.       if(b & 0x80) next = hi;

  647. 

  648.       // Don't "optimize" the OUT calls into the bitTime subroutine;

  649.       // we're exploiting the RCALL and RET as 3- and 4-cycle NOPs!

  650.       asm volatile(

  651.        "headD:"                   "\n\t" //        (T =  0)

  652.         "out   %[port], %[hi]"    "\n\t" //        (T =  1)

  653.         "rcall bitTimeD"          "\n\t" // Bit 7  (T = 15)

  654.         "out   %[port], %[hi]"    "\n\t"

  655.         "rcall bitTimeD"          "\n\t" // Bit 6

  656.         "out   %[port], %[hi]"    "\n\t"

  657.         "rcall bitTimeD"          "\n\t" // Bit 5

  658.         "out   %[port], %[hi]"    "\n\t"

  659.         "rcall bitTimeD"          "\n\t" // Bit 4

  660.         "out   %[port], %[hi]"    "\n\t"

  661.         "rcall bitTimeD"          "\n\t" // Bit 3

  662.         "out   %[port], %[hi]"    "\n\t"

  663.         "rcall bitTimeD"          "\n\t" // Bit 2

  664.         "out   %[port], %[hi]"    "\n\t"

  665.         "rcall bitTimeD"          "\n\t" // Bit 1

  666.         // Bit 0:

  667.         "out  %[port] , %[hi]"    "\n\t" // 1    PORT = hi    (T =  1)

  668.         "rjmp .+0"                "\n\t" // 2    nop nop      (T =  3)

  669.         "ld   %[byte] , %a[ptr]+" "\n\t" // 2    b = *ptr++   (T =  5)

  670.         "out  %[port] , %[next]"  "\n\t" // 1    PORT = next  (T =  6)

  671.         "mov  %[next] , %[lo]"    "\n\t" // 1    next = lo    (T =  7)

  672.         "sbrc %[byte] , 7"        "\n\t" // 1-2  if(b & 0x80) (T =  8)

  673.          "mov %[next] , %[hi]"    "\n\t" // 0-1    next = hi  (T =  9)

  674.         "nop"                     "\n\t" // 1                 (T = 10)

  675.         "out  %[port] , %[lo]"    "\n\t" // 1    PORT = lo    (T = 11)

  676.         "sbiw %[count], 1"        "\n\t" // 2    i--          (T = 13)

  677.         "brne headD"              "\n\t" // 2    if(i != 0) -> (next byte)

  678.          "rjmp doneD"             "\n\t"

  679.         "bitTimeD:"               "\n\t" //      nop nop nop     (T =  4)

  680.          "out  %[port], %[next]"  "\n\t" // 1    PORT = next     (T =  5)

  681.          "mov  %[next], %[lo]"    "\n\t" // 1    next = lo       (T =  6)

  682.          "rol  %[byte]"           "\n\t" // 1    b <<= 1         (T =  7)

  683.          "sbrc %[byte], 7"        "\n\t" // 1-2  if(b & 0x80)    (T =  8)

  684.           "mov %[next], %[hi]"    "\n\t" // 0-1   next = hi      (T =  9)

  685.          "nop"                    "\n\t" // 1                    (T = 10)

  686.          "out  %[port], %[lo]"    "\n\t" // 1    PORT = lo       (T = 11)

  687.          "ret"                    "\n\t" // 4    nop nop nop nop (T = 15)

  688.          "doneD:"                 "\n"

  689.         : [byte]  "+r" (b),

  690.           [next]  "+r" (next),

  691.           [count] "+w" (i)

  692.         : [port]   "I" (_SFR_IO_ADDR(PORTD)),

  693.           [ptr]    "e" (ptr),

  694.           [hi]     "r" (hi),

  695.           [lo]     "r" (lo));

  696. 

  697.  #if defined(PORTB) || defined(PORTC) || defined(PORTF)

  698.     } else // other PORT(s)

  699.  #endif // defined(PORTB/C/F)

  700. #endif // defined(PORTD)

  701. 

  702.     // PORTB OUTPUT ----------------------------------------------------

  703. 

  704. #if defined(PORTB)

  705.  #if defined(PORTD) || defined(PORTC) || defined(PORTF)

  706.     if(port == &PORTB) {

  707.  #endif // defined(PORTD/C/F)

  708. 

  709.       hi   = PORTB |  pinMask;

  710.       lo   = PORTB & ~pinMask;

  711.       next = lo;

  712.       if(b & 0x80) next = hi;

  713. 

  714.       // Same as above, just set for PORTB & stripped of comments

  715.       asm volatile(

  716.        "headB:"                   "\n\t"

  717.         "out   %[port], %[hi]"    "\n\t"

  718.         "rcall bitTimeB"          "\n\t"

  719.         "out   %[port], %[hi]"    "\n\t"

  720.         "rcall bitTimeB"          "\n\t"

  721.         "out   %[port], %[hi]"    "\n\t"

  722.         "rcall bitTimeB"          "\n\t"

  723.         "out   %[port], %[hi]"    "\n\t"

  724.         "rcall bitTimeB"          "\n\t"

  725.         "out   %[port], %[hi]"    "\n\t"

  726.         "rcall bitTimeB"          "\n\t"

  727.         "out   %[port], %[hi]"    "\n\t"

  728.         "rcall bitTimeB"          "\n\t"

  729.         "out   %[port], %[hi]"    "\n\t"

  730.         "rcall bitTimeB"          "\n\t"

  731.         "out  %[port] , %[hi]"    "\n\t"

  732.         "rjmp .+0"                "\n\t"

  733.         "ld   %[byte] , %a[ptr]+" "\n\t"

  734.         "out  %[port] , %[next]"  "\n\t"

  735.         "mov  %[next] , %[lo]"    "\n\t"

  736.         "sbrc %[byte] , 7"        "\n\t"

  737.          "mov %[next] , %[hi]"    "\n\t"

  738.         "nop"                     "\n\t"

  739.         "out  %[port] , %[lo]"    "\n\t"

  740.         "sbiw %[count], 1"        "\n\t"

  741.         "brne headB"              "\n\t"

  742.          "rjmp doneB"             "\n\t"

  743.         "bitTimeB:"               "\n\t"

  744.          "out  %[port], %[next]"  "\n\t"

  745.          "mov  %[next], %[lo]"    "\n\t"

  746.          "rol  %[byte]"           "\n\t"

  747.          "sbrc %[byte], 7"        "\n\t"

  748.           "mov %[next], %[hi]"    "\n\t"

  749.          "nop"                    "\n\t"

  750.          "out  %[port], %[lo]"    "\n\t"

  751.          "ret"                    "\n\t"

  752.          "doneB:"                 "\n"

  753.         : [byte] "+r" (b), [next] "+r" (next), [count] "+w" (i)

  754.         : [port] "I" (_SFR_IO_ADDR(PORTB)), [ptr] "e" (ptr), [hi] "r" (hi),

  755.           [lo] "r" (lo));

  756. 

  757.  #if defined(PORTD) || defined(PORTC) || defined(PORTF)

  758.     }

  759.  #endif

  760.  #if defined(PORTC) || defined(PORTF)

  761.     else

  762.  #endif // defined(PORTC/F)

  763. #endif // defined(PORTB)

  764. 

  765.     // PORTC OUTPUT ----------------------------------------------------

  766. 

  767. #if defined(PORTC)

  768.  #if defined(PORTD) || defined(PORTB) || defined(PORTF)

  769.     if(port == &PORTC) {

  770.  #endif // defined(PORTD/B/F)

  771. 

  772.       hi   = PORTC |  pinMask;

  773.       lo   = PORTC & ~pinMask;

  774.       next = lo;

  775.       if(b & 0x80) next = hi;

  776. 

  777.       // Same as above, just set for PORTC & stripped of comments

  778.       asm volatile(

  779.        "headC:"                   "\n\t"

  780.         "out   %[port], %[hi]"    "\n\t"

  781.         "rcall bitTimeC"          "\n\t"

  782.         "out   %[port], %[hi]"    "\n\t"

  783.         "rcall bitTimeC"          "\n\t"

  784.         "out   %[port], %[hi]"    "\n\t"

  785.         "rcall bitTimeC"          "\n\t"

  786.         "out   %[port], %[hi]"    "\n\t"

  787.         "rcall bitTimeC"          "\n\t"

  788.         "out   %[port], %[hi]"    "\n\t"

  789.         "rcall bitTimeC"          "\n\t"

  790.         "out   %[port], %[hi]"    "\n\t"

  791.         "rcall bitTimeC"          "\n\t"

  792.         "out   %[port], %[hi]"    "\n\t"

  793.         "rcall bitTimeC"          "\n\t"

  794.         "out  %[port] , %[hi]"    "\n\t"

  795.         "rjmp .+0"                "\n\t"

  796.         "ld   %[byte] , %a[ptr]+" "\n\t"

  797.         "out  %[port] , %[next]"  "\n\t"

  798.         "mov  %[next] , %[lo]"    "\n\t"

  799.         "sbrc %[byte] , 7"        "\n\t"

  800.          "mov %[next] , %[hi]"    "\n\t"

  801.         "nop"                     "\n\t"

  802.         "out  %[port] , %[lo]"    "\n\t"

  803.         "sbiw %[count], 1"        "\n\t"

  804.         "brne headC"              "\n\t"

  805.          "rjmp doneC"             "\n\t"

  806.         "bitTimeC:"               "\n\t"

  807.          "out  %[port], %[next]"  "\n\t"

  808.          "mov  %[next], %[lo]"    "\n\t"

  809.          "rol  %[byte]"           "\n\t"

  810.          "sbrc %[byte], 7"        "\n\t"

  811.           "mov %[next], %[hi]"    "\n\t"

  812.          "nop"                    "\n\t"

  813.          "out  %[port], %[lo]"    "\n\t"

  814.          "ret"                    "\n\t"

  815.          "doneC:"                 "\n"

  816.         : [byte] "+r" (b), [next] "+r" (next), [count] "+w" (i)

  817.         : [port] "I" (_SFR_IO_ADDR(PORTC)), [ptr] "e" (ptr), [hi] "r" (hi),

  818.           [lo] "r" (lo));

  819. 

  820.  #if defined(PORTD) || defined(PORTB) || defined(PORTF)

  821.     }

  822.  #endif // defined(PORTD/B/F)

  823.  #if defined(PORTF)

  824.     else

  825.  #endif

  826. #endif // defined(PORTC)

  827. 

  828.     // PORTF OUTPUT ----------------------------------------------------

  829. 

  830. #if defined(PORTF)

  831.  #if defined(PORTD) || defined(PORTB) || defined(PORTC)

  832.     if(port == &PORTF) {

  833.  #endif // defined(PORTD/B/C)

  834. 

  835.       hi   = PORTF |  pinMask;

  836.       lo   = PORTF & ~pinMask;

  837.       next = lo;

  838.       if(b & 0x80) next = hi;

  839. 

  840.       // Same as above, just set for PORTF & stripped of comments

  841.       asm volatile(

  842.        "headF:"                   "\n\t"

  843.         "out   %[port], %[hi]"    "\n\t"

  844.         "rcall bitTimeC"          "\n\t"

  845.         "out   %[port], %[hi]"    "\n\t"

  846.         "rcall bitTimeC"          "\n\t"

  847.         "out   %[port], %[hi]"    "\n\t"

  848.         "rcall bitTimeC"          "\n\t"

  849.         "out   %[port], %[hi]"    "\n\t"

  850.         "rcall bitTimeC"          "\n\t"

  851.         "out   %[port], %[hi]"    "\n\t"

  852.         "rcall bitTimeC"          "\n\t"

  853.         "out   %[port], %[hi]"    "\n\t"

  854.         "rcall bitTimeC"          "\n\t"

  855.         "out   %[port], %[hi]"    "\n\t"

  856.         "rcall bitTimeC"          "\n\t"

  857.         "out  %[port] , %[hi]"    "\n\t"

  858.         "rjmp .+0"                "\n\t"

  859.         "ld   %[byte] , %a[ptr]+" "\n\t"

  860.         "out  %[port] , %[next]"  "\n\t"

  861.         "mov  %[next] , %[lo]"    "\n\t"

  862.         "sbrc %[byte] , 7"        "\n\t"

  863.          "mov %[next] , %[hi]"    "\n\t"

  864.         "nop"                     "\n\t"

  865.         "out  %[port] , %[lo]"    "\n\t"

  866.         "sbiw %[count], 1"        "\n\t"

  867.         "brne headF"              "\n\t"

  868.          "rjmp doneC"             "\n\t"

  869.         "bitTimeC:"               "\n\t"

  870.          "out  %[port], %[next]"  "\n\t"

  871.          "mov  %[next], %[lo]"    "\n\t"

  872.          "rol  %[byte]"           "\n\t"

  873.          "sbrc %[byte], 7"        "\n\t"

  874.           "mov %[next], %[hi]"    "\n\t"

  875.          "nop"                    "\n\t"

  876.          "out  %[port], %[lo]"    "\n\t"

  877.          "ret"                    "\n\t"

  878.          "doneC:"                 "\n"

  879.         : [byte] "+r" (b), [next] "+r" (next), [count] "+w" (i)

  880.         : [port] "I" (_SFR_IO_ADDR(PORTF)), [ptr] "e" (ptr), [hi] "r" (hi),

  881.           [lo] "r" (lo));

  882. 

  883.  #if defined(PORTD) || defined(PORTB) || defined(PORTC)

  884.     }

  885.  #endif // defined(PORTD/B/C)

  886. #endif // defined(PORTF)

  887. 

  888. #ifdef NEO_KHZ400

  889.   } else { // 400 KHz

  890. 

  891.     // 30 instruction clocks per bit: HHHHHHxxxxxxxxxLLLLLLLLLLLLLLL

  892.     // ST instructions:               ^     ^        ^    (T=0,6,15)

  893. 

  894.     volatile uint8_t next, bit;

  895. 

  896.     hi   = *port |  pinMask;

  897.     lo   = *port & ~pinMask;

  898.     next = lo;

  899.     bit  = 8;

  900. 

  901.     asm volatile(

  902.      "head30:"                  "\n\t" // Clk  Pseudocode    (T =  0)

  903.       "st   %a[port], %[hi]"    "\n\t" // 2    PORT = hi     (T =  2)

  904.       "sbrc %[byte] , 7"        "\n\t" // 1-2  if(b & 128)

  905.        "mov  %[next], %[hi]"    "\n\t" // 0-1   next = hi    (T =  4)

  906.       "rjmp .+0"                "\n\t" // 2    nop nop       (T =  6)

  907.       "st   %a[port], %[next]"  "\n\t" // 2    PORT = next   (T =  8)

  908.       "rjmp .+0"                "\n\t" // 2    nop nop       (T = 10)

  909.       "rjmp .+0"                "\n\t" // 2    nop nop       (T = 12)

  910.       "rjmp .+0"                "\n\t" // 2    nop nop       (T = 14)

  911.       "nop"                     "\n\t" // 1    nop           (T = 15)

  912.       "st   %a[port], %[lo]"    "\n\t" // 2    PORT = lo     (T = 17)

  913.       "rjmp .+0"                "\n\t" // 2    nop nop       (T = 19)

  914.       "dec  %[bit]"             "\n\t" // 1    bit--         (T = 20)

  915.       "breq nextbyte30"         "\n\t" // 1-2  if(bit == 0)

  916.       "rol  %[byte]"            "\n\t" // 1    b <<= 1       (T = 22)

  917.       "rjmp .+0"                "\n\t" // 2    nop nop       (T = 24)

  918.       "rjmp .+0"                "\n\t" // 2    nop nop       (T = 26)

  919.       "rjmp .+0"                "\n\t" // 2    nop nop       (T = 28)

  920.       "rjmp head30"             "\n\t" // 2    -> head30 (next bit out)

  921.      "nextbyte30:"              "\n\t" //                    (T = 22)

  922.       "nop"                     "\n\t" // 1    nop           (T = 23)

  923.       "ldi  %[bit]  , 8"        "\n\t" // 1    bit = 8       (T = 24)

  924.       "ld   %[byte] , %a[ptr]+" "\n\t" // 2    b = *ptr++    (T = 26)

  925.       "sbiw %[count], 1"        "\n\t" // 2    i--           (T = 28)

  926.       "brne head30"             "\n"   // 1-2  if(i != 0) -> (next byte)

  927.       : [port]  "+e" (port),

  928.         [byte]  "+r" (b),

  929.         [bit]   "+r" (bit),

  930.         [next]  "+r" (next),

  931.         [count] "+w" (i)

  932.       : [hi]     "r" (hi),

  933.         [lo]     "r" (lo),

  934.         [ptr]    "e" (ptr));

  935.   }

  936. #endif // NEO_KHZ400

  937. 

  938. // 16 MHz(ish) AVR --------------------------------------------------------

  939. #elif (F_CPU >= 15400000UL) && (F_CPU <= 19000000L)

  940. 

  941. #ifdef NEO_KHZ400 // 800 KHz check needed only if 400 KHz support enabled

  942.   if(is800KHz) {

  943. #endif

  944. 

  945.     // WS2811 and WS2812 have different hi/lo duty cycles; this is

  946.     // similar but NOT an exact copy of the prior 400-on-8 code.

  947. 

  948.     // 20 inst. clocks per bit: HHHHHxxxxxxxxLLLLLLL

  949.     // ST instructions:         ^   ^        ^       (T=0,5,13)

  950. 

  951.     volatile uint8_t next, bit;

  952. 

  953.     hi   = *port |  pinMask;

  954.     lo   = *port & ~pinMask;

  955.     next = lo;

  956.     bit  = 8;

  957. 

  958.     asm volatile(

  959.      "head20:"                   "\n\t" // Clk  Pseudocode    (T =  0)

  960.       "st   %a[port],  %[hi]"    "\n\t" // 2    PORT = hi     (T =  2)

  961.       "sbrc %[byte],  7"         "\n\t" // 1-2  if(b & 128)

  962.        "mov  %[next], %[hi]"     "\n\t" // 0-1   next = hi    (T =  4)

  963.       "dec  %[bit]"              "\n\t" // 1    bit--         (T =  5)

  964.       "st   %a[port],  %[next]"  "\n\t" // 2    PORT = next   (T =  7)

  965.       "mov  %[next] ,  %[lo]"    "\n\t" // 1    next = lo     (T =  8)

  966.       "breq nextbyte20"          "\n\t" // 1-2  if(bit == 0) (from dec above)

  967.       "rol  %[byte]"             "\n\t" // 1    b <<= 1       (T = 10)

  968.       "rjmp .+0"                 "\n\t" // 2    nop nop       (T = 12)

  969.       "nop"                      "\n\t" // 1    nop           (T = 13)

  970.       "st   %a[port],  %[lo]"    "\n\t" // 2    PORT = lo     (T = 15)

  971.       "nop"                      "\n\t" // 1    nop           (T = 16)

  972.       "rjmp .+0"                 "\n\t" // 2    nop nop       (T = 18)

  973.       "rjmp head20"              "\n\t" // 2    -> head20 (next bit out)

  974.      "nextbyte20:"               "\n\t" //                    (T = 10)

  975.       "ldi  %[bit]  ,  8"        "\n\t" // 1    bit = 8       (T = 11)

  976.       "ld   %[byte] ,  %a[ptr]+" "\n\t" // 2    b = *ptr++    (T = 13)

  977.       "st   %a[port], %[lo]"     "\n\t" // 2    PORT = lo     (T = 15)

  978.       "nop"                      "\n\t" // 1    nop           (T = 16)

  979.       "sbiw %[count], 1"         "\n\t" // 2    i--           (T = 18)

  980.        "brne head20"             "\n"   // 2    if(i != 0) -> (next byte)

  981.       : [port]  "+e" (port),

  982.         [byte]  "+r" (b),

  983.         [bit]   "+r" (bit),

  984.         [next]  "+r" (next),

  985.         [count] "+w" (i)

  986.       : [ptr]    "e" (ptr),

  987.         [hi]     "r" (hi),

  988.         [lo]     "r" (lo));

  989. 

  990. #ifdef NEO_KHZ400

  991.   } else { // 400 KHz

  992. 

  993.     // The 400 KHz clock on 16 MHz MCU is the most 'relaxed' version.

  994. 

  995.     // 40 inst. clocks per bit: HHHHHHHHxxxxxxxxxxxxLLLLLLLLLLLLLLLLLLLL

  996.     // ST instructions:         ^       ^           ^         (T=0,8,20)

  997. 

  998.     volatile uint8_t next, bit;

  999. 

  1000.     hi   = *port |  pinMask;

  1001.     lo   = *port & ~pinMask;

  1002.     next = lo;

  1003.     bit  = 8;

  1004. 

  1005.     asm volatile(

  1006.      "head40:"                  "\n\t" // Clk  Pseudocode    (T =  0)

  1007.       "st   %a[port], %[hi]"    "\n\t" // 2    PORT = hi     (T =  2)

  1008.       "sbrc %[byte] , 7"        "\n\t" // 1-2  if(b & 128)

  1009.        "mov  %[next] , %[hi]"   "\n\t" // 0-1   next = hi    (T =  4)

  1010.       "rjmp .+0"                "\n\t" // 2    nop nop       (T =  6)

  1011.       "rjmp .+0"                "\n\t" // 2    nop nop       (T =  8)

  1012.       "st   %a[port], %[next]"  "\n\t" // 2    PORT = next   (T = 10)

  1013.       "rjmp .+0"                "\n\t" // 2    nop nop       (T = 12)

  1014.       "rjmp .+0"                "\n\t" // 2    nop nop       (T = 14)

  1015.       "rjmp .+0"                "\n\t" // 2    nop nop       (T = 16)

  1016.       "rjmp .+0"                "\n\t" // 2    nop nop       (T = 18)

  1017.       "rjmp .+0"                "\n\t" // 2    nop nop       (T = 20)

  1018.       "st   %a[port], %[lo]"    "\n\t" // 2    PORT = lo     (T = 22)

  1019.       "nop"                     "\n\t" // 1    nop           (T = 23)

  1020.       "mov  %[next] , %[lo]"    "\n\t" // 1    next = lo     (T = 24)

  1021.       "dec  %[bit]"             "\n\t" // 1    bit--         (T = 25)

  1022.       "breq nextbyte40"         "\n\t" // 1-2  if(bit == 0)

  1023.       "rol  %[byte]"            "\n\t" // 1    b <<= 1       (T = 27)

  1024.       "nop"                     "\n\t" // 1    nop           (T = 28)

  1025.       "rjmp .+0"                "\n\t" // 2    nop nop       (T = 30)

  1026.       "rjmp .+0"                "\n\t" // 2    nop nop       (T = 32)

  1027.       "rjmp .+0"                "\n\t" // 2    nop nop       (T = 34)

  1028.       "rjmp .+0"                "\n\t" // 2    nop nop       (T = 36)

  1029.       "rjmp .+0"                "\n\t" // 2    nop nop       (T = 38)

  1030.       "rjmp head40"             "\n\t" // 2    -> head40 (next bit out)

  1031.      "nextbyte40:"              "\n\t" //                    (T = 27)

  1032.       "ldi  %[bit]  , 8"        "\n\t" // 1    bit = 8       (T = 28)

  1033.       "ld   %[byte] , %a[ptr]+" "\n\t" // 2    b = *ptr++    (T = 30)

  1034.       "rjmp .+0"                "\n\t" // 2    nop nop       (T = 32)

  1035.       "st   %a[port], %[lo]"    "\n\t" // 2    PORT = lo     (T = 34)

  1036.       "rjmp .+0"                "\n\t" // 2    nop nop       (T = 36)

  1037.       "sbiw %[count], 1"        "\n\t" // 2    i--           (T = 38)

  1038.       "brne head40"             "\n"   // 1-2  if(i != 0) -> (next byte)

  1039.       : [port]  "+e" (port),

  1040.         [byte]  "+r" (b),

  1041.         [bit]   "+r" (bit),

  1042.         [next]  "+r" (next),

  1043.         [count] "+w" (i)

  1044.       : [ptr]    "e" (ptr),

  1045.         [hi]     "r" (hi),

  1046.         [lo]     "r" (lo));

  1047.   }

  1048. #endif // NEO_KHZ400

  1049. 

  1050. #else

  1051.  #error "CPU SPEED NOT SUPPORTED"

  1052. #endif // end F_CPU ifdefs on __AVR__

  1053. 

  1054. // END AVR ----------------------------------------------------------------

  1055. 

  1056. 

  1057. #elif defined(__arm__)

  1058. 

  1059. // ARM MCUs -- Teensy 3.0, 3.1, LC, Arduino Due ---------------------------

  1060. 

  1061. #if defined(TEENSYDUINO) && defined(KINETISK) // Teensy 3.0, 3.1, 3.2, 3.5, 3.6

  1062. #define CYCLES_800_T0H  (F_CPU / 4000000)

  1063. #define CYCLES_800_T1H  (F_CPU / 1250000)

  1064. #define CYCLES_800      (F_CPU /  800000)

  1065. #define CYCLES_400_T0H  (F_CPU / 2000000)

  1066. #define CYCLES_400_T1H  (F_CPU /  833333)

  1067. #define CYCLES_400      (F_CPU /  400000)

  1068. 

  1069.   uint8_t          *p   = pixels,

  1070.                    *end = p + numBytes, pix, mask;

  1071.   volatile uint8_t *set = portSetRegister(pin),

  1072.                    *clr = portClearRegister(pin);

  1073.   uint32_t          cyc;

  1074. 

  1075.   ARM_DEMCR    |= ARM_DEMCR_TRCENA;

  1076.   ARM_DWT_CTRL |= ARM_DWT_CTRL_CYCCNTENA;

  1077. 

  1078. #ifdef NEO_KHZ400 // 800 KHz check needed only if 400 KHz support enabled

  1079.   if(is800KHz) {

  1080. #endif

  1081.     cyc = ARM_DWT_CYCCNT + CYCLES_800;

  1082.     while(p < end) {

  1083.       pix = *p++;

  1084.       for(mask = 0x80; mask; mask >>= 1) {

  1085.         while(ARM_DWT_CYCCNT - cyc < CYCLES_800);

  1086.         cyc  = ARM_DWT_CYCCNT;

  1087.         *set = 1;

  1088.         if(pix & mask) {

  1089.           while(ARM_DWT_CYCCNT - cyc < CYCLES_800_T1H);

  1090.         } else {

  1091.           while(ARM_DWT_CYCCNT - cyc < CYCLES_800_T0H);

  1092.         }

  1093.         *clr = 1;

  1094.       }

  1095.     }

  1096.     while(ARM_DWT_CYCCNT - cyc < CYCLES_800);

  1097. #ifdef NEO_KHZ400

  1098.   } else { // 400 kHz bitstream

  1099.     cyc = ARM_DWT_CYCCNT + CYCLES_400;

  1100.     while(p < end) {

  1101.       pix = *p++;

  1102.       for(mask = 0x80; mask; mask >>= 1) {

  1103.         while(ARM_DWT_CYCCNT - cyc < CYCLES_400);

  1104.         cyc  = ARM_DWT_CYCCNT;

  1105.         *set = 1;

  1106.         if(pix & mask) {

  1107.           while(ARM_DWT_CYCCNT - cyc < CYCLES_400_T1H);

  1108.         } else {

  1109.           while(ARM_DWT_CYCCNT - cyc < CYCLES_400_T0H);

  1110.         }

  1111.         *clr = 1;

  1112.       }

  1113.     }

  1114.     while(ARM_DWT_CYCCNT - cyc < CYCLES_400);

  1115.   }

  1116. #endif // NEO_KHZ400

  1117. 

  1118. #elif defined(TEENSYDUINO) && (defined(__IMXRT1052__) || defined(__IMXRT1062__))

  1119. #define CYCLES_800_T0H  (F_CPU_ACTUAL / 4000000)

  1120. #define CYCLES_800_T1H  (F_CPU_ACTUAL / 1250000)

  1121. #define CYCLES_800      (F_CPU_ACTUAL /  800000)

  1122. #define CYCLES_400_T0H  (F_CPU_ACTUAL / 2000000)

  1123. #define CYCLES_400_T1H  (F_CPU_ACTUAL /  833333)

  1124. #define CYCLES_400      (F_CPU_ACTUAL /  400000)

  1125. 

  1126.   uint8_t           *p   = pixels,

  1127.                     *end = p + numBytes, pix, mask;

  1128.   volatile uint32_t *set = portSetRegister(pin),

  1129.                     *clr = portClearRegister(pin);

  1130.   uint32_t          cyc,

  1131.                     msk = digitalPinToBitMask(pin);

  1132. 

  1133.   ARM_DEMCR    |= ARM_DEMCR_TRCENA;

  1134.   ARM_DWT_CTRL |= ARM_DWT_CTRL_CYCCNTENA;

  1135. 

  1136. #ifdef NEO_KHZ400 // 800 KHz check needed only if 400 KHz support enabled

  1137.   if(is800KHz) {

  1138. #endif

  1139.     cyc = ARM_DWT_CYCCNT + CYCLES_800;

  1140.     while(p < end) {

  1141.       pix = *p++;

  1142.       for(mask = 0x80; mask; mask >>= 1) {

  1143.         while(ARM_DWT_CYCCNT - cyc < CYCLES_800);

  1144.         cyc  = ARM_DWT_CYCCNT;

  1145.         *set = msk;

  1146.         if(pix & mask) {

  1147.           while(ARM_DWT_CYCCNT - cyc < CYCLES_800_T1H);

  1148.         } else {

  1149.           while(ARM_DWT_CYCCNT - cyc < CYCLES_800_T0H);

  1150.         }

  1151.         *clr = msk;

  1152.       }

  1153.     }

  1154.     while(ARM_DWT_CYCCNT - cyc < CYCLES_800);

  1155. #ifdef NEO_KHZ400

  1156.   } else { // 400 kHz bitstream

  1157.     cyc = ARM_DWT_CYCCNT + CYCLES_400;

  1158.     while(p < end) {

  1159.       pix = *p++;

  1160.       for(mask = 0x80; mask; mask >>= 1) {

  1161.         while(ARM_DWT_CYCCNT - cyc < CYCLES_400);

  1162.         cyc  = ARM_DWT_CYCCNT;

  1163.         *set = msk;

  1164.         if(pix & mask) {

  1165.           while(ARM_DWT_CYCCNT - cyc < CYCLES_400_T1H);

  1166.         } else {

  1167.           while(ARM_DWT_CYCCNT - cyc < CYCLES_400_T0H);

  1168.         }

  1169.         *clr = msk;

  1170.       }

  1171.     }

  1172.     while(ARM_DWT_CYCCNT - cyc < CYCLES_400);

  1173.   }

  1174. #endif // NEO_KHZ400

  1175. 

  1176. #elif defined(TEENSYDUINO) && defined(__MKL26Z64__) // Teensy-LC

  1177. 

  1178. #if F_CPU == 48000000

  1179.   uint8_t          *p   = pixels,

  1180. 		   pix, count, dly,

  1181.                    bitmask = digitalPinToBitMask(pin);

  1182.   volatile uint8_t *reg = portSetRegister(pin);

  1183.   uint32_t         num = numBytes;

  1184.   asm volatile(

  1185. 	"L%=_begin:"				"\n\t"

  1186. 	"ldrb	%[pix], [%[p], #0]"		"\n\t"

  1187. 	"lsl	%[pix], #24"			"\n\t"

  1188. 	"movs	%[count], #7"			"\n\t"

  1189. 	"L%=_loop:"				"\n\t"

  1190. 	"lsl	%[pix], #1"			"\n\t"

  1191. 	"bcs	L%=_loop_one"			"\n\t"

  1192. 	"L%=_loop_zero:"

  1193. 	"strb	%[bitmask], [%[reg], #0]"	"\n\t"

  1194. 	"movs	%[dly], #4"			"\n\t"

  1195. 	"L%=_loop_delay_T0H:"			"\n\t"

  1196. 	"sub	%[dly], #1"			"\n\t"

  1197. 	"bne	L%=_loop_delay_T0H"		"\n\t"

  1198. 	"strb	%[bitmask], [%[reg], #4]"	"\n\t"

  1199. 	"movs	%[dly], #13"			"\n\t"

  1200. 	"L%=_loop_delay_T0L:"			"\n\t"

  1201. 	"sub	%[dly], #1"			"\n\t"

  1202. 	"bne	L%=_loop_delay_T0L"		"\n\t"

  1203. 	"b	L%=_next"			"\n\t"

  1204. 	"L%=_loop_one:"

  1205. 	"strb	%[bitmask], [%[reg], #0]"	"\n\t"

  1206. 	"movs	%[dly], #13"			"\n\t"

  1207. 	"L%=_loop_delay_T1H:"			"\n\t"

  1208. 	"sub	%[dly], #1"			"\n\t"

  1209. 	"bne	L%=_loop_delay_T1H"		"\n\t"

  1210. 	"strb	%[bitmask], [%[reg], #4]"	"\n\t"

  1211. 	"movs	%[dly], #4"			"\n\t"

  1212. 	"L%=_loop_delay_T1L:"			"\n\t"

  1213. 	"sub	%[dly], #1"			"\n\t"

  1214. 	"bne	L%=_loop_delay_T1L"		"\n\t"

  1215. 	"nop"					"\n\t"

  1216. 	"L%=_next:"				"\n\t"

  1217. 	"sub	%[count], #1"			"\n\t"

  1218. 	"bne	L%=_loop"			"\n\t"

  1219. 	"lsl	%[pix], #1"			"\n\t"

  1220. 	"bcs	L%=_last_one"			"\n\t"

  1221. 	"L%=_last_zero:"

  1222. 	"strb	%[bitmask], [%[reg], #0]"	"\n\t"

  1223. 	"movs	%[dly], #4"			"\n\t"

  1224. 	"L%=_last_delay_T0H:"			"\n\t"

  1225. 	"sub	%[dly], #1"			"\n\t"

  1226. 	"bne	L%=_last_delay_T0H"		"\n\t"

  1227. 	"strb	%[bitmask], [%[reg], #4]"	"\n\t"

  1228. 	"movs	%[dly], #10"			"\n\t"

  1229. 	"L%=_last_delay_T0L:"			"\n\t"

  1230. 	"sub	%[dly], #1"			"\n\t"

  1231. 	"bne	L%=_last_delay_T0L"		"\n\t"

  1232. 	"b	L%=_repeat"			"\n\t"

  1233. 	"L%=_last_one:"

  1234. 	"strb	%[bitmask], [%[reg], #0]"	"\n\t"

  1235. 	"movs	%[dly], #13"			"\n\t"

  1236. 	"L%=_last_delay_T1H:"			"\n\t"

  1237. 	"sub	%[dly], #1"			"\n\t"

  1238. 	"bne	L%=_last_delay_T1H"		"\n\t"

  1239. 	"strb	%[bitmask], [%[reg], #4]"	"\n\t"

  1240. 	"movs	%[dly], #1"			"\n\t"

  1241. 	"L%=_last_delay_T1L:"			"\n\t"

  1242. 	"sub	%[dly], #1"			"\n\t"

  1243. 	"bne	L%=_last_delay_T1L"		"\n\t"

  1244. 	"nop"					"\n\t"

  1245. 	"L%=_repeat:"				"\n\t"

  1246. 	"add	%[p], #1"			"\n\t"

  1247. 	"sub	%[num], #1"			"\n\t"

  1248. 	"bne	L%=_begin"			"\n\t"

  1249. 	"L%=_done:"				"\n\t"

  1250. 	: [p] "+r" (p),

  1251. 	  [pix] "=&r" (pix),

  1252. 	  [count] "=&r" (count),

  1253. 	  [dly] "=&r" (dly),

  1254. 	  [num] "+r" (num)

  1255. 	: [bitmask] "r" (bitmask),

  1256. 	  [reg] "r" (reg)

  1257.   );

  1258. #else

  1259. #error "Sorry, only 48 MHz is supported, please set Tools > CPU Speed to 48 MHz"

  1260. #endif // F_CPU == 48000000

  1261. 

  1262. // Begin of support for nRF52 based boards  -------------------------

  1263. 

  1264. #elif defined(NRF52) || defined(NRF52_SERIES)

  1265. // [[[Begin of the Neopixel NRF52 EasyDMA implementation

  1266. //                                    by the Hackerspace San Salvador]]]

  1267. // This technique uses the PWM peripheral on the NRF52. The PWM uses the

  1268. // EasyDMA feature included on the chip. This technique loads the duty

  1269. // cycle configuration for each cycle when the PWM is enabled. For this

  1270. // to work we need to store a 16 bit configuration for each bit of the

  1271. // RGB(W) values in the pixel buffer.

  1272. // Comparator values for the PWM were hand picked and are guaranteed to

  1273. // be 100% organic to preserve freshness and high accuracy. Current

  1274. // parameters are:

  1275. //   * PWM Clock: 16Mhz

  1276. //   * Minimum step time: 62.5ns

  1277. //   * Time for zero in high (T0H): 0.31ms

  1278. //   * Time for one in high (T1H): 0.75ms

  1279. //   * Cycle time:  1.25us

  1280. //   * Frequency: 800Khz

  1281. // For 400Khz we just double the calculated times.

  1282. // ---------- BEGIN Constants for the EasyDMA implementation -----------

  1283. // The PWM starts the duty cycle in LOW. To start with HIGH we

  1284. // need to set the 15th bit on each register.

  1285. 

  1286. // WS2812 (rev A) timing is 0.35 and 0.7us

  1287. //#define MAGIC_T0H               5UL | (0x8000) // 0.3125us

  1288. //#define MAGIC_T1H              12UL | (0x8000) // 0.75us

  1289. 

  1290. // WS2812B (rev B) timing is 0.4 and 0.8 us

  1291. #define MAGIC_T0H               6UL | (0x8000) // 0.375us

  1292. #define MAGIC_T1H              13UL | (0x8000) // 0.8125us

  1293. 

  1294. // WS2811 (400 khz) timing is 0.5 and 1.2

  1295. #define MAGIC_T0H_400KHz        8UL  | (0x8000) // 0.5us

  1296. #define MAGIC_T1H_400KHz        19UL | (0x8000) // 1.1875us

  1297. 

  1298. // For 400Khz, we double value of CTOPVAL

  1299. #define CTOPVAL                20UL            // 1.25us

  1300. #define CTOPVAL_400KHz         40UL            // 2.5us

  1301. 

  1302. // ---------- END Constants for the EasyDMA implementation -------------

  1303. //

  1304. // If there is no device available an alternative cycle-counter

  1305. // implementation is tried.

  1306. // The nRF52 runs with a fixed clock of 64Mhz. The alternative

  1307. // implementation is the same as the one used for the Teensy 3.0/1/2 but

  1308. // with the Nordic SDK HAL & registers syntax.

  1309. // The number of cycles was hand picked and is guaranteed to be 100%

  1310. // organic to preserve freshness and high accuracy.

  1311. // ---------- BEGIN Constants for cycle counter implementation ---------

  1312. #define CYCLES_800_T0H  18  // ~0.36 uS

  1313. #define CYCLES_800_T1H  41  // ~0.76 uS

  1314. #define CYCLES_800      71  // ~1.25 uS

  1315. 

  1316. #define CYCLES_400_T0H  26  // ~0.50 uS

  1317. #define CYCLES_400_T1H  70  // ~1.26 uS

  1318. #define CYCLES_400      156 // ~2.50 uS

  1319. // ---------- END of Constants for cycle counter implementation --------

  1320. 

  1321.   // To support both the SoftDevice + Neopixels we use the EasyDMA

  1322.   // feature from the NRF25. However this technique implies to

  1323.   // generate a pattern and store it on the memory. The actual

  1324.   // memory used in bytes corresponds to the following formula:

  1325.   //              totalMem = numBytes*8*2+(2*2)

  1326.   // The two additional bytes at the end are needed to reset the

  1327.   // sequence.

  1328.   //

  1329.   // If there is not enough memory, we will fall back to cycle counter

  1330.   // using DWT

  1331.   uint32_t  pattern_size   = numBytes*8*sizeof(uint16_t)+2*sizeof(uint16_t);

  1332.   uint16_t* pixels_pattern = NULL;

  1333. 

  1334.   NRF_PWM_Type* pwm = NULL;

  1335. 

  1336.   // Try to find a free PWM device, which is not enabled

  1337.   // and has no connected pins

  1338.   NRF_PWM_Type* PWM[] = {

  1339.     NRF_PWM0, NRF_PWM1, NRF_PWM2

  1340. #ifdef NRF_PWM3

  1341.     ,NRF_PWM3

  1342. #endif

  1343.   };

  1344. 

  1345.   for(int device = 0; device < (sizeof(PWM)/sizeof(PWM[0])); device++) {

  1346.     if( (PWM[device]->ENABLE == 0)                            &&

  1347.         (PWM[device]->PSEL.OUT[0] & PWM_PSEL_OUT_CONNECT_Msk) &&

  1348.         (PWM[device]->PSEL.OUT[1] & PWM_PSEL_OUT_CONNECT_Msk) &&

  1349.         (PWM[device]->PSEL.OUT[2] & PWM_PSEL_OUT_CONNECT_Msk) &&

  1350.         (PWM[device]->PSEL.OUT[3] & PWM_PSEL_OUT_CONNECT_Msk)

  1351.     ) {

  1352.       pwm = PWM[device];

  1353.       break;

  1354.     }

  1355.   }

  1356. 

  1357.   // only malloc if there is PWM device available

  1358.   if ( pwm != NULL ) {

  1359.     #ifdef ARDUINO_NRF52_ADAFRUIT // use thread-safe malloc

  1360.       pixels_pattern = (uint16_t *) rtos_malloc(pattern_size);

  1361.     #else

  1362.       pixels_pattern = (uint16_t *) malloc(pattern_size);

  1363.     #endif

  1364.   }

  1365. 

  1366.   // Use the identified device to choose the implementation

  1367.   // If a PWM device is available use DMA

  1368.   if( (pixels_pattern != NULL) && (pwm != NULL) ) {

  1369.     uint16_t pos = 0; // bit position

  1370. 

  1371.     for(uint16_t n=0; n<numBytes; n++) {

  1372.       uint8_t pix = pixels[n];

  1373. 

  1374.       for(uint8_t mask=0x80, i=0; mask>0; mask >>= 1, i++) {

  1375.         #ifdef NEO_KHZ400

  1376.         if( !is800KHz ) {

  1377.           pixels_pattern[pos] = (pix & mask) ? MAGIC_T1H_400KHz : MAGIC_T0H_400KHz;

  1378.         }else

  1379.         #endif

  1380.         {

  1381.           pixels_pattern[pos] = (pix & mask) ? MAGIC_T1H : MAGIC_T0H;

  1382.         }

  1383. 

  1384.         pos++;

  1385.       }

  1386.     }

  1387. 

  1388.     // Zero padding to indicate the end of que sequence

  1389.     pixels_pattern[++pos] = 0 | (0x8000); // Seq end

  1390.     pixels_pattern[++pos] = 0 | (0x8000); // Seq end

  1391. 

  1392.     // Set the wave mode to count UP

  1393.     pwm->MODE = (PWM_MODE_UPDOWN_Up << PWM_MODE_UPDOWN_Pos);

  1394. 

  1395.     // Set the PWM to use the 16MHz clock

  1396.     pwm->PRESCALER = (PWM_PRESCALER_PRESCALER_DIV_1 << PWM_PRESCALER_PRESCALER_Pos);

  1397. 

  1398.     // Setting of the maximum count

  1399.     // but keeping it on 16Mhz allows for more granularity just

  1400.     // in case someone wants to do more fine-tuning of the timing.

  1401. #ifdef NEO_KHZ400

  1402.     if( !is800KHz ) {

  1403.       pwm->COUNTERTOP = (CTOPVAL_400KHz << PWM_COUNTERTOP_COUNTERTOP_Pos);

  1404.     }else

  1405. #endif

  1406.     {

  1407.       pwm->COUNTERTOP = (CTOPVAL << PWM_COUNTERTOP_COUNTERTOP_Pos);

  1408.     }

  1409. 

  1410.     // Disable loops, we want the sequence to repeat only once

  1411.     pwm->LOOP = (PWM_LOOP_CNT_Disabled << PWM_LOOP_CNT_Pos);

  1412. 

  1413.     // On the "Common" setting the PWM uses the same pattern for the

  1414.     // for supported sequences. The pattern is stored on half-word

  1415.     // of 16bits

  1416.     pwm->DECODER = (PWM_DECODER_LOAD_Common << PWM_DECODER_LOAD_Pos) |

  1417.                    (PWM_DECODER_MODE_RefreshCount << PWM_DECODER_MODE_Pos);

  1418. 

  1419.     // Pointer to the memory storing the patter

  1420.     pwm->SEQ[0].PTR = (uint32_t)(pixels_pattern) << PWM_SEQ_PTR_PTR_Pos;

  1421. 

  1422.     // Calculation of the number of steps loaded from memory.

  1423.     pwm->SEQ[0].CNT = (pattern_size/sizeof(uint16_t)) << PWM_SEQ_CNT_CNT_Pos;

  1424. 

  1425.     // The following settings are ignored with the current config.

  1426.     pwm->SEQ[0].REFRESH  = 0;

  1427.     pwm->SEQ[0].ENDDELAY = 0;

  1428. 

  1429.     // The Neopixel implementation is a blocking algorithm. DMA

  1430.     // allows for non-blocking operation. To "simulate" a blocking

  1431.     // operation we enable the interruption for the end of sequence

  1432.     // and block the execution thread until the event flag is set by

  1433.     // the peripheral.

  1434. //    pwm->INTEN |= (PWM_INTEN_SEQEND0_Enabled<<PWM_INTEN_SEQEND0_Pos);

  1435. 

  1436.     // PSEL must be configured before enabling PWM

  1437.     pwm->PSEL.OUT[0] = g_ADigitalPinMap[pin];

  1438. 

  1439.     // Enable the PWM

  1440.     pwm->ENABLE = 1;

  1441. 

  1442.     // After all of this and many hours of reading the documentation

  1443.     // we are ready to start the sequence...

  1444.     pwm->EVENTS_SEQEND[0]  = 0;

  1445.     pwm->TASKS_SEQSTART[0] = 1;

  1446. 

  1447.     // But we have to wait for the flag to be set.

  1448.     while(!pwm->EVENTS_SEQEND[0])

  1449.     {

  1450.       #ifdef ARDUINO_NRF52_ADAFRUIT

  1451.       yield();

  1452.       #endif

  1453.     }

  1454. 

  1455.     // Before leave we clear the flag for the event.

  1456.     pwm->EVENTS_SEQEND[0] = 0;

  1457. 

  1458.     // We need to disable the device and disconnect

  1459.     // all the outputs before leave or the device will not

  1460.     // be selected on the next call.

  1461.     // TODO: Check if disabling the device causes performance issues.

  1462.     pwm->ENABLE = 0;

  1463. 

  1464.     pwm->PSEL.OUT[0] = 0xFFFFFFFFUL;

  1465. 

  1466.     #ifdef ARDUINO_NRF52_ADAFRUIT  // use thread-safe free

  1467.       rtos_free(pixels_pattern);

  1468.     #else

  1469.       free(pixels_pattern);

  1470.     #endif

  1471.   }// End of DMA implementation

  1472.   // ---------------------------------------------------------------------

  1473.   else{

  1474.     // Fall back to DWT

  1475.     #ifdef ARDUINO_NRF52_ADAFRUIT

  1476.       // Bluefruit Feather 52 uses freeRTOS

  1477.       // Critical Section is used since it does not block SoftDevice execution

  1478.       taskENTER_CRITICAL();

  1479.     #elif defined(NRF52_DISABLE_INT)

  1480.       // If you are using the Bluetooth SoftDevice we advise you to not disable

  1481.       // the interrupts. Disabling the interrupts even for short periods of time

  1482.       // causes the SoftDevice to stop working.

  1483.       // Disable the interrupts only in cases where you need high performance for

  1484.       // the LEDs and if you are not using the EasyDMA feature.

  1485.       __disable_irq();

  1486.     #endif

  1487. 

  1488.     NRF_GPIO_Type* nrf_port = (NRF_GPIO_Type*) digitalPinToPort(pin);

  1489.     uint32_t pinMask = digitalPinToBitMask(pin);

  1490. 

  1491.     uint32_t CYCLES_X00     = CYCLES_800;

  1492.     uint32_t CYCLES_X00_T1H = CYCLES_800_T1H;

  1493.     uint32_t CYCLES_X00_T0H = CYCLES_800_T0H;

  1494. 

  1495. #ifdef NEO_KHZ400

  1496.     if( !is800KHz )

  1497.     {

  1498.       CYCLES_X00     = CYCLES_400;

  1499.       CYCLES_X00_T1H = CYCLES_400_T1H;

  1500.       CYCLES_X00_T0H = CYCLES_400_T0H;

  1501.     }

  1502. #endif

  1503. 

  1504.     // Enable DWT in debug core

  1505.     CoreDebug->DEMCR |= CoreDebug_DEMCR_TRCENA_Msk;

  1506.     DWT->CTRL |= DWT_CTRL_CYCCNTENA_Msk;

  1507. 

  1508.     // Tries to re-send the frame if is interrupted by the SoftDevice.

  1509.     while(1) {

  1510.       uint8_t *p = pixels;

  1511. 

  1512.       uint32_t cycStart = DWT->CYCCNT;

  1513.       uint32_t cyc = 0;

  1514. 

  1515.       for(uint16_t n=0; n<numBytes; n++) {

  1516.         uint8_t pix = *p++;

  1517. 

  1518.         for(uint8_t mask = 0x80; mask; mask >>= 1) {

  1519.           while(DWT->CYCCNT - cyc < CYCLES_X00);

  1520.           cyc  = DWT->CYCCNT;

  1521. 

  1522.           nrf_port->OUTSET |= pinMask;

  1523. 

  1524.           if(pix & mask) {

  1525.             while(DWT->CYCCNT - cyc < CYCLES_X00_T1H);

  1526.           } else {

  1527.             while(DWT->CYCCNT - cyc < CYCLES_X00_T0H);

  1528.           }

  1529. 

  1530.           nrf_port->OUTCLR |= pinMask;

  1531.         }

  1532.       }

  1533.       while(DWT->CYCCNT - cyc < CYCLES_X00);

  1534. 

  1535. 

  1536.       // If total time longer than 25%, resend the whole data.

  1537.       // Since we are likely to be interrupted by SoftDevice

  1538.       if ( (DWT->CYCCNT - cycStart) < ( 8*numBytes*((CYCLES_X00*5)/4) ) ) {

  1539.         break;

  1540.       }

  1541. 

  1542.       // re-send need 300us delay

  1543.       delayMicroseconds(300);

  1544.     }

  1545. 

  1546.     // Enable interrupts again

  1547.     #ifdef ARDUINO_NRF52_ADAFRUIT

  1548.       taskEXIT_CRITICAL();

  1549.     #elif defined(NRF52_DISABLE_INT)

  1550.       __enable_irq();

  1551.     #endif

  1552.   }

  1553. // END of NRF52 implementation

  1554. 

  1555. #elif defined (__SAMD21E17A__) || defined(__SAMD21G18A__)  || defined(__SAMD21E18A__) || defined(__SAMD21J18A__) // Arduino Zero, Gemma/Trinket M0, SODAQ Autonomo and others

  1556.   // Tried this with a timer/counter, couldn't quite get adequate

  1557.   // resolution.  So yay, you get a load of goofball NOPs...

  1558. 

  1559.   uint8_t  *ptr, *end, p, bitMask, portNum;

  1560.   uint32_t  pinMask;

  1561. 

  1562.   portNum =  g_APinDescription[pin].ulPort;

  1563.   pinMask =  1ul << g_APinDescription[pin].ulPin;

  1564.   ptr     =  pixels;

  1565.   end     =  ptr + numBytes;

  1566.   p       = *ptr++;

  1567.   bitMask =  0x80;

  1568. 

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

  1570.                     *clr = &(PORT->Group[portNum].OUTCLR.reg);

  1571. 

  1572. #ifdef NEO_KHZ400 // 800 KHz check needed only if 400 KHz support enabled

  1573.   if(is800KHz) {

  1574. #endif

  1575.     for(;;) {

  1576.       *set = pinMask;

  1577.       asm("nop; nop; nop; nop; nop; nop; nop; nop;");

  1578.       if(p & bitMask) {

  1579.         asm("nop; nop; nop; nop; nop; nop; nop; nop;"

  1580.             "nop; nop; nop; nop; nop; nop; nop; nop;"

  1581.             "nop; nop; nop; nop;");

  1582.         *clr = pinMask;

  1583.       } else {

  1584.         *clr = pinMask;

  1585.         asm("nop; nop; nop; nop; nop; nop; nop; nop;"

  1586.             "nop; nop; nop; nop; nop; nop; nop; nop;"

  1587.             "nop; nop; nop; nop;");

  1588.       }

  1589.       if(bitMask >>= 1) {

  1590.         asm("nop; nop; nop; nop; nop; nop; nop; nop; nop;");

  1591.       } else {

  1592.         if(ptr >= end) break;

  1593.         p       = *ptr++;

  1594.         bitMask = 0x80;

  1595.       }

  1596.     }

  1597. #ifdef NEO_KHZ400

  1598.   } else { // 400 KHz bitstream

  1599.     for(;;) {

  1600.       *set = pinMask;

  1601.       asm("nop; nop; nop; nop; nop; nop; nop; nop; nop; nop; nop;");

  1602.       if(p & bitMask) {

  1603.         asm("nop; nop; nop; nop; nop; nop; nop; nop;"

  1604.             "nop; nop; nop; nop; nop; nop; nop; nop;"

  1605.             "nop; nop; nop; nop; nop; nop; nop; nop;"

  1606.             "nop; nop; nop;");

  1607.         *clr = pinMask;

  1608.       } else {

  1609.         *clr = pinMask;

  1610.         asm("nop; nop; nop; nop; nop; nop; nop; nop;"

  1611.             "nop; nop; nop; nop; nop; nop; nop; nop;"

  1612.             "nop; nop; nop; nop; nop; nop; nop; nop;"

  1613.             "nop; nop; nop;");

  1614.       }

  1615.       asm("nop; nop; nop; nop; nop; nop; nop; nop;"

  1616.           "nop; nop; nop; nop; nop; nop; nop; nop;"

  1617.           "nop; nop; nop; nop; nop; nop; nop; nop;"

  1618.           "nop; nop; nop; nop; nop; nop; nop; nop;");

  1619.       if(bitMask >>= 1) {

  1620.         asm("nop; nop; nop; nop; nop; nop; nop;");

  1621.       } else {

  1622.         if(ptr >= end) break;

  1623.         p       = *ptr++;

  1624.         bitMask = 0x80;

  1625.       }

  1626.     }

  1627.   }

  1628. #endif

  1629. 

  1630. #elif defined (__SAMD51__) // M4 @ 120mhz

  1631.   // Tried this with a timer/counter, couldn't quite get adequate

  1632.   // resolution.  So yay, you get a load of goofball NOPs...

  1633. 

  1634.   uint8_t  *ptr, *end, p, bitMask, portNum;

  1635.   uint32_t  pinMask;

  1636. 

  1637.   portNum =  g_APinDescription[pin].ulPort;

  1638.   pinMask =  1ul << g_APinDescription[pin].ulPin;

  1639.   ptr     =  pixels;

  1640.   end     =  ptr + numBytes;

  1641.   p       = *ptr++;

  1642.   bitMask =  0x80;

  1643. 

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

  1645.                     *clr = &(PORT->Group[portNum].OUTCLR.reg);

  1646. 

  1647. #ifdef NEO_KHZ400 // 800 KHz check needed only if 400 KHz support enabled

  1648.   if(is800KHz) {

  1649. #endif

  1650.     for(;;) {

  1651.       if(p & bitMask) { // ONE

  1652.         // High 800ns

  1653.         *set = pinMask;

  1654.         asm("nop; nop; nop; nop; nop; nop; nop; nop;"

  1655.             "nop; nop; nop; nop; nop; nop; nop; nop;"

  1656.             "nop; nop; nop; nop; nop; nop; nop; nop;"

  1657.             "nop; nop; nop; nop; nop; nop; nop; nop;"

  1658.             "nop; nop; nop; nop; nop; nop; nop; nop;"

  1659.             "nop; nop; nop; nop; nop; nop; nop; nop;"

  1660.             "nop; nop; nop; nop; nop; nop; nop; nop;"

  1661.             "nop; nop; nop; nop; nop; nop; nop; nop;"

  1662.             "nop; nop; nop; nop; nop; nop; nop; nop;"

  1663.             "nop; nop; nop; nop; nop; nop; nop; nop;");

  1664.         // Low 450ns

  1665.         *clr = pinMask;

  1666.         asm("nop; nop; nop; nop; nop; nop; nop; nop;"

  1667.             "nop; nop; nop; nop; nop; nop; nop; nop;"

  1668.             "nop; nop; nop; nop; nop; nop; nop; nop;"

  1669.             "nop; nop; nop; nop; nop; nop; nop; nop;"

  1670.             "nop;");

  1671.       } else { // ZERO

  1672.         // High 400ns

  1673.         *set = pinMask;

  1674.         asm("nop; nop; nop; nop; nop; nop; nop; nop;"

  1675.             "nop; nop; nop; nop; nop; nop; nop; nop;"

  1676.             "nop; nop; nop; nop; nop; nop; nop; nop;"

  1677.             "nop; nop; nop; nop; nop; nop; nop; nop;"

  1678.             "nop;");

  1679.         // Low 850ns

  1680.         *clr = pinMask;

  1681.         asm("nop; nop; nop; nop; nop; nop; nop; nop;"

  1682.             "nop; nop; nop; nop; nop; nop; nop; nop;"

  1683.             "nop; nop; nop; nop; nop; nop; nop; nop;"

  1684.             "nop; nop; nop; nop; nop; nop; nop; nop;"

  1685.             "nop; nop; nop; nop; nop; nop; nop; nop;"

  1686.             "nop; nop; nop; nop; nop; nop; nop; nop;"

  1687.             "nop; nop; nop; nop; nop; nop; nop; nop;"

  1688.             "nop; nop; nop; nop; nop; nop; nop; nop;"

  1689.             "nop; nop; nop; nop; nop; nop; nop; nop;"

  1690.             "nop; nop; nop; nop; nop; nop; nop; nop;");

  1691.       }

  1692.       if(bitMask >>= 1) {

  1693.         // Move on to the next pixel

  1694.         asm("nop;");

  1695.       } else {

  1696.         if(ptr >= end) break;

  1697.         p       = *ptr++;

  1698.         bitMask = 0x80;

  1699.       }

  1700.     }

  1701. #ifdef NEO_KHZ400

  1702.   } else { // 400 KHz bitstream

  1703.     // ToDo!

  1704.   }

  1705. #endif

  1706. 

  1707. #elif defined (ARDUINO_STM32_FEATHER) // FEATHER WICED (120MHz)

  1708. 

  1709.   // Tried this with a timer/counter, couldn't quite get adequate

  1710.   // resolution.  So yay, you get a load of goofball NOPs...

  1711. 

  1712.   uint8_t  *ptr, *end, p, bitMask;

  1713.   uint32_t  pinMask;

  1714. 

  1715.   pinMask =  BIT(PIN_MAP[pin].gpio_bit);

  1716.   ptr     =  pixels;

  1717.   end     =  ptr + numBytes;

  1718.   p       = *ptr++;

  1719.   bitMask =  0x80;

  1720. 

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

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

  1723. 

  1724. #ifdef NEO_KHZ400 // 800 KHz check needed only if 400 KHz support enabled

  1725.   if(is800KHz) {

  1726. #endif

  1727.     for(;;) {

  1728.       if(p & bitMask) { // ONE

  1729.         // High 800ns

  1730.         *set = pinMask;

  1731.         asm("nop; nop; nop; nop; nop; nop; nop; nop;"

  1732.             "nop; nop; nop; nop; nop; nop; nop; nop;"

  1733.             "nop; nop; nop; nop; nop; nop; nop; nop;"

  1734.             "nop; nop; nop; nop; nop; nop; nop; nop;"

  1735.             "nop; nop; nop; nop; nop; nop; nop; nop;"

  1736.             "nop; nop; nop; nop; nop; nop; nop; nop;"

  1737.             "nop; nop; nop; nop; nop; nop; nop; nop;"

  1738.             "nop; nop; nop; nop; nop; nop; nop; nop;"

  1739.             "nop; nop; nop; nop; nop; nop; nop; nop;"

  1740.             "nop; nop; nop; nop; nop; nop; nop; nop;"

  1741.             "nop; nop; nop; nop; nop; nop; nop; nop;"

  1742.             "nop; nop; nop; nop; nop; nop;");

  1743.         // Low 450ns

  1744.         *clr = pinMask;

  1745.         asm("nop; nop; nop; nop; nop; nop; nop; nop;"

  1746.             "nop; nop; nop; nop; nop; nop; nop; nop;"

  1747.             "nop; nop; nop; nop; nop; nop; nop; nop;"

  1748.             "nop; nop; nop; nop; nop; nop; nop; nop;"

  1749.             "nop; nop; nop; nop; nop; nop;");

  1750.       } else { // ZERO

  1751.         // High 400ns

  1752.         *set = pinMask;

  1753.         asm("nop; nop; nop; nop; nop; nop; nop; nop;"

  1754.             "nop; nop; nop; nop; nop; nop; nop; nop;"

  1755.             "nop; nop; nop; nop; nop; nop; nop; nop;"

  1756.             "nop; nop; nop; nop; nop; nop; nop; nop;"

  1757.             "nop; nop; nop; nop; nop; nop; nop; nop;"

  1758.             "nop;");

  1759.         // Low 850ns

  1760.         *clr = pinMask;

  1761.         asm("nop; nop; nop; nop; nop; nop; nop; nop;"

  1762.             "nop; nop; nop; nop; nop; nop; nop; nop;"

  1763.             "nop; nop; nop; nop; nop; nop; nop; nop;"

  1764.             "nop; nop; nop; nop; nop; nop; nop; nop;"

  1765.             "nop; nop; nop; nop; nop; nop; nop; nop;"

  1766.             "nop; nop; nop; nop; nop; nop; nop; nop;"

  1767.             "nop; nop; nop; nop; nop; nop; nop; nop;"

  1768.             "nop; nop; nop; nop; nop; nop; nop; nop;"

  1769.             "nop; nop; nop; nop; nop; nop; nop; nop;"

  1770.             "nop; nop; nop; nop; nop; nop; nop; nop;"

  1771.             "nop; nop; nop; nop; nop; nop; nop; nop;"

  1772.             "nop; nop; nop; nop;");

  1773.       }

  1774.       if(bitMask >>= 1) {

  1775.         // Move on to the next pixel

  1776.         asm("nop;");

  1777.       } else {

  1778.         if(ptr >= end) break;

  1779.         p       = *ptr++;

  1780.         bitMask = 0x80;

  1781.       }

  1782.     }

  1783. #ifdef NEO_KHZ400

  1784.   } else { // 400 KHz bitstream

  1785.     // ToDo!

  1786.   }

  1787. #endif

  1788. 

  1789. #elif defined (NRF51)

  1790.   uint8_t          *p   = pixels,

  1791.                     pix, count, mask;

  1792.   int32_t         num = numBytes;

  1793.   unsigned int bitmask = ( 1 << g_ADigitalPinMap[pin] );

  1794. // https://github.com/sandeepmistry/arduino-nRF5/blob/dc53980c8bac27898fca90d8ecb268e11111edc1/variants/BBCmicrobit/variant.cpp

  1795. 

  1796.   volatile unsigned int *reg = (unsigned int *) (0x50000000UL + 0x508);

  1797. 

  1798. // https://github.com/sandeepmistry/arduino-nRF5/blob/dc53980c8bac27898fca90d8ecb268e11111edc1/cores/nRF5/SDK/components/device/nrf51.h

  1799. // http://www.iot-programmer.com/index.php/books/27-micro-bit-iot-in-c/chapters-micro-bit-iot-in-c/47-micro-bit-iot-in-c-fast-memory-mapped-gpio?showall=1

  1800. // https://github.com/Microsoft/pxt-neopixel/blob/master/sendbuffer.asm

  1801. 

  1802.   asm volatile(

  1803.     // "cpsid i" ; disable irq

  1804. 

  1805.     //    b .start

  1806.     "b  L%=_start"                    "\n\t"

  1807.     // .nextbit:               ;            C0

  1808.     "L%=_nextbit:"                    "\n\t"          //;            C0

  1809.     //    str r1, [r3, #0]    ; pin := hi  C2

  1810.     "strb %[bitmask], [%[reg], #0]"   "\n\t"          //; pin := hi  C2

  1811.     //    tst r6, r0          ;            C3

  1812.     "tst %[mask], %[pix]"             "\n\t"//          ;            C3

  1813.     //    bne .islate         ;            C4

  1814.     "bne L%=_islate"                  "\n\t"          //;            C4

  1815.     //    str r1, [r2, #0]    ; pin := lo  C6

  1816.     "strb %[bitmask], [%[reg], #4]"   "\n\t"          //; pin := lo  C6

  1817.     // .islate:

  1818.     "L%=_islate:"                     "\n\t"

  1819.     //    lsrs r6, r6, #1     ; r6 >>= 1   C7

  1820.     "lsr %[mask], %[mask], #1"       "\n\t"          //; r6 >>= 1   C7

  1821.     //    bne .justbit        ;            C8

  1822.     "bne L%=_justbit"                 "\n\t"          //;            C8

  1823. 

  1824.     //    ; not just a bit - need new byte

  1825.     //    adds r4, #1         ; r4++       C9

  1826.     "add %[p], #1"                   "\n\t"          //; r4++       C9

  1827.     //    subs r5, #1         ; r5--       C10

  1828.     "sub %[num], #1"                 "\n\t"          //; r5--       C10

  1829.     //    bcc .stop           ; if (r5<0) goto .stop  C11

  1830.     "bcc L%=_stop"                    "\n\t"          //; if (r5<0) goto .stop  C11

  1831.     // .start:

  1832.     "L%=_start:"

  1833.     //    movs r6, #0x80      ; reset mask C12

  1834.     "movs %[mask], #0x80"             "\n\t"          //; reset mask C12

  1835.     //    nop                 ;            C13

  1836.     "nop"                             "\n\t"          //;            C13

  1837. 

  1838.     // .common:               ;             C13

  1839.     "L%=_common:"                     "\n\t"          //;            C13

  1840.     //    str r1, [r2, #0]   ; pin := lo   C15

  1841.     "strb %[bitmask], [%[reg], #4]"   "\n\t"          //; pin := lo  C15

  1842.     //    ; always re-load byte - it just fits with the cycles better this way

  1843.     //    ldrb r0, [r4, #0]  ; r0 := *r4   C17

  1844.     "ldrb  %[pix], [%[p], #0]"        "\n\t"          //; r0 := *r4   C17

  1845.     //    b .nextbit         ;             C20

  1846.     "b L%=_nextbit"                   "\n\t"          //;             C20

  1847. 

  1848.     // .justbit: ; C10

  1849.     "L%=_justbit:"                    "\n\t"          //; C10

  1850.     //    ; no nops, branch taken is already 3 cycles

  1851.     //    b .common ; C13

  1852.     "b L%=_common"                    "\n\t"          //; C13

  1853. 

  1854.     // .stop:

  1855.     "L%=_stop:"                       "\n\t"

  1856.     //    str r1, [r2, #0]   ; pin := lo

  1857.     "strb %[bitmask], [%[reg], #4]"   "\n\t"          //; pin := lo

  1858.     //    cpsie i            ; enable irq

  1859. 

  1860.     : [p] "+r" (p),

  1861.     [pix] "=&r" (pix),

  1862.     [count] "=&r" (count),

  1863.     [mask] "=&r" (mask),

  1864.     [num] "+r" (num)

  1865.     : [bitmask] "r" (bitmask),

  1866.     [reg] "r" (reg)

  1867.   );

  1868. 

  1869. #elif defined(__SAM3X8E__) // Arduino Due

  1870. 

  1871.   #define SCALE      VARIANT_MCK / 2UL / 1000000UL

  1872.   #define INST       (2UL * F_CPU / VARIANT_MCK)

  1873.   #define TIME_800_0 ((int)(0.40 * SCALE + 0.5) - (5 * INST))

  1874.   #define TIME_800_1 ((int)(0.80 * SCALE + 0.5) - (5 * INST))

  1875.   #define PERIOD_800 ((int)(1.25 * SCALE + 0.5) - (5 * INST))

  1876.   #define TIME_400_0 ((int)(0.50 * SCALE + 0.5) - (5 * INST))

  1877.   #define TIME_400_1 ((int)(1.20 * SCALE + 0.5) - (5 * INST))

  1878.   #define PERIOD_400 ((int)(2.50 * SCALE + 0.5) - (5 * INST))

  1879. 

  1880.   int             pinMask, time0, time1, period, t;

  1881.   Pio            *port;

  1882.   volatile WoReg *portSet, *portClear, *timeValue, *timeReset;

  1883.   uint8_t        *p, *end, pix, mask;

  1884. 

  1885.   pmc_set_writeprotect(false);

  1886.   pmc_enable_periph_clk((uint32_t)TC3_IRQn);

  1887.   TC_Configure(TC1, 0,

  1888.     TC_CMR_WAVE | TC_CMR_WAVSEL_UP | TC_CMR_TCCLKS_TIMER_CLOCK1);

  1889.   TC_Start(TC1, 0);

  1890. 

  1891.   pinMask   = g_APinDescription[pin].ulPin; // Don't 'optimize' these into

  1892.   port      = g_APinDescription[pin].pPort; // declarations above.  Want to

  1893.   portSet   = &(port->PIO_SODR);            // burn a few cycles after

  1894.   portClear = &(port->PIO_CODR);            // starting timer to minimize

  1895.   timeValue = &(TC1->TC_CHANNEL[0].TC_CV);  // the initial 'while'.

  1896.   timeReset = &(TC1->TC_CHANNEL[0].TC_CCR);

  1897.   p         =  pixels;

  1898.   end       =  p + numBytes;

  1899.   pix       = *p++;

  1900.   mask      = 0x80;

  1901. 

  1902. #ifdef NEO_KHZ400 // 800 KHz check needed only if 400 KHz support enabled

  1903.   if(is800KHz) {

  1904. #endif

  1905.     time0  = TIME_800_0;

  1906.     time1  = TIME_800_1;

  1907.     period = PERIOD_800;

  1908. #ifdef NEO_KHZ400

  1909.   } else { // 400 KHz bitstream

  1910.     time0  = TIME_400_0;

  1911.     time1  = TIME_400_1;

  1912.     period = PERIOD_400;

  1913.   }

  1914. #endif

  1915. 

  1916.   for(t = time0;; t = time0) {

  1917.     if(pix & mask) t = time1;

  1918.     while(*timeValue < period);

  1919.     *portSet   = pinMask;

  1920.     *timeReset = TC_CCR_CLKEN | TC_CCR_SWTRG;

  1921.     while(*timeValue < t);

  1922.     *portClear = pinMask;

  1923.     if(!(mask >>= 1)) {   // This 'inside-out' loop logic utilizes

  1924.       if(p >= end) break; // idle time to minimize inter-byte delays.

  1925.       pix = *p++;

  1926.       mask = 0x80;

  1927.     }

  1928.   }

  1929.   while(*timeValue < period); // Wait for last bit

  1930.   TC_Stop(TC1, 0);

  1931. 

  1932. #endif // end Due

  1933. 

  1934. // END ARM ----------------------------------------------------------------

  1935. 

  1936. 

  1937. #elif defined(ESP8266) || defined(ESP32)

  1938. 

  1939. // ESP8266 ----------------------------------------------------------------

  1940. 

  1941.   // ESP8266 show() is external to enforce ICACHE_RAM_ATTR execution

  1942.   espShow(pin, pixels, numBytes, is800KHz);

  1943. 

  1944. #elif defined(__ARDUINO_ARC__)

  1945. 

  1946. // Arduino 101  -----------------------------------------------------------

  1947. 

  1948. #define NOPx7 { __builtin_arc_nop(); \

  1949.   __builtin_arc_nop(); __builtin_arc_nop(); \

  1950.   __builtin_arc_nop(); __builtin_arc_nop(); \

  1951.   __builtin_arc_nop(); __builtin_arc_nop(); }

  1952. 

  1953.   PinDescription *pindesc = &g_APinDescription[pin];

  1954.   register uint32_t loop = 8 * numBytes; // one loop to handle all bytes and all bits

  1955.   register uint8_t *p = pixels;

  1956.   register uint32_t currByte = (uint32_t) (*p);

  1957.   register uint32_t currBit = 0x80 & currByte;

  1958.   register uint32_t bitCounter = 0;

  1959.   register uint32_t first = 1;

  1960. 

  1961.   // The loop is unusual. Very first iteration puts all the way LOW to the wire -

  1962.   // constant LOW does not affect NEOPIXEL, so there is no visible effect displayed.

  1963.   // During that very first iteration CPU caches instructions in the loop.

  1964.   // Because of the caching process, "CPU slows down". NEOPIXEL pulse is very time sensitive

  1965.   // that's why we let the CPU cache first and we start regular pulse from 2nd iteration

  1966.   if (pindesc->ulGPIOType == SS_GPIO) {

  1967.     register uint32_t reg = pindesc->ulGPIOBase + SS_GPIO_SWPORTA_DR;

  1968.     uint32_t reg_val = __builtin_arc_lr((volatile uint32_t)reg);

  1969.     register uint32_t reg_bit_high = reg_val | (1 << pindesc->ulGPIOId);

  1970.     register uint32_t reg_bit_low  = reg_val & ~(1 << pindesc->ulGPIOId);

  1971. 

  1972.     loop += 1; // include first, special iteration

  1973.     while(loop--) {

  1974.       if(!first) {

  1975.         currByte <<= 1;

  1976.         bitCounter++;

  1977.       }

  1978. 

  1979.       // 1 is >550ns high and >450ns low; 0 is 200..500ns high and >450ns low

  1980.       __builtin_arc_sr(first ? reg_bit_low : reg_bit_high, (volatile uint32_t)reg);

  1981.       if(currBit) { // ~400ns HIGH (740ns overall)

  1982.         NOPx7

  1983.         NOPx7

  1984.       }

  1985.       // ~340ns HIGH

  1986.       NOPx7

  1987.      __builtin_arc_nop();

  1988. 

  1989.       // 820ns LOW; per spec, max allowed low here is 5000ns */

  1990.       __builtin_arc_sr(reg_bit_low, (volatile uint32_t)reg);

  1991.       NOPx7

  1992.       NOPx7

  1993. 

  1994.       if(bitCounter >= 8) {

  1995.         bitCounter = 0;

  1996.         currByte = (uint32_t) (*++p);

  1997.       }

  1998. 

  1999.       currBit = 0x80 & currByte;

  2000.       first = 0;

  2001.     }

  2002.   } else if(pindesc->ulGPIOType == SOC_GPIO) {

  2003.     register uint32_t reg = pindesc->ulGPIOBase + SOC_GPIO_SWPORTA_DR;

  2004.     uint32_t reg_val = MMIO_REG_VAL(reg);

  2005.     register uint32_t reg_bit_high = reg_val | (1 << pindesc->ulGPIOId);

  2006.     register uint32_t reg_bit_low  = reg_val & ~(1 << pindesc->ulGPIOId);

  2007. 

  2008.     loop += 1; // include first, special iteration

  2009.     while(loop--) {

  2010.       if(!first) {

  2011.         currByte <<= 1;

  2012.         bitCounter++;

  2013.       }

  2014.       MMIO_REG_VAL(reg) = first ? reg_bit_low : reg_bit_high;

  2015.       if(currBit) { // ~430ns HIGH (740ns overall)

  2016.         NOPx7

  2017.         NOPx7

  2018.         __builtin_arc_nop();

  2019.       }

  2020.       // ~310ns HIGH

  2021.       NOPx7

  2022. 

  2023.       // 850ns LOW; per spec, max allowed low here is 5000ns */

  2024.       MMIO_REG_VAL(reg) = reg_bit_low;

  2025.       NOPx7

  2026.       NOPx7

  2027. 

  2028.       if(bitCounter >= 8) {

  2029.         bitCounter = 0;

  2030.         currByte = (uint32_t) (*++p);

  2031.       }

  2032. 

  2033.       currBit = 0x80 & currByte;

  2034.       first = 0;

  2035.     }

  2036.   }

  2037. 

  2038. #else

  2039. #error Architecture not supported

  2040. #endif

  2041. 

  2042. 

  2043. // END ARCHITECTURE SELECT ------------------------------------------------

  2044. 

  2045. #if !( defined(NRF52) || defined(NRF52_SERIES) )

  2046.   interrupts();

  2047. #endif

  2048. 

  2049.   endTime = micros(); // Save EOD time for latch on next call

  2050. }

  2051. 

  2052. // Set the output pin number

  2053. void Adafruit_NeoPixel::setPin(uint8_t p) {

  2054.   if(begun && (pin >= 0)) pinMode(pin, INPUT);

  2055.     pin = p;

  2056.     if(begun) {

  2057.       pinMode(p, OUTPUT);

  2058.       digitalWrite(p, LOW);

  2059.     }

  2060. #ifdef __AVR__

  2061.     port    = portOutputRegister(digitalPinToPort(p));

  2062.     pinMask = digitalPinToBitMask(p);

  2063. #endif

  2064. }

  2065. 

  2066. // Set pixel color from separate R,G,B components:

  2067. void Adafruit_NeoPixel::setPixelColor(

  2068.  uint16_t n, uint8_t r, uint8_t g, uint8_t b) {

  2069. 

  2070.   if(n < numLEDs) {

  2071.     if(brightness) { // See notes in setBrightness()

  2072.       r = (r * brightness) >> 8;

  2073.       g = (g * brightness) >> 8;

  2074.       b = (b * brightness) >> 8;

  2075.     }

  2076.     uint8_t *p;

  2077.     if(wOffset == rOffset) { // Is an RGB-type strip

  2078.       p = &pixels[n * 3];    // 3 bytes per pixel

  2079.     } else {                 // Is a WRGB-type strip

  2080.       p = &pixels[n * 4];    // 4 bytes per pixel

  2081.       p[wOffset] = 0;        // But only R,G,B passed -- set W to 0

  2082.     }

  2083.     p[rOffset] = r;          // R,G,B always stored

  2084.     p[gOffset] = g;

  2085.     p[bOffset] = b;

  2086.   }

  2087. }

  2088. 

  2089. void Adafruit_NeoPixel::setPixelColor(

  2090.  uint16_t n, uint8_t r, uint8_t g, uint8_t b, uint8_t w) {

  2091. 

  2092.   if(n < numLEDs) {

  2093.     if(brightness) { // See notes in setBrightness()

  2094.       r = (r * brightness) >> 8;

  2095.       g = (g * brightness) >> 8;

  2096.       b = (b * brightness) >> 8;

  2097.       w = (w * brightness) >> 8;

  2098.     }

  2099.     uint8_t *p;

  2100.     if(wOffset == rOffset) { // Is an RGB-type strip

  2101.       p = &pixels[n * 3];    // 3 bytes per pixel (ignore W)

  2102.     } else {                 // Is a WRGB-type strip

  2103.       p = &pixels[n * 4];    // 4 bytes per pixel

  2104.       p[wOffset] = w;        // Store W

  2105.     }

  2106.     p[rOffset] = r;          // Store R,G,B

  2107.     p[gOffset] = g;

  2108.     p[bOffset] = b;

  2109.   }

  2110. }

  2111. 

  2112. // Set pixel color from 'packed' 32-bit RGB color:

  2113. void Adafruit_NeoPixel::setPixelColor(uint16_t n, uint32_t c) {

  2114.   if(n < numLEDs) {

  2115.     uint8_t *p,

  2116.       r = (uint8_t)(c >> 16),

  2117.       g = (uint8_t)(c >>  8),

  2118.       b = (uint8_t)c;

  2119.     if(brightness) { // See notes in setBrightness()

  2120.       r = (r * brightness) >> 8;

  2121.       g = (g * brightness) >> 8;

  2122.       b = (b * brightness) >> 8;

  2123.     }

  2124.     if(wOffset == rOffset) {

  2125.       p = &pixels[n * 3];

  2126.     } else {

  2127.       p = &pixels[n * 4];

  2128.       uint8_t w = (uint8_t)(c >> 24);

  2129.       p[wOffset] = brightness ? ((w * brightness) >> 8) : w;

  2130.     }

  2131.     p[rOffset] = r;

  2132.     p[gOffset] = g;

  2133.     p[bOffset] = b;

  2134.   }

  2135. }

  2136. 

  2137. // Fills all or a given start+length of strip. Arguments:

  2138. // Packed RGB color (0 if unspecified, effectively a strip clear operation).

  2139. // Index if first pixel (0 if unspecified - beginning of strip).

  2140. // Pixel count (if unspecified, fills to end of strip).

  2141. void Adafruit_NeoPixel::fill(uint32_t c, uint16_t first, uint16_t count) {

  2142.   uint16_t i, end;

  2143. 

  2144.   if(first >= numLEDs) {

  2145.     return; // If first LED is past end of strip, nothing to do

  2146.   }

  2147. 

  2148.   // Calculate the index ONE AFTER the last pixel to fill

  2149.   if(count == 0) {

  2150.     // Fill to end of strip

  2151.     end = numLEDs;

  2152.   } else {

  2153.     // Ensure that the loop won't go past the last pixel

  2154.     end = first + count;

  2155.     if(end > numLEDs) end = numLEDs;

  2156.   }

  2157. 

  2158.   for(i = first; i < end; i++) {

  2159.     this->setPixelColor(i, c);

  2160.   }

  2161. }

  2162. 

  2163. // Convert separate R,G,B into packed 32-bit RGB color.

  2164. // Packed format is always RGB, regardless of LED strand color order.

  2165. uint32_t Adafruit_NeoPixel::Color(uint8_t r, uint8_t g, uint8_t b) {

  2166.   return ((uint32_t)r << 16) | ((uint32_t)g <<  8) | b;

  2167. }

  2168. 

  2169. // Convert separate R,G,B,W into packed 32-bit WRGB color.

  2170. // Packed format is always WRGB, regardless of LED strand color order.

  2171. uint32_t Adafruit_NeoPixel::Color(uint8_t r, uint8_t g, uint8_t b, uint8_t w) {

  2172.   return ((uint32_t)w << 24) | ((uint32_t)r << 16) | ((uint32_t)g <<  8) | b;

  2173. }

  2174. 

  2175. // Query color from previously-set pixel (returns packed 32-bit RGB value)

  2176. uint32_t Adafruit_NeoPixel::getPixelColor(uint16_t n) const {

  2177.   if(n >= numLEDs) return 0; // Out of bounds, return no color.

  2178. 

  2179.   uint8_t *p;

  2180. 

  2181.   if(wOffset == rOffset) { // Is RGB-type device

  2182.     p = &pixels[n * 3];

  2183.     if(brightness) {

  2184.       // Stored color was decimated by setBrightness().  Returned value

  2185.       // attempts to scale back to an approximation of the original 24-bit

  2186.       // value used when setting the pixel color, but there will always be

  2187.       // some error -- those bits are simply gone.  Issue is most

  2188.       // pronounced at low brightness levels.

  2189.       return (((uint32_t)(p[rOffset] << 8) / brightness) << 16) |

  2190.              (((uint32_t)(p[gOffset] << 8) / brightness) <<  8) |

  2191.              ( (uint32_t)(p[bOffset] << 8) / brightness       );

  2192.     } else {

  2193.       // No brightness adjustment has been made -- return 'raw' color

  2194.       return ((uint32_t)p[rOffset] << 16) |

  2195.              ((uint32_t)p[gOffset] <<  8) |

  2196.               (uint32_t)p[bOffset];

  2197.     }

  2198.   } else {                 // Is RGBW-type device

  2199.     p = &pixels[n * 4];

  2200.     if(brightness) { // Return scaled color

  2201.       return (((uint32_t)(p[wOffset] << 8) / brightness) << 24) |

  2202.              (((uint32_t)(p[rOffset] << 8) / brightness) << 16) |

  2203.              (((uint32_t)(p[gOffset] << 8) / brightness) <<  8) |

  2204.              ( (uint32_t)(p[bOffset] << 8) / brightness       );

  2205.     } else { // Return raw color

  2206.       return ((uint32_t)p[wOffset] << 24) |

  2207.              ((uint32_t)p[rOffset] << 16) |

  2208.              ((uint32_t)p[gOffset] <<  8) |

  2209.               (uint32_t)p[bOffset];

  2210.     }

  2211.   }

  2212. }

  2213. 

  2214. // Returns pointer to pixels[] array.  Pixel data is stored in device-

  2215. // native format and is not translated here.  Application will need to be

  2216. // aware of specific pixel data format and handle colors appropriately.

  2217. uint8_t *Adafruit_NeoPixel::getPixels(void) const {

  2218.   return pixels;

  2219. }

  2220. 

  2221. uint16_t Adafruit_NeoPixel::numPixels(void) const {

  2222.   return numLEDs;

  2223. }

  2224. 

  2225. // Adjust output brightness; 0=darkest (off), 255=brightest.  This does

  2226. // NOT immediately affect what's currently displayed on the LEDs.  The

  2227. // next call to show() will refresh the LEDs at this level.  However,

  2228. // this process is potentially "lossy," especially when increasing

  2229. // brightness.  The tight timing in the WS2811/WS2812 code means there

  2230. // aren't enough free cycles to perform this scaling on the fly as data

  2231. // is issued.  So we make a pass through the existing color data in RAM

  2232. // and scale it (subsequent graphics commands also work at this

  2233. // brightness level).  If there's a significant step up in brightness,

  2234. // the limited number of steps (quantization) in the old data will be

  2235. // quite visible in the re-scaled version.  For a non-destructive

  2236. // change, you'll need to re-render the full strip data.  C'est la vie.

  2237. void Adafruit_NeoPixel::setBrightness(uint8_t b) {

  2238.   // Stored brightness value is different than what's passed.

  2239.   // This simplifies the actual scaling math later, allowing a fast

  2240.   // 8x8-bit multiply and taking the MSB.  'brightness' is a uint8_t,

  2241.   // adding 1 here may (intentionally) roll over...so 0 = max brightness

  2242.   // (color values are interpreted literally; no scaling), 1 = min

  2243.   // brightness (off), 255 = just below max brightness.

  2244.   uint8_t newBrightness = b + 1;

  2245.   if(newBrightness != brightness) { // Compare against prior value

  2246.     // Brightness has changed -- re-scale existing data in RAM

  2247.     uint8_t  c,

  2248.             *ptr           = pixels,

  2249.              oldBrightness = brightness - 1; // De-wrap old brightness value

  2250.     uint16_t scale;

  2251.     if(oldBrightness == 0) scale = 0; // Avoid /0

  2252.     else if(b == 255) scale = 65535 / oldBrightness;

  2253.     else scale = (((uint16_t)newBrightness << 8) - 1) / oldBrightness;

  2254.     for(uint16_t i=0; i<numBytes; i++) {

  2255.       c      = *ptr;

  2256.       *ptr++ = (c * scale) >> 8;

  2257.     }

  2258.     brightness = newBrightness;

  2259.   }

  2260. }

  2261. 

  2262. //Return the brightness value

  2263. uint8_t Adafruit_NeoPixel::getBrightness(void) const {

  2264.   return brightness - 1;

  2265. }

  2266. 

  2267. void Adafruit_NeoPixel::clear() {

  2268.   memset(pixels, 0, numBytes);

  2269. }

  2270. 

  2271. /* A PROGMEM (flash mem) table containing 8-bit unsigned sine wave (0-255).

  2272.    Copy & paste this snippet into a Python REPL to regenerate:

  2273. import math

  2274. for x in range(256):

  2275.     print("{:3},".format(int((math.sin(x/128.0*math.pi)+1.0)*127.5+0.5))),

  2276.     if x&15 == 15: print

  2277. */

  2278. static const uint8_t PROGMEM _sineTable[256] = {

  2279.   128,131,134,137,140,143,146,149,152,155,158,162,165,167,170,173,

  2280.   176,179,182,185,188,190,193,196,198,201,203,206,208,211,213,215,

  2281.   218,220,222,224,226,228,230,232,234,235,237,238,240,241,243,244,

  2282.   245,246,248,249,250,250,251,252,253,253,254,254,254,255,255,255,

  2283.   255,255,255,255,254,254,254,253,253,252,251,250,250,249,248,246,

  2284.   245,244,243,241,240,238,237,235,234,232,230,228,226,224,222,220,

  2285.   218,215,213,211,208,206,203,201,198,196,193,190,188,185,182,179,

  2286.   176,173,170,167,165,162,158,155,152,149,146,143,140,137,134,131,

  2287.   128,124,121,118,115,112,109,106,103,100, 97, 93, 90, 88, 85, 82,

  2288.    79, 76, 73, 70, 67, 65, 62, 59, 57, 54, 52, 49, 47, 44, 42, 40,

  2289.    37, 35, 33, 31, 29, 27, 25, 23, 21, 20, 18, 17, 15, 14, 12, 11,

  2290.    10,  9,  7,  6,  5,  5,  4,  3,  2,  2,  1,  1,  1,  0,  0,  0,

  2291.     0,  0,  0,  0,  1,  1,  1,  2,  2,  3,  4,  5,  5,  6,  7,  9,

  2292.    10, 11, 12, 14, 15, 17, 18, 20, 21, 23, 25, 27, 29, 31, 33, 35,

  2293.    37, 40, 42, 44, 47, 49, 52, 54, 57, 59, 62, 65, 67, 70, 73, 76,

  2294.    79, 82, 85, 88, 90, 93, 97,100,103,106,109,112,115,118,121,124};

  2295. 

  2296. /* Similar to above, but for an 8-bit gamma-correction table.

  2297.    Copy & paste this snippet into a Python REPL to regenerate:

  2298. import math

  2299. gamma=2.6

  2300. for x in range(256):

  2301.     print("{:3},".format(int(math.pow((x)/255.0,gamma)*255.0+0.5))),

  2302.     if x&15 == 15: print

  2303. */

  2304. static const uint8_t PROGMEM _gammaTable[256] = {

  2305.     0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,

  2306.     0,  0,  0,  0,  0,  0,  0,  0,  1,  1,  1,  1,  1,  1,  1,  1,

  2307.     1,  1,  1,  1,  2,  2,  2,  2,  2,  2,  2,  2,  3,  3,  3,  3,

  2308.     3,  3,  4,  4,  4,  4,  5,  5,  5,  5,  5,  6,  6,  6,  6,  7,

  2309.     7,  7,  8,  8,  8,  9,  9,  9, 10, 10, 10, 11, 11, 11, 12, 12,

  2310.    13, 13, 13, 14, 14, 15, 15, 16, 16, 17, 17, 18, 18, 19, 19, 20,

  2311.    20, 21, 21, 22, 22, 23, 24, 24, 25, 25, 26, 27, 27, 28, 29, 29,

  2312.    30, 31, 31, 32, 33, 34, 34, 35, 36, 37, 38, 38, 39, 40, 41, 42,

  2313.    42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57,

  2314.    58, 59, 60, 61, 62, 63, 64, 65, 66, 68, 69, 70, 71, 72, 73, 75,

  2315.    76, 77, 78, 80, 81, 82, 84, 85, 86, 88, 89, 90, 92, 93, 94, 96,

  2316.    97, 99,100,102,103,105,106,108,109,111,112,114,115,117,119,120,

  2317.   122,124,125,127,129,130,132,134,136,137,139,141,143,145,146,148,

  2318.   150,152,154,156,158,160,162,164,166,168,170,172,174,176,178,180,

  2319.   182,184,186,188,191,193,195,197,199,202,204,206,209,211,213,215,

  2320.   218,220,223,225,227,230,232,235,237,240,242,245,247,250,252,255};

  2321. 

  2322. uint8_t Adafruit_NeoPixel::sine8(uint8_t x) const {

  2323.   return pgm_read_byte(&_sineTable[x]); // 0-255 in, 0-255 out

  2324. }

  2325. 

  2326. uint8_t Adafruit_NeoPixel::gamma8(uint8_t x) const {

  2327.   return pgm_read_byte(&_gammaTable[x]); // 0-255 in, 0-255 out

  2328. }

  2329.