Gixie Clock

1#include<stdio.h>
2#include <avr/io.h>
3#include <util/delay.h>
4#include  "RX8025.h"
5
6unsigned char ack; /**/
7
8/*******************************************************************
9
10:  void Start_I2c();
11: I2C ,I2C .
12********************************************************************/
13void  Start_I2c()
14{
15	SCL_OUT();
16	SCL_L();
17	SDA_OUT();/**/
18  _delay_us(5);  
19	SDA_H(); /**/
20	_delay_us(5);
21	SCL_H();	/**/
22	_delay_us(6); /*4.7us,*/
23	SDA_L();  /**/
24	_delay_us(6); /* 4s*/
25	SCL_L(); /*I2C  */
26	_delay_us(2);
27}
28/*******************************************************************
29
30:  void Stop_I2c();
31: I2C ,I2C .
32********************************************************************/
33void  Stop_I2c()
34{
35	SCL_OUT();
36	SCL_L();
37	_delay_us(6);
38	SDA_OUT();/**/
39	SDA_L()  ; /**/
40	_delay_us(6);
41	SCL_H(); /*4s*/
42	_delay_us(6);
43	SDA_H();  /*I2C */
44	_delay_us(6);
45	SCL_L();
46}
47/*******************************************************************
48
49:  void SendByte(uchar c);
50: c ,,,,
51.(ack=0 )
52ack=1; ack=0 
53********************************************************************/
54void  SendByte(unsigned char c)
55{
56	unsigned char BitCnt =0;
57	SCL_OUT();
58	SDA_OUT();/**/
59
60	for(BitCnt  = 0; BitCnt < 8; BitCnt++){ /*8 */
61	  SCL_L();
62		_delay_us(6);
63		if((c  << BitCnt) & 0x80) SDA_H(); /**/
64		else SDA_L();
65		_delay_us(6);
66		SCL_H();  /**/
67		_delay_us(5); /*4s*/
68		SCL_L();
69		_delay_us(6);
70	}
71	SDA_H();  /*8 */
72	SDA_IN();/**/
73	_delay_us(1);
74	SCL_H();
75	_delay_us(3);
76	if(1  == SDA_INPUT()) 
77	{
78	ack = 0;/**/
79	}
80	else ack=1; /**/
81	SCL_L();
82	_delay_us(3);
83}
84/*******************************************************************
85
86:  uchar RcvByte();
87: ,()
88
89********************************************************************/
90unsigned  char RcvByte()
91{
92	unsigned char retc = 0;
93	unsigned char BitCnt = 0;
94	SCL_OUT();
95	SDA_OUT();
96	SCL_L();
97	_delay_us(6);
98	SDA_H();  /**/
99	_delay_us(2);
100	SDA_IN();/**/
101	for(BitCnt = 0; BitCnt < 8; BitCnt++)
102	{
103		_delay_us(1);
104		SCL_L();  /**/
105		_delay_us(6); /*4.7s*/
106		SCL_H(); /**/
107		_delay_us(1);
108		retc  = (retc << 1);
109		if(1 == SDA_INPUT()) 
110		retc = (retc + 1); /*,retc  */
111	}
112	SCL_L();
113	_delay_us(1);
114	//_delay_us(1);
115	return(retc);
116}
117/********************************************************************
118
119:  void Ack_I2c(bit a);
120:,()
121********************************************************************/
122void  Ack_I2c(unsigned char a)
123{
124    SDA_OUT();
125	if(a == 0) SDA_L(); /* */
126	else  SDA_H();
127	_delay_us(3);
128	SCL_H();
129	_delay_us(5); /*4s*/
130	SCL_L();  /*I2C */
131	_delay_us(2);
132}
133/*******************************************************************
134
135:  bit ISendStr(uchar sla,uchar suba,ucahr *s,uchar no);
136: ,,
137slasubas no 
1381  
139 
140********************************************************************/
141unsigned  char ISendStr(unsigned char sla,unsigned char suba,unsigned char *s,unsigned char  no)
142{
143	unsigned char i;
144	Start_I2c(); /**/
145	SendByte(sla); /**/
146	if(ack  == 0) return(0);
147	SendByte(suba); /**/
148	if(ack == 0) return(0);
149	for(i  = 0; i < no; i++){
150		SendByte(*s); /**/
151		if(ack == 0) return(0);
152		s++;
153	}
154	Stop_I2c();  /**/
155	return(1);
156}
157/*******************************************************************
158
159:  bit ISendStr(uchar sla,uchar suba,ucahr *s,uchar no);
160: ,,
161slasubas no 
1621  
163 
164********************************************************************/
165unsigned  char IRcvStr(unsigned char sla,unsigned char suba,unsigned char *s,unsigned char  no)
166{
167	unsigned char i;
168	Start_I2c(); /**/
169	SendByte(sla); /**/
170	if(ack  == 0) return(0);
171	SendByte(suba); /**/
172	if(ack == 0) return(0);
173	Start_I2c();
174	SendByte(sla  + 1);
175	if(ack == 0) return(0);
176	for(i = 0; i< no - 1; i++){
177		*s =  RcvByte(); /**/
178		Ack_I2c(0); /**/
179		s++;
180		_delay_us(1);
181		_delay_us(1);
182	}
183	*s  = RcvByte();
184	Ack_I2c(1); /**/
185	Stop_I2c(); /**/
186	return(1);
187}
188/*********************************************************************************************
189RX8025
190  RX8025_INIT();
191  
192
193  7
194  7unsigned char YY,MO,DD,WW,HH,MM,SS; //
195**********************************************************************************************/
196void  RX8025_INIT(void)
197{ //
198	unsigned char buf[7]; //
199	IRcvStr(RX8025_ADD,RS8025_CONTROL_REG_ADD,buf,2);  //
200	if(buf[1] & 0x10){ //C10x01
201		buf[0] |= 0x20; //24
202		buf[1] &=  0xEF; //PON
203		ISendStr(RX8025_ADD,RS8025_CONTROL_REG_ADD,buf,2); //
204	}
205}
206/*********************************************************************************************
207RX8025
208  RX8025_READ();
209  
210
211  (
212**********************************************************************************************/
213void  RX8025_READ (unsigned char *GetTime)
214{
215	unsigned char _time[3];
216    IRcvStr(RX8025_ADD,RS8025_TIME_REG_START_ADD,_time,3);  //
217	GetTime[0] = _time[2] >> 4;
218	GetTime[1] = _time[2] & 0x0F;
219	GetTime[2]  = _time[1] >> 4;
220	GetTime[3] = _time[1] & 0x0F;
221	GetTime[4] = _time[0] >>  4;
222	GetTime[5] = _time[0] & 0x0F;
223}
224/*********************************************************************************************
225RX8025
226  RX8025_WRITE();
227  
228
229  7
230**********************************************************************************************/
231void  RX8025_WRITE (unsigned char *SetTime)
232{
233	unsigned char _time[3];
234	_time[2]  = (SetTime[0] << 4) | SetTime[1];
235	_time[1] = (SetTime[2] << 4) | SetTime[3];
236	_time[0]  = (SetTime[4] << 4) | SetTime[5];
237	ISendStr(RX8025_ADD,RS8025_TIME_REG_START_ADD,_time,3);  //
238}
239

1#include "Adafruit_NeoPixel.h"
2#include "light.h"
3#include "RX8025.h"
4
5extern  unsigned char _t[6];
6
7Adafruit_NeoPixel light[6] = {Adafruit_NeoPixel(10,  13, NEO_GRB + NEO_KHZ800),
8                              Adafruit_NeoPixel(10,  12, NEO_GRB + NEO_KHZ800),
9                              Adafruit_NeoPixel(10,  11, NEO_GRB + NEO_KHZ800),
10                              Adafruit_NeoPixel(10,  10, NEO_GRB + NEO_KHZ800),
11                              Adafruit_NeoPixel(10,  9 , NEO_GRB + NEO_KHZ800),
12                              Adafruit_NeoPixel(10,  8 , NEO_GRB + NEO_KHZ800)};
13
14color rgb[6];
15
16void light_init(){
17  unsigned  char i;
18  for(i=0;i<6;i++)light[i].begin();
19}
20
21void poeron_effect()//
22{
23  #define TTT 80
24  #define WHITE 100
25  unsigned char i,j,k;
26  for(k=0;k<2;k++)
27  {
28    for(i=0;i<6;i++) //i
29    {
30      RX8025_READ(_t);
31      light_wirte(_t,rgb);
32      for(j=0;j<_t[i];j++)light[i].setPixelColor(j, light[i].Color((rgb[i].r>>2)+50,(rgb[i].g>>2)+50,(rgb[i].b>>2)+50));  //j
33      light[i].setPixelColor(_t[i], light[i].Color(rgb[i].r,rgb[i].g,rgb[i].b));
34      for(j=_t[i]+1;j<10;j++)light[i].setPixelColor(j, light[i].Color((rgb[i].r>>2)+50,(rgb[i].g>>2)+50,(rgb[i].b>>2)+50));
35      light[i].show();
36      for(j=0;j<10;j++)light[i].setPixelColor(j, light[i].Color(0,0,0));
37      delay(TTT);
38    }
39    for(i=5;i!=255;i--) //i
40    {
41      RX8025_READ(_t);
42      light_wirte(_t,rgb);
43      for(j=0;j<_t[i];j++)light[i].setPixelColor(j,  light[i].Color((rgb[i].r>>2)+50,(rgb[i].g>>2)+50,(rgb[i].b>>2)+50)); //j
44      light[i].setPixelColor(_t[i],  light[i].Color(rgb[i].r,rgb[i].g,rgb[i].b));
45      for(j=_t[i]+1;j<10;j++)light[i].setPixelColor(j,  light[i].Color((rgb[i].r>>2)+50,(rgb[i].g>>2)+50,(rgb[i].b>>2)+50));
46      light[i].show();
47      for(j=0;j<10;j++)light[i].setPixelColor(j, light[i].Color(0,0,0));
48      delay(TTT);
49    }
50  }
51}
52
53void effect4()
54{
55  static unsigned char n=0,col=0;
56  unsigned char temp,temp1;
57
58  light[temp=n/10].setPixelColor(temp1=n%10,  light[n/10].Color(rgb[temp].r,rgb[temp].g,rgb[temp].b));
59  light[temp=5-temp].setPixelColor(10-temp1,  light[n/10].Color(rgb[temp].r,rgb[temp].g,rgb[temp].b));
60  for(unsigned char  i=0;i<6;i++)light[i].show();
61  for(unsigned char i=0;i<6;i++)
62    for(unsigned  char j=0;j<10;j++)
63      light[i].setPixelColor(j, light[i].Color(0,0,0));
64  n++;
65  if(n==60)
66  {
67    n=0;
68    make_color(&rgb[0],col+=20);
69    for(unsigned char i=1;i<6;i++){
70       rgb[i] = rgb[0];
71    }
72  }
73}
74
75void  light_wirte(unsigned char* number,color* rgb){
76  unsigned char i;
77  for(i=0;i<6;i++)
78    light[i].setPixelColor(*(number + i), light[i].Color(rgb[i].r,rgb[i].g,rgb[i].b));
79  for(i=0;i<6;i++)
80	  light[i].show();
81  for(i=0;i<6;i++)
82    light[i].setPixelColor(*(number  + i), light[0].Color(0,0,0));
83}
84
85/*rgb*/
86void make_color(color *p,unsigned  char c_n)
87{
88        unsigned char WheelPos;
89        color rgb_temp;
90        WheelPos=255-(((256/8)+c_n)&255);
91        if(WheelPos < 85)
92        {   rgb_temp.r=255 - WheelPos * 3;rgb_temp.g=0;rgb_temp.b=WheelPos * 3;
93            *p  = rgb_temp;
94            return;
95        }
96        if(WheelPos < 170)
97        {   WheelPos -= 85;rgb_temp.r=0;rgb_temp.g=WheelPos * 3;rgb_temp.b=255 -  WheelPos * 3;
98            *p = rgb_temp;
99            return;
100        }
101        WheelPos -= 170;rgb_temp.r=WheelPos * 3;rgb_temp.g=255 - WheelPos * 3;rgb_temp.b=0;
102        *p = rgb_temp;
103        return;
104}
105/**/
106void wheel(color* p)
107{
108    static unsigned char i=0;
109    unsigned char j,WheelPos;
110    color rgbxxx;
111    for(j=0;j<6;j++)
112    {
113        WheelPos=255-(((j*256/8)+i)&255);
114        if(WheelPos  < 85)
115        {   rgbxxx.r=255 - WheelPos * 3;rgbxxx.g=0;rgbxxx.b=WheelPos *  3;
116            *(p+j)=rgbxxx;
117            continue;
118        }
119        if(WheelPos  < 170)
120        {   WheelPos -= 85;rgbxxx.r=0;rgbxxx.g=WheelPos * 3;rgbxxx.b=255  - WheelPos * 3;
121            *(p+j)=rgbxxx;
122            continue;
123        }
124        WheelPos -= 170;rgbxxx.r=WheelPos * 3;rgbxxx.g=255 - WheelPos * 3;rgbxxx.b=0;
125        *(p+j)=rgbxxx;
126    }
127    i++;
128}
129

1#ifndef LIGHT_H
2#define LIGHT_H
3
4
5struct color{
6	unsigned  char r;
7	unsigned char g;
8	unsigned char b;
9};
10
11extern color rgb[6];
12
13void  light_init();
14void poeron_effect();
15void effect4();
16void light_wirte(unsigned  char* number,color* rgb);
17
18void make_color(color *p,unsigned char c_n);
19void  wheel(color* p);
20
21#endif
22

1/*
2 * key.h
3 *
4 *  Created on: 201858
5 *      Author: 
6  */
7 
8 #ifndef _KEY_H
9 #define _KEY_H
10 
11 //#define key_input(nnn)  (PIND>>(5+nnn)) & 0x01
12unsigned char key_input(unsigned char nnn);
13 #define  key_no	    0    //no keys
14 #define key_click  1    //click keys
15 #define  key_double 2    //double click
16 #define key_long   3    //long click
17
18  #define key_state_0   0
19 #define key_state_1   1
20 #define key_state_2   2
21  #define key_state_3   3 //key states define
22
23 #define key_flag	(1<<0)
24  #define clear_key_flag  (~(1<<0))
25 void key_init(); // 
26 unsigned char key_read(unsigned  char nnn); // 
27 
28 #endif /*end _KEY_H*/
29

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)
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:
45Adafruit_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!
58Adafruit_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
67Adafruit_NeoPixel::~Adafruit_NeoPixel()  {
68  if(pixels)   free(pixels);
69  if(pin >= 0) pinMode(pin, INPUT);
70}
71
72void  Adafruit_NeoPixel::begin(void) {
73  if(pin >= 0) {
74    pinMode(pin, OUTPUT);
75    digitalWrite(pin, LOW);
76  }
77  begun = true;
78
79}
80
81void 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
94void 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
115extern  "C" void ICACHE_RAM_ATTR espShow(
116  uint8_t pin, uint8_t *pixels, uint32_t  numBytes, uint8_t type);
117#elif defined(ESP32)
118extern "C" void espShow(
119  uint8_t pin, uint8_t *pixels, uint32_t numBytes, uint8_t type);
120#endif // ESP8266
121
122void  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#ifndef NRF52
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:"                   "\
212\	" // Clk  Pseudocode
213        // Bit 7:
214        "out  %[port] , %[hi]"    "\
215\	" // 1    PORT  = hi
216        "mov  %[n2]   , %[lo]"    "\
217\	" // 1    n2   = lo
218        "out  %[port] , %[n1]"    "\
219\	" // 1    PORT = n1
220        "rjmp .+0"                "\
221\	"  // 2    nop nop
222        "sbrc %[byte] , 6"        "\
223\	" // 1-2  if(b &  0x40)
224         "mov %[n2]   , %[hi]"    "\
225\	" // 0-1   n2 = hi
226        "out  %[port] , %[lo]"    "\
227\	" // 1    PORT = lo
228        "rjmp .+0"                "\
229\	"  // 2    nop nop
230        // Bit 6:
231        "out  %[port] , %[hi]"    "\
232\	"  // 1    PORT = hi
233        "mov  %[n1]   , %[lo]"    "\
234\	" // 1    n1   =  lo
235        "out  %[port] , %[n2]"    "\
236\	" // 1    PORT = n2
237        "rjmp  .+0"                "\
238\	" // 2    nop nop
239        "sbrc %[byte] , 5"        "\
240\	" // 1-2  if(b & 0x20)
241         "mov %[n1]   , %[hi]"    "\
242\	"  // 0-1   n1 = hi
243        "out  %[port] , %[lo]"    "\
244\	" // 1    PORT  = lo
245        "rjmp .+0"                "\
246\	" // 2    nop nop
247        //  Bit 5:
248        "out  %[port] , %[hi]"    "\
249\	" // 1    PORT = hi
250        "mov  %[n2]   , %[lo]"    "\
251\	" // 1    n2   = lo
252        "out  %[port] ,  %[n1]"    "\
253\	" // 1    PORT = n1
254        "rjmp .+0"                "\
255\	"  // 2    nop nop
256        "sbrc %[byte] , 4"        "\
257\	" // 1-2  if(b &  0x10)
258         "mov %[n2]   , %[hi]"    "\
259\	" // 0-1   n2 = hi
260        "out  %[port] , %[lo]"    "\
261\	" // 1    PORT = lo
262        "rjmp .+0"                "\
263\	"  // 2    nop nop
264        // Bit 4:
265        "out  %[port] , %[hi]"    "\
266\	"  // 1    PORT = hi
267        "mov  %[n1]   , %[lo]"    "\
268\	" // 1    n1   =  lo
269        "out  %[port] , %[n2]"    "\
270\	" // 1    PORT = n2
271        "rjmp  .+0"                "\
272\	" // 2    nop nop
273        "sbrc %[byte] , 3"        "\
274\	" // 1-2  if(b & 0x08)
275         "mov %[n1]   , %[hi]"    "\
276\	"  // 0-1   n1 = hi
277        "out  %[port] , %[lo]"    "\
278\	" // 1    PORT  = lo
279        "rjmp .+0"                "\
280\	" // 2    nop nop
281        //  Bit 3:
282        "out  %[port] , %[hi]"    "\
283\	" // 1    PORT = hi
284        "mov  %[n2]   , %[lo]"    "\
285\	" // 1    n2   = lo
286        "out  %[port] ,  %[n1]"    "\
287\	" // 1    PORT = n1
288        "rjmp .+0"                "\
289\	"  // 2    nop nop
290        "sbrc %[byte] , 2"        "\
291\	" // 1-2  if(b &  0x04)
292         "mov %[n2]   , %[hi]"    "\
293\	" // 0-1   n2 = hi
294        "out  %[port] , %[lo]"    "\
295\	" // 1    PORT = lo
296        "rjmp .+0"                "\
297\	"  // 2    nop nop
298        // Bit 2:
299        "out  %[port] , %[hi]"    "\
300\	"  // 1    PORT = hi
301        "mov  %[n1]   , %[lo]"    "\
302\	" // 1    n1   =  lo
303        "out  %[port] , %[n2]"    "\
304\	" // 1    PORT = n2
305        "rjmp  .+0"                "\
306\	" // 2    nop nop
307        "sbrc %[byte] , 1"        "\
308\	" // 1-2  if(b & 0x02)
309         "mov %[n1]   , %[hi]"    "\
310\	"  // 0-1   n1 = hi
311        "out  %[port] , %[lo]"    "\
312\	" // 1    PORT  = lo
313        "rjmp .+0"                "\
314\	" // 2    nop nop
315        //  Bit 1:
316        "out  %[port] , %[hi]"    "\
317\	" // 1    PORT = hi
318        "mov  %[n2]   , %[lo]"    "\
319\	" // 1    n2   = lo
320        "out  %[port] ,  %[n1]"    "\
321\	" // 1    PORT = n1
322        "rjmp .+0"                "\
323\	"  // 2    nop nop
324        "sbrc %[byte] , 0"        "\
325\	" // 1-2  if(b &  0x01)
326         "mov %[n2]   , %[hi]"    "\
327\	" // 0-1   n2 = hi
328        "out  %[port] , %[lo]"    "\
329\	" // 1    PORT = lo
330        "sbiw %[count],  1"        "\
331\	" // 2    i-- (don't act on Z flag yet)
332        // Bit 0:
333        "out  %[port] , %[hi]"    "\
334\	" // 1    PORT = hi
335        "mov  %[n1]   , %[lo]"    "\
336\	" // 1    n1   = lo
337        "out  %[port] ,  %[n2]"    "\
338\	" // 1    PORT = n2
339        "ld   %[byte] , %a[ptr]+" "\
340\	"  // 2    b = *ptr++
341        "sbrc %[byte] , 7"        "\
342\	" // 1-2  if(b  & 0x80)
343         "mov %[n1]   , %[hi]"    "\
344\	" // 0-1   n1 = hi
345        "out  %[port] , %[lo]"    "\
346\	" // 1    PORT = lo
347        "brne headD"              "\
348"   // 2    while(i) (Z flag set above)
349      : [byte]  "+r" (b),
350        [n1]    "+r" (n1),
351        [n2]    "+r" (n2),
352        [count] "+w" (i)
353      : [port]   "I" (_SFR_IO_ADDR(PORTD)),
354        [ptr]    "e" (ptr),
355        [hi]     "r" (hi),
356        [lo]     "r" (lo));
357
358 #if defined(PORTB)  || defined(PORTC) || defined(PORTF)
359    } else // other PORT(s)
360 #endif //  defined(PORTB/C/F)
361#endif // defined(PORTD)
362
363    // PORTB OUTPUT ----------------------------------------------------
364
365#if  defined(PORTB)
366 #if defined(PORTD) || defined(PORTC) || defined(PORTF)
367    if(port  == &PORTB) {
368 #endif // defined(PORTD/C/F)
369
370      // Same as above, just  switched to PORTB and stripped of comments.
371      hi = PORTB |  pinMask;
372      lo = PORTB & ~pinMask;
373      n1 = lo;
374      if(b & 0x80) n1 = hi;
375
376      asm volatile(
377       "headB:"                   "\
378\	"
379        "out  %[port] , %[hi]"    "\
380\	"
381        "mov  %[n2]   , %[lo]"    "\
382\	"
383        "out  %[port] , %[n1]"    "\
384\	"
385        "rjmp .+0"                "\
386\	"
387        "sbrc %[byte] , 6"        "\
388\	"
389         "mov %[n2]   , %[hi]"    "\
390\	"
391        "out  %[port] , %[lo]"    "\
392\	"
393        "rjmp  .+0"                "\
394\	"
395        "out  %[port] , %[hi]"    "\
396\	"
397        "mov  %[n1]   , %[lo]"    "\
398\	"
399        "out  %[port] , %[n2]"    "\
400\	"
401        "rjmp .+0"                "\
402\	"
403        "sbrc  %[byte] , 5"        "\
404\	"
405         "mov %[n1]   , %[hi]"    "\
406\	"
407        "out  %[port] , %[lo]"    "\
408\	"
409        "rjmp .+0"                "\
410\	"
411        "out  %[port] , %[hi]"    "\
412\	"
413        "mov  %[n2]   , %[lo]"    "\
414\	"
415        "out  %[port] , %[n1]"    "\
416\	"
417        "rjmp  .+0"                "\
418\	"
419        "sbrc %[byte] , 4"        "\
420\	"
421         "mov %[n2]   , %[hi]"    "\
422\	"
423        "out  %[port] , %[lo]"    "\
424\	"
425        "rjmp .+0"                "\
426\	"
427        "out  %[port] , %[hi]"    "\
428\	"
429        "mov  %[n1]   , %[lo]"    "\
430\	"
431        "out  %[port] , %[n2]"    "\
432\	"
433        "rjmp .+0"                "\
434\	"
435        "sbrc %[byte] , 3"        "\
436\	"
437         "mov %[n1]   , %[hi]"    "\
438\	"
439        "out  %[port] , %[lo]"    "\
440\	"
441        "rjmp  .+0"                "\
442\	"
443        "out  %[port] , %[hi]"    "\
444\	"
445        "mov  %[n2]   , %[lo]"    "\
446\	"
447        "out  %[port] , %[n1]"    "\
448\	"
449        "rjmp .+0"                "\
450\	"
451        "sbrc  %[byte] , 2"        "\
452\	"
453         "mov %[n2]   , %[hi]"    "\
454\	"
455        "out  %[port] , %[lo]"    "\
456\	"
457        "rjmp .+0"                "\
458\	"
459        "out  %[port] , %[hi]"    "\
460\	"
461        "mov  %[n1]   , %[lo]"    "\
462\	"
463        "out  %[port] , %[n2]"    "\
464\	"
465        "rjmp  .+0"                "\
466\	"
467        "sbrc %[byte] , 1"        "\
468\	"
469         "mov %[n1]   , %[hi]"    "\
470\	"
471        "out  %[port] , %[lo]"    "\
472\	"
473        "rjmp .+0"                "\
474\	"
475        "out  %[port] , %[hi]"    "\
476\	"
477        "mov  %[n2]   , %[lo]"    "\
478\	"
479        "out  %[port] , %[n1]"    "\
480\	"
481        "rjmp .+0"                "\
482\	"
483        "sbrc %[byte] , 0"        "\
484\	"
485         "mov %[n2]   , %[hi]"    "\
486\	"
487        "out  %[port] , %[lo]"    "\
488\	"
489        "sbiw  %[count], 1"        "\
490\	"
491        "out  %[port] , %[hi]"    "\
492\	"
493        "mov  %[n1]   , %[lo]"    "\
494\	"
495        "out  %[port] , %[n2]"    "\
496\	"
497        "ld   %[byte] , %a[ptr]+" "\
498\	"
499        "sbrc  %[byte] , 7"        "\
500\	"
501         "mov %[n1]   , %[hi]"    "\
502\	"
503        "out  %[port] , %[lo]"    "\
504\	"
505        "brne headB"              "\
506"
507      : [byte] "+r" (b), [n1] "+r" (n1), [n2] "+r" (n2), [count] "+w" (i)
508      : [port] "I" (_SFR_IO_ADDR(PORTB)), [ptr] "e" (ptr), [hi] "r" (hi),
509        [lo] "r" (lo));
510
511 #if defined(PORTD) || defined(PORTC) || defined(PORTF)
512    }
513 #endif
514 #if defined(PORTC) || defined(PORTF)
515    else
516 #endif  // defined(PORTC/F)
517#endif // defined(PORTB)
518
519    // PORTC OUTPUT ----------------------------------------------------
520
521#if  defined(PORTC)
522 #if defined(PORTD) || defined(PORTB) || defined(PORTF)
523    if(port  == &PORTC) {
524 #endif // defined(PORTD/B/F)
525
526      // Same as above, just  switched to PORTC and stripped of comments.
527      hi = PORTC |  pinMask;
528      lo = PORTC & ~pinMask;
529      n1 = lo;
530      if(b & 0x80) n1 = hi;
531
532      asm volatile(
533       "headC:"                   "\
534\	"
535        "out  %[port] , %[hi]"    "\
536\	"
537        "mov  %[n2]   , %[lo]"    "\
538\	"
539        "out  %[port] , %[n1]"    "\
540\	"
541        "rjmp .+0"                "\
542\	"
543        "sbrc %[byte] , 6"        "\
544\	"
545         "mov %[n2]   , %[hi]"    "\
546\	"
547        "out  %[port] , %[lo]"    "\
548\	"
549        "rjmp  .+0"                "\
550\	"
551        "out  %[port] , %[hi]"    "\
552\	"
553        "mov  %[n1]   , %[lo]"    "\
554\	"
555        "out  %[port] , %[n2]"    "\
556\	"
557        "rjmp .+0"                "\
558\	"
559        "sbrc  %[byte] , 5"        "\
560\	"
561         "mov %[n1]   , %[hi]"    "\
562\	"
563        "out  %[port] , %[lo]"    "\
564\	"
565        "rjmp .+0"                "\
566\	"
567        "out  %[port] , %[hi]"    "\
568\	"
569        "mov  %[n2]   , %[lo]"    "\
570\	"
571        "out  %[port] , %[n1]"    "\
572\	"
573        "rjmp  .+0"                "\
574\	"
575        "sbrc %[byte] , 4"        "\
576\	"
577         "mov %[n2]   , %[hi]"    "\
578\	"
579        "out  %[port] , %[lo]"    "\
580\	"
581        "rjmp .+0"                "\
582\	"
583        "out  %[port] , %[hi]"    "\
584\	"
585        "mov  %[n1]   , %[lo]"    "\
586\	"
587        "out  %[port] , %[n2]"    "\
588\	"
589        "rjmp .+0"                "\
590\	"
591        "sbrc %[byte] , 3"        "\
592\	"
593         "mov %[n1]   , %[hi]"    "\
594\	"
595        "out  %[port] , %[lo]"    "\
596\	"
597        "rjmp  .+0"                "\
598\	"
599        "out  %[port] , %[hi]"    "\
600\	"
601        "mov  %[n2]   , %[lo]"    "\
602\	"
603        "out  %[port] , %[n1]"    "\
604\	"
605        "rjmp .+0"                "\
606\	"
607        "sbrc  %[byte] , 2"        "\
608\	"
609         "mov %[n2]   , %[hi]"    "\
610\	"
611        "out  %[port] , %[lo]"    "\
612\	"
613        "rjmp .+0"                "\
614\	"
615        "out  %[port] , %[hi]"    "\
616\	"
617        "mov  %[n1]   , %[lo]"    "\
618\	"
619        "out  %[port] , %[n2]"    "\
620\	"
621        "rjmp  .+0"                "\
622\	"
623        "sbrc %[byte] , 1"        "\
624\	"
625         "mov %[n1]   , %[hi]"    "\
626\	"
627        "out  %[port] , %[lo]"    "\
628\	"
629        "rjmp .+0"                "\
630\	"
631        "out  %[port] , %[hi]"    "\
632\	"
633        "mov  %[n2]   , %[lo]"    "\
634\	"
635        "out  %[port] , %[n1]"    "\
636\	"
637        "rjmp .+0"                "\
638\	"
639        "sbrc %[byte] , 0"        "\
640\	"
641         "mov %[n2]   , %[hi]"    "\
642\	"
643        "out  %[port] , %[lo]"    "\
644\	"
645        "sbiw  %[count], 1"        "\
646\	"
647        "out  %[port] , %[hi]"    "\
648\	"
649        "mov  %[n1]   , %[lo]"    "\
650\	"
651        "out  %[port] , %[n2]"    "\
652\	"
653        "ld   %[byte] , %a[ptr]+" "\
654\	"
655        "sbrc  %[byte] , 7"        "\
656\	"
657         "mov %[n1]   , %[hi]"    "\
658\	"
659        "out  %[port] , %[lo]"    "\
660\	"
661        "brne headC"              "\
662"
663      : [byte] "+r" (b), [n1] "+r" (n1), [n2] "+r" (n2), [count] "+w" (i)
664      : [port] "I" (_SFR_IO_ADDR(PORTC)), [ptr] "e" (ptr), [hi] "r" (hi),
665        [lo] "r" (lo));
666
667 #if defined(PORTD) || defined(PORTB) || defined(PORTF)
668    }
669 #endif // defined(PORTD/B/F)
670 #if defined(PORTF)
671    else
672 #endif
673#endif  // defined(PORTC)
674
675    // PORTF OUTPUT ----------------------------------------------------
676
677#if  defined(PORTF)
678 #if defined(PORTD) || defined(PORTB) || defined(PORTC)
679    if(port  == &PORTF) {
680 #endif // defined(PORTD/B/C)
681
682      hi = PORTF |  pinMask;
683      lo = PORTF & ~pinMask;
684      n1 = lo;
685      if(b & 0x80) n1 = hi;
686
687      asm volatile(
688       "headF:"                   "\
689\	"
690        "out  %[port] , %[hi]"    "\
691\	"
692        "mov  %[n2]   , %[lo]"    "\
693\	"
694        "out  %[port] , %[n1]"    "\
695\	"
696        "rjmp .+0"                "\
697\	"
698        "sbrc %[byte] , 6"        "\
699\	"
700         "mov %[n2]   , %[hi]"    "\
701\	"
702        "out  %[port] , %[lo]"    "\
703\	"
704        "rjmp  .+0"                "\
705\	"
706        "out  %[port] , %[hi]"    "\
707\	"
708        "mov  %[n1]   , %[lo]"    "\
709\	"
710        "out  %[port] , %[n2]"    "\
711\	"
712        "rjmp .+0"                "\
713\	"
714        "sbrc  %[byte] , 5"        "\
715\	"
716         "mov %[n1]   , %[hi]"    "\
717\	"
718        "out  %[port] , %[lo]"    "\
719\	"
720        "rjmp .+0"                "\
721\	"
722        "out  %[port] , %[hi]"    "\
723\	"
724        "mov  %[n2]   , %[lo]"    "\
725\	"
726        "out  %[port] , %[n1]"    "\
727\	"
728        "rjmp  .+0"                "\
729\	"
730        "sbrc %[byte] , 4"        "\
731\	"
732         "mov %[n2]   , %[hi]"    "\
733\	"
734        "out  %[port] , %[lo]"    "\
735\	"
736        "rjmp .+0"                "\
737\	"
738        "out  %[port] , %[hi]"    "\
739\	"
740        "mov  %[n1]   , %[lo]"    "\
741\	"
742        "out  %[port] , %[n2]"    "\
743\	"
744        "rjmp .+0"                "\
745\	"
746        "sbrc %[byte] , 3"        "\
747\	"
748         "mov %[n1]   , %[hi]"    "\
749\	"
750        "out  %[port] , %[lo]"    "\
751\	"
752        "rjmp  .+0"                "\
753\	"
754        "out  %[port] , %[hi]"    "\
755\	"
756        "mov  %[n2]   , %[lo]"    "\
757\	"
758        "out  %[port] , %[n1]"    "\
759\	"
760        "rjmp .+0"                "\
761\	"
762        "sbrc  %[byte] , 2"        "\
763\	"
764         "mov %[n2]   , %[hi]"    "\
765\	"
766        "out  %[port] , %[lo]"    "\
767\	"
768        "rjmp .+0"                "\
769\	"
770        "out  %[port] , %[hi]"    "\
771\	"
772        "mov  %[n1]   , %[lo]"    "\
773\	"
774        "out  %[port] , %[n2]"    "\
775\	"
776        "rjmp  .+0"                "\
777\	"
778        "sbrc %[byte] , 1"        "\
779\	"
780         "mov %[n1]   , %[hi]"    "\
781\	"
782        "out  %[port] , %[lo]"    "\
783\	"
784        "rjmp .+0"                "\
785\	"
786        "out  %[port] , %[hi]"    "\
787\	"
788        "mov  %[n2]   , %[lo]"    "\
789\	"
790        "out  %[port] , %[n1]"    "\
791\	"
792        "rjmp .+0"                "\
793\	"
794        "sbrc %[byte] , 0"        "\
795\	"
796         "mov %[n2]   , %[hi]"    "\
797\	"
798        "out  %[port] , %[lo]"    "\
799\	"
800        "sbiw  %[count], 1"        "\
801\	"
802        "out  %[port] , %[hi]"    "\
803\	"
804        "mov  %[n1]   , %[lo]"    "\
805\	"
806        "out  %[port] , %[n2]"    "\
807\	"
808        "ld   %[byte] , %a[ptr]+" "\
809\	"
810        "sbrc  %[byte] , 7"        "\
811\	"
812         "mov %[n1]   , %[hi]"    "\
813\	"
814        "out  %[port] , %[lo]"    "\
815\	"
816        "brne headF"              "\
817"
818      : [byte] "+r" (b), [n1] "+r" (n1), [n2] "+r" (n2), [count] "+w" (i)
819      : [port] "I" (_SFR_IO_ADDR(PORTF)), [ptr] "e" (ptr), [hi] "r" (hi),
820        [lo] "r" (lo));
821
822 #if defined(PORTD) || defined(PORTB) || defined(PORTC)
823    }
824 #endif // defined(PORTD/B/C)
825#endif // defined(PORTF)
826
827#ifdef  NEO_KHZ400
828  } else { // end 800 KHz, do 400 KHz
829
830    // Timing is more  relaxed; unrolling the inner loop for each bit is
831    // not necessary.  Still  using the peculiar RJMPs as 2X NOPs, not out
832    // of need but just to trim  the code size down a little.
833    // This 400-KHz-datastream-on-8-MHz-CPU code  is not quite identical
834    // to the 800-on-16 code later -- the hi/lo timing  between WS2811 and
835    // WS2812 is not simply a 2:1 scale!
836
837    // 20  inst. clocks per bit: HHHHxxxxxxLLLLLLLLLL
838    // ST instructions:         ^   ^     ^          (T=0,4,10)
839
840    volatile uint8_t next, bit;
841
842    hi   = *port |  pinMask;
843    lo   = *port & ~pinMask;
844    next = lo;
845    bit  = 8;
846
847    asm volatile(
848     "head20:"                  "\
849\	"  // Clk  Pseudocode    (T =  0)
850      "st   %a[port], %[hi]"    "\
851\	" //  2    PORT = hi     (T =  2)
852      "sbrc %[byte] , 7"        "\
853\	" // 1-2  if(b & 128)
854       "mov  %[next], %[hi]"    "\
855\	" // 0-1   next = hi    (T =  4)
856      "st   %a[port], %[next]"  "\
857\	" // 2    PORT = next   (T =  6)
858      "mov  %[next] , %[lo]"    "\
859\	" // 1    next = lo     (T  =  7)
860      "dec  %[bit]"             "\
861\	" // 1    bit--         (T =  8)
862      "breq nextbyte20"         "\
863\	" // 1-2  if(bit == 0)
864      "rol  %[byte]"            "\
865\	" // 1    b <<= 1       (T = 10)
866      "st   %a[port],  %[lo]"    "\
867\	" // 2    PORT = lo     (T = 12)
868      "rjmp .+0"                "\
869\	"  // 2    nop nop       (T = 14)
870      "rjmp .+0"                "\
871\	" //  2    nop nop       (T = 16)
872      "rjmp .+0"                "\
873\	" // 2    nop nop       (T = 18)
874      "rjmp head20"             "\
875\	" // 2    -> head20 (next bit out)
876     "nextbyte20:"              "\
877\	" //                    (T = 10)
878      "st   %a[port], %[lo]"    "\
879\	" //  2    PORT = lo     (T = 12)
880      "nop"                     "\
881\	" // 1    nop           (T = 13)
882      "ldi  %[bit]  , 8"        "\
883\	" // 1    bit = 8       (T = 14)
884      "ld   %[byte] , %a[ptr]+" "\
885\	" // 2    b = *ptr++    (T = 16)
886      "sbiw %[count], 1"        "\
887\	" // 2    i--           (T = 18)
888      "brne head20"             "\
889"   // 2    if(i  != 0) -> (next byte)
890      : [port]  "+e" (port),
891        [byte]  "+r"  (b),
892        [bit]   "+r" (bit),
893        [next]  "+r" (next),
894        [count]  "+w" (i)
895      : [hi]    "r" (hi),
896        [lo]    "r" (lo),
897        [ptr]   "e" (ptr));
898  }
899#endif // NEO_KHZ400
900
901// 12 MHz(ish) AVR --------------------------------------------------------
902#elif  (F_CPU >= 11100000UL) && (F_CPU <= 14300000UL)
903
904#ifdef NEO_KHZ400 // 800 KHz  check needed only if 400 KHz support enabled
905  if(is800KHz) {
906#endif
907
908    // In the 12 MHz case, an optimized 800 KHz datastream (no dead time
909    //  between bytes) requires a PORT-specific loop similar to the 8 MHz
910    // code  (but a little more relaxed in this case).
911
912    // 15 instruction clocks per  bit: HHHHxxxxxxLLLLL
913    // OUT instructions:              ^   ^     ^     (T=0,4,10)
914
915    volatile uint8_t next;
916
917    // PORTD OUTPUT ----------------------------------------------------
918
919#if  defined(PORTD)
920 #if defined(PORTB) || defined(PORTC) || defined(PORTF)
921    if(port  == &PORTD) {
922 #endif // defined(PORTB/C/F)
923
924      hi   = PORTD |  pinMask;
925      lo   = PORTD & ~pinMask;
926      next = lo;
927      if(b & 0x80) next =  hi;
928
929      // Don't "optimize" the OUT calls into the bitTime subroutine;
930      // we're exploiting the RCALL and RET as 3- and 4-cycle NOPs!
931      asm  volatile(
932       "headD:"                   "\
933\	" //        (T =  0)
934        "out   %[port], %[hi]"    "\
935\	" //        (T =  1)
936        "rcall  bitTimeD"          "\
937\	" // Bit 7  (T = 15)
938        "out   %[port], %[hi]"    "\
939\	"
940        "rcall bitTimeD"          "\
941\	" // Bit 6
942        "out   %[port], %[hi]"    "\
943\	"
944        "rcall bitTimeD"          "\
945\	"  // Bit 5
946        "out   %[port], %[hi]"    "\
947\	"
948        "rcall bitTimeD"          "\
949\	" // Bit 4
950        "out   %[port], %[hi]"    "\
951\	"
952        "rcall bitTimeD"          "\
953\	" // Bit 3
954        "out   %[port],  %[hi]"    "\
955\	"
956        "rcall bitTimeD"          "\
957\	" // Bit 2
958        "out   %[port], %[hi]"    "\
959\	"
960        "rcall bitTimeD"          "\
961\	"  // Bit 1
962        // Bit 0:
963        "out  %[port] , %[hi]"    "\
964\	"  // 1    PORT = hi    (T =  1)
965        "rjmp .+0"                "\
966\	"  // 2    nop nop      (T =  3)
967        "ld   %[byte] , %a[ptr]+" "\
968\	"  // 2    b = *ptr++   (T =  5)
969        "out  %[port] , %[next]"  "\
970\	"  // 1    PORT = next  (T =  6)
971        "mov  %[next] , %[lo]"    "\
972\	"  // 1    next = lo    (T =  7)
973        "sbrc %[byte] , 7"        "\
974\	"  // 1-2  if(b & 0x80) (T =  8)
975         "mov %[next] , %[hi]"    "\
976\	"  // 0-1    next = hi  (T =  9)
977        "nop"                     "\
978\	"  // 1                 (T = 10)
979        "out  %[port] , %[lo]"    "\
980\	"  // 1    PORT = lo    (T = 11)
981        "sbiw %[count], 1"        "\
982\	"  // 2    i--          (T = 13)
983        "brne headD"              "\
984\	"  // 2    if(i != 0) -> (next byte)
985         "rjmp doneD"             "\
986\	"
987        "bitTimeD:"               "\
988\	" //      nop nop nop     (T =  4)
989         "out  %[port], %[next]"  "\
990\	" // 1    PORT = next     (T =  5)
991         "mov  %[next], %[lo]"    "\
992\	" // 1    next = lo       (T =  6)
993         "rol  %[byte]"           "\
994\	" // 1    b <<= 1         (T =  7)
995         "sbrc %[byte], 7"        "\
996\	" // 1-2  if(b & 0x80)    (T =  8)
997          "mov %[next], %[hi]"    "\
998\	" // 0-1   next = hi      (T =  9)
999         "nop"                    "\
1000\	" // 1                    (T = 10)
1001         "out  %[port], %[lo]"    "\
1002\	" // 1    PORT = lo       (T = 11)
1003         "ret"                    "\
1004\	" // 4    nop nop nop nop (T = 15)
1005         "doneD:"                 "\
1006"
1007        : [byte]  "+r" (b),
1008          [next]  "+r" (next),
1009          [count] "+w" (i)
1010        : [port]   "I" (_SFR_IO_ADDR(PORTD)),
1011          [ptr]    "e" (ptr),
1012          [hi]     "r" (hi),
1013          [lo]     "r" (lo));
1014
1015 #if defined(PORTB) ||  defined(PORTC) || defined(PORTF)
1016    } else // other PORT(s)
1017 #endif // defined(PORTB/C/F)
1018#endif  // defined(PORTD)
1019
1020    // PORTB OUTPUT ----------------------------------------------------
1021
1022#if  defined(PORTB)
1023 #if defined(PORTD) || defined(PORTC) || defined(PORTF)
1024    if(port  == &PORTB) {
1025 #endif // defined(PORTD/C/F)
1026
1027      hi   = PORTB |  pinMask;
1028      lo   = PORTB & ~pinMask;
1029      next = lo;
1030      if(b & 0x80) next =  hi;
1031
1032      // Same as above, just set for PORTB & stripped of comments
1033      asm volatile(
1034       "headB:"                   "\
1035\	"
1036        "out   %[port], %[hi]"    "\
1037\	"
1038        "rcall bitTimeB"          "\
1039\	"
1040        "out   %[port], %[hi]"    "\
1041\	"
1042        "rcall bitTimeB"          "\
1043\	"
1044        "out   %[port], %[hi]"    "\
1045\	"
1046        "rcall bitTimeB"          "\
1047\	"
1048        "out   %[port], %[hi]"    "\
1049\	"
1050        "rcall bitTimeB"          "\
1051\	"
1052        "out   %[port], %[hi]"    "\
1053\	"
1054        "rcall bitTimeB"          "\
1055\	"
1056        "out   %[port], %[hi]"    "\
1057\	"
1058        "rcall bitTimeB"          "\
1059\	"
1060        "out   %[port], %[hi]"    "\
1061\	"
1062        "rcall bitTimeB"          "\
1063\	"
1064        "out  %[port] , %[hi]"    "\
1065\	"
1066        "rjmp .+0"                "\
1067\	"
1068        "ld   %[byte] , %a[ptr]+" "\
1069\	"
1070        "out  %[port] , %[next]"  "\
1071\	"
1072        "mov  %[next] , %[lo]"    "\
1073\	"
1074        "sbrc  %[byte] , 7"        "\
1075\	"
1076         "mov %[next] , %[hi]"    "\
1077\	"
1078        "nop"                     "\
1079\	"
1080        "out  %[port] , %[lo]"    "\
1081\	"
1082        "sbiw %[count], 1"        "\
1083\	"
1084        "brne  headB"              "\
1085\	"
1086         "rjmp doneB"             "\
1087\	"
1088        "bitTimeB:"               "\
1089\	"
1090         "out  %[port], %[next]"  "\
1091\	"
1092         "mov  %[next], %[lo]"    "\
1093\	"
1094         "rol  %[byte]"           "\
1095\	"
1096         "sbrc %[byte], 7"        "\
1097\	"
1098          "mov %[next], %[hi]"    "\
1099\	"
1100         "nop"                    "\
1101\	"
1102         "out  %[port], %[lo]"    "\
1103\	"
1104         "ret"                    "\
1105\	"
1106         "doneB:"                 "\
1107"
1108        : [byte] "+r" (b), [next]  "+r" (next), [count] "+w" (i)
1109        : [port] "I" (_SFR_IO_ADDR(PORTB)),  [ptr] "e" (ptr), [hi] "r" (hi),
1110          [lo] "r" (lo));
1111
1112 #if defined(PORTD)  || defined(PORTC) || defined(PORTF)
1113    }
1114 #endif
1115 #if defined(PORTC) ||  defined(PORTF)
1116    else
1117 #endif // defined(PORTC/F)
1118#endif // defined(PORTB)
1119
1120    // PORTC OUTPUT ----------------------------------------------------
1121
1122#if  defined(PORTC)
1123 #if defined(PORTD) || defined(PORTB) || defined(PORTF)
1124    if(port  == &PORTC) {
1125 #endif // defined(PORTD/B/F)
1126
1127      hi   = PORTC |  pinMask;
1128      lo   = PORTC & ~pinMask;
1129      next = lo;
1130      if(b & 0x80) next =  hi;
1131
1132      // Same as above, just set for PORTC & stripped of comments
1133      asm volatile(
1134       "headC:"                   "\
1135\	"
1136        "out   %[port], %[hi]"    "\
1137\	"
1138        "rcall bitTimeC"          "\
1139\	"
1140        "out   %[port], %[hi]"    "\
1141\	"
1142        "rcall bitTimeC"          "\
1143\	"
1144        "out   %[port], %[hi]"    "\
1145\	"
1146        "rcall bitTimeC"          "\
1147\	"
1148        "out   %[port], %[hi]"    "\
1149\	"
1150        "rcall bitTimeC"          "\
1151\	"
1152        "out   %[port], %[hi]"    "\
1153\	"
1154        "rcall bitTimeC"          "\
1155\	"
1156        "out   %[port], %[hi]"    "\
1157\	"
1158        "rcall bitTimeC"          "\
1159\	"
1160        "out   %[port], %[hi]"    "\
1161\	"
1162        "rcall bitTimeC"          "\
1163\	"
1164        "out  %[port] , %[hi]"    "\
1165\	"
1166        "rjmp .+0"                "\
1167\	"
1168        "ld   %[byte] , %a[ptr]+" "\
1169\	"
1170        "out  %[port] , %[next]"  "\
1171\	"
1172        "mov  %[next] , %[lo]"    "\
1173\	"
1174        "sbrc  %[byte] , 7"        "\
1175\	"
1176         "mov %[next] , %[hi]"    "\
1177\	"
1178        "nop"                     "\
1179\	"
1180        "out  %[port] , %[lo]"    "\
1181\	"
1182        "sbiw %[count], 1"        "\
1183\	"
1184        "brne  headC"              "\
1185\	"
1186         "rjmp doneC"             "\
1187\	"
1188        "bitTimeC:"               "\
1189\	"
1190         "out  %[port], %[next]"  "\
1191\	"
1192         "mov  %[next], %[lo]"    "\
1193\	"
1194         "rol  %[byte]"           "\
1195\	"
1196         "sbrc %[byte], 7"        "\
1197\	"
1198          "mov %[next], %[hi]"    "\
1199\	"
1200         "nop"                    "\
1201\	"
1202         "out  %[port], %[lo]"    "\
1203\	"
1204         "ret"                    "\
1205\	"
1206         "doneC:"                 "\
1207"
1208        : [byte] "+r" (b), [next]  "+r" (next), [count] "+w" (i)
1209        : [port] "I" (_SFR_IO_ADDR(PORTC)),  [ptr] "e" (ptr), [hi] "r" (hi),
1210          [lo] "r" (lo));
1211
1212 #if defined(PORTD)  || defined(PORTB) || defined(PORTF)
1213    }
1214 #endif // defined(PORTD/B/F)
1215  #if defined(PORTF)
1216    else
1217 #endif
1218#endif // defined(PORTC)
1219
1220    //  PORTF OUTPUT ----------------------------------------------------
1221
1222#if defined(PORTF)
1223  #if defined(PORTD) || defined(PORTB) || defined(PORTC)
1224    if(port == &PORTF)  {
1225 #endif // defined(PORTD/B/C)
1226
1227      hi   = PORTF |  pinMask;
1228      lo   = PORTF & ~pinMask;
1229      next = lo;
1230      if(b & 0x80) next = hi;
1231
1232      // Same as above, just set for PORTF & stripped of comments
1233      asm volatile(
1234       "headF:"                   "\
1235\	"
1236        "out   %[port], %[hi]"    "\
1237\	"
1238        "rcall bitTimeC"          "\
1239\	"
1240        "out   %[port], %[hi]"    "\
1241\	"
1242        "rcall bitTimeC"          "\
1243\	"
1244        "out   %[port], %[hi]"    "\
1245\	"
1246        "rcall bitTimeC"          "\
1247\	"
1248        "out   %[port], %[hi]"    "\
1249\	"
1250        "rcall bitTimeC"          "\
1251\	"
1252        "out   %[port], %[hi]"    "\
1253\	"
1254        "rcall bitTimeC"          "\
1255\	"
1256        "out   %[port], %[hi]"    "\
1257\	"
1258        "rcall bitTimeC"          "\
1259\	"
1260        "out   %[port], %[hi]"    "\
1261\	"
1262        "rcall bitTimeC"          "\
1263\	"
1264        "out  %[port] , %[hi]"    "\
1265\	"
1266        "rjmp .+0"                "\
1267\	"
1268        "ld   %[byte] , %a[ptr]+" "\
1269\	"
1270        "out  %[port] , %[next]"  "\
1271\	"
1272        "mov  %[next] , %[lo]"    "\
1273\	"
1274        "sbrc  %[byte] , 7"        "\
1275\	"
1276         "mov %[next] , %[hi]"    "\
1277\	"
1278        "nop"                     "\
1279\	"
1280        "out  %[port] , %[lo]"    "\
1281\	"
1282        "sbiw %[count], 1"        "\
1283\	"
1284        "brne  headF"              "\
1285\	"
1286         "rjmp doneC"             "\
1287\	"
1288        "bitTimeC:"               "\
1289\	"
1290         "out  %[port], %[next]"  "\
1291\	"
1292         "mov  %[next], %[lo]"    "\
1293\	"
1294         "rol  %[byte]"           "\
1295\	"
1296         "sbrc %[byte], 7"        "\
1297\	"
1298          "mov %[next], %[hi]"    "\
1299\	"
1300         "nop"                    "\
1301\	"
1302         "out  %[port], %[lo]"    "\
1303\	"
1304         "ret"                    "\
1305\	"
1306         "doneC:"                 "\
1307"
1308        : [byte] "+r" (b), [next]  "+r" (next), [count] "+w" (i)
1309        : [port] "I" (_SFR_IO_ADDR(PORTF)),  [ptr] "e" (ptr), [hi] "r" (hi),
1310          [lo] "r" (lo));
1311
1312 #if defined(PORTD)  || defined(PORTB) || defined(PORTC)
1313    }
1314 #endif // defined(PORTD/B/C)
1315#endif  // defined(PORTF)
1316
1317#ifdef NEO_KHZ400
1318  } else { // 400 KHz
1319
1320    //  30 instruction clocks per bit: HHHHHHxxxxxxxxxLLLLLLLLLLLLLLL
1321    // ST instructions:               ^     ^        ^    (T=0,6,15)
1322
1323    volatile uint8_t next,  bit;
1324
1325    hi   = *port |  pinMask;
1326    lo   = *port & ~pinMask;
1327    next  = lo;
1328    bit  = 8;
1329
1330    asm volatile(
1331     "head30:"                  "\
1332\	"  // Clk  Pseudocode    (T =  0)
1333      "st   %a[port], %[hi]"    "\
1334\	" //  2    PORT = hi     (T =  2)
1335      "sbrc %[byte] , 7"        "\
1336\	" // 1-2  if(b & 128)
1337       "mov  %[next], %[hi]"    "\
1338\	" // 0-1   next = hi    (T =  4)
1339      "rjmp .+0"                "\
1340\	" // 2    nop nop       (T  =  6)
1341      "st   %a[port], %[next]"  "\
1342\	" // 2    PORT = next   (T =  8)
1343      "rjmp .+0"                "\
1344\	" // 2    nop nop       (T =  10)
1345      "rjmp .+0"                "\
1346\	" // 2    nop nop       (T = 12)
1347      "rjmp .+0"                "\
1348\	" // 2    nop nop       (T = 14)
1349      "nop"                     "\
1350\	" // 1    nop           (T = 15)
1351      "st   %a[port], %[lo]"    "\
1352\	" // 2    PORT = lo     (T = 17)
1353      "rjmp .+0"                "\
1354\	" // 2    nop nop       (T = 19)
1355      "dec  %[bit]"             "\
1356\	" // 1    bit--         (T = 20)
1357      "breq nextbyte30"         "\
1358\	" // 1-2  if(bit == 0)
1359      "rol  %[byte]"            "\
1360\	" // 1    b <<= 1       (T = 22)
1361      "rjmp  .+0"                "\
1362\	" // 2    nop nop       (T = 24)
1363      "rjmp .+0"                "\
1364\	" // 2    nop nop       (T = 26)
1365      "rjmp .+0"                "\
1366\	" // 2    nop nop       (T = 28)
1367      "rjmp head30"             "\
1368\	" // 2    -> head30 (next bit out)
1369     "nextbyte30:"              "\
1370\	" //                    (T = 22)
1371      "nop"                     "\
1372\	"  // 1    nop           (T = 23)
1373      "ldi  %[bit]  , 8"        "\
1374\	" //  1    bit = 8       (T = 24)
1375      "ld   %[byte] , %a[ptr]+" "\
1376\	" // 2    b = *ptr++    (T = 26)
1377      "sbiw %[count], 1"        "\
1378\	" // 2    i--           (T = 28)
1379      "brne head30"             "\
1380"   // 1-2  if(i != 0) -> (next byte)
1381      : [port]  "+e" (port),
1382        [byte]  "+r" (b),
1383        [bit]   "+r" (bit),
1384        [next]  "+r" (next),
1385        [count] "+w" (i)
1386      : [hi]     "r" (hi),
1387        [lo]     "r"  (lo),
1388        [ptr]    "e" (ptr));
1389  }
1390#endif // NEO_KHZ400
1391
1392//  16 MHz(ish) AVR --------------------------------------------------------
1393#elif  (F_CPU >= 15400000UL) && (F_CPU <= 19000000L)
1394
1395#ifdef NEO_KHZ400 // 800 KHz  check needed only if 400 KHz support enabled
1396  if(is800KHz) {
1397#endif
1398
1399    // WS2811 and WS2812 have different hi/lo duty cycles; this is
1400    // similar  but NOT an exact copy of the prior 400-on-8 code.
1401
1402    // 20 inst. clocks  per bit: HHHHHxxxxxxxxLLLLLLL
1403    // ST instructions:         ^   ^        ^       (T=0,5,13)
1404
1405    volatile uint8_t next, bit;
1406
1407    hi   = *port  |  pinMask;
1408    lo   = *port & ~pinMask;
1409    next = lo;
1410    bit  = 8;
1411
1412    asm volatile(
1413     "head20:"                   "\
1414\	" // Clk  Pseudocode    (T =  0)
1415      "st   %a[port],  %[hi]"    "\
1416\	" // 2    PORT = hi     (T =  2)
1417      "sbrc %[byte],  7"         "\
1418\	" // 1-2  if(b & 128)
1419       "mov  %[next], %[hi]"     "\
1420\	" // 0-1   next = hi    (T =  4)
1421      "dec  %[bit]"              "\
1422\	" // 1    bit--         (T =  5)
1423      "st   %a[port],  %[next]"  "\
1424\	" // 2    PORT = next   (T =  7)
1425      "mov  %[next] ,  %[lo]"    "\
1426\	" // 1    next = lo     (T =  8)
1427      "breq nextbyte20"          "\
1428\	" // 1-2  if(bit == 0) (from dec above)
1429      "rol  %[byte]"             "\
1430\	" // 1    b <<= 1       (T = 10)
1431      "rjmp .+0"                 "\
1432\	" // 2    nop nop       (T = 12)
1433      "nop"                      "\
1434\	" // 1    nop           (T = 13)
1435      "st   %a[port],  %[lo]"    "\
1436\	" // 2    PORT = lo     (T = 15)
1437      "nop"                      "\
1438\	" // 1    nop           (T = 16)
1439      "rjmp .+0"                 "\
1440\	" // 2    nop nop       (T = 18)
1441      "rjmp head20"              "\
1442\	" // 2    -> head20 (next bit out)
1443     "nextbyte20:"               "\
1444\	" //                    (T = 10)
1445      "ldi  %[bit]  ,  8"        "\
1446\	" // 1    bit = 8       (T = 11)
1447      "ld   %[byte] ,  %a[ptr]+" "\
1448\	" // 2    b = *ptr++    (T = 13)
1449      "st   %a[port], %[lo]"     "\
1450\	" // 2    PORT = lo     (T = 15)
1451      "nop"                      "\
1452\	" // 1    nop           (T = 16)
1453      "sbiw %[count], 1"         "\
1454\	" // 2    i--           (T = 18)
1455       "brne head20"             "\
1456"   // 2    if(i != 0) -> (next byte)
1457      : [port]  "+e" (port),
1458        [byte]  "+r" (b),
1459        [bit]   "+r"  (bit),
1460        [next]  "+r" (next),
1461        [count] "+w" (i)
1462      :  [ptr]    "e" (ptr),
1463        [hi]     "r" (hi),
1464        [lo]     "r"  (lo));
1465
1466#ifdef NEO_KHZ400
1467  } else { // 400 KHz
1468
1469    // The 400 KHz  clock on 16 MHz MCU is the most 'relaxed' version.
1470
1471    // 40 inst. clocks  per bit: HHHHHHHHxxxxxxxxxxxxLLLLLLLLLLLLLLLLLLLL
1472    // ST instructions:         ^       ^           ^         (T=0,8,20)
1473
1474    volatile uint8_t next, bit;
1475
1476    hi   = *port |  pinMask;
1477    lo   = *port & ~pinMask;
1478    next = lo;
1479    bit  = 8;
1480
1481    asm volatile(
1482     "head40:"                  "\
1483\	"  // Clk  Pseudocode    (T =  0)
1484      "st   %a[port], %[hi]"    "\
1485\	" //  2    PORT = hi     (T =  2)
1486      "sbrc %[byte] , 7"        "\
1487\	" // 1-2  if(b & 128)
1488       "mov  %[next] , %[hi]"   "\
1489\	" // 0-1   next = hi    (T =  4)
1490      "rjmp .+0"                "\
1491\	" // 2    nop nop       (T  =  6)
1492      "rjmp .+0"                "\
1493\	" // 2    nop nop       (T =  8)
1494      "st   %a[port], %[next]"  "\
1495\	" // 2    PORT = next   (T =  10)
1496      "rjmp .+0"                "\
1497\	" // 2    nop nop       (T = 12)
1498      "rjmp .+0"                "\
1499\	" // 2    nop nop       (T = 14)
1500      "rjmp .+0"                "\
1501\	" // 2    nop nop       (T = 16)
1502      "rjmp .+0"                "\
1503\	" // 2    nop nop       (T = 18)
1504      "rjmp .+0"                "\
1505\	" // 2    nop nop       (T = 20)
1506      "st   %a[port], %[lo]"    "\
1507\	" // 2    PORT = lo     (T = 22)
1508      "nop"                     "\
1509\	" // 1    nop           (T = 23)
1510      "mov  %[next] , %[lo]"    "\
1511\	" // 1    next = lo     (T = 24)
1512      "dec  %[bit]"             "\
1513\	" // 1    bit--         (T = 25)
1514      "breq nextbyte40"         "\
1515\	" // 1-2  if(bit == 0)
1516      "rol  %[byte]"            "\
1517\	" // 1    b <<= 1       (T = 27)
1518      "nop"                     "\
1519\	" // 1    nop           (T = 28)
1520      "rjmp .+0"                "\
1521\	" // 2    nop nop       (T = 30)
1522      "rjmp .+0"                "\
1523\	" // 2    nop nop       (T = 32)
1524      "rjmp .+0"                "\
1525\	" // 2    nop nop       (T = 34)
1526      "rjmp .+0"                "\
1527\	" // 2    nop nop       (T = 36)
1528      "rjmp .+0"                "\
1529\	" // 2    nop nop       (T = 38)
1530      "rjmp head40"             "\
1531\	" // 2    -> head40 (next bit out)
1532     "nextbyte40:"              "\
1533\	" //                    (T = 27)
1534      "ldi  %[bit]  ,  8"        "\
1535\	" // 1    bit = 8       (T = 28)
1536      "ld   %[byte] , %a[ptr]+"  "\
1537\	" // 2    b = *ptr++    (T = 30)
1538      "rjmp .+0"                "\
1539\	"  // 2    nop nop       (T = 32)
1540      "st   %a[port], %[lo]"    "\
1541\	" //  2    PORT = lo     (T = 34)
1542      "rjmp .+0"                "\
1543\	" // 2    nop nop       (T = 36)
1544      "sbiw %[count], 1"        "\
1545\	" // 2    i--           (T = 38)
1546      "brne head40"             "\
1547"   // 1-2  if(i != 0) -> (next byte)
1548      : [port]  "+e" (port),
1549        [byte]  "+r" (b),
1550        [bit]   "+r" (bit),
1551        [next]  "+r" (next),
1552        [count] "+w" (i)
1553      : [ptr]    "e" (ptr),
1554        [hi]     "r"  (hi),
1555        [lo]     "r" (lo));
1556  }
1557#endif // NEO_KHZ400
1558
1559#else
1560  #error "CPU SPEED NOT SUPPORTED"
1561#endif // end F_CPU ifdefs on __AVR__
1562
1563//  END AVR ----------------------------------------------------------------
1564
1565
1566#elif  defined(__arm__)
1567
1568// ARM MCUs -- Teensy 3.0, 3.1, LC, Arduino Due ---------------------------
1569
1570#if  defined(TEENSYDUINO) && defined(KINETISK) // Teensy 3.0, 3.1, 3.2, 3.5, 3.6
1571#define  CYCLES_800_T0H  (F_CPU / 4000000)
1572#define CYCLES_800_T1H  (F_CPU / 1250000)
1573#define  CYCLES_800      (F_CPU /  800000)
1574#define CYCLES_400_T0H  (F_CPU / 2000000)
1575#define  CYCLES_400_T1H  (F_CPU /  833333)
1576#define CYCLES_400      (F_CPU /  400000)
1577
1578  uint8_t          *p   = pixels,
1579                   *end = p + numBytes, pix,  mask;
1580  volatile uint8_t *set = portSetRegister(pin),
1581                   *clr  = portClearRegister(pin);
1582  uint32_t          cyc;
1583
1584  ARM_DEMCR    |= ARM_DEMCR_TRCENA;
1585  ARM_DWT_CTRL |= ARM_DWT_CTRL_CYCCNTENA;
1586
1587#ifdef NEO_KHZ400 // 800 KHz check  needed only if 400 KHz support enabled
1588  if(is800KHz) {
1589#endif
1590    cyc  = ARM_DWT_CYCCNT + CYCLES_800;
1591    while(p < end) {
1592      pix = *p++;
1593      for(mask = 0x80; mask; mask >>= 1) {
1594        while(ARM_DWT_CYCCNT - cyc  < CYCLES_800);
1595        cyc  = ARM_DWT_CYCCNT;
1596        *set = 1;
1597        if(pix  & mask) {
1598          while(ARM_DWT_CYCCNT - cyc < CYCLES_800_T1H);
1599        }  else {
1600          while(ARM_DWT_CYCCNT - cyc < CYCLES_800_T0H);
1601        }
1602        *clr = 1;
1603      }
1604    }
1605    while(ARM_DWT_CYCCNT - cyc < CYCLES_800);
1606#ifdef  NEO_KHZ400
1607  } else { // 400 kHz bitstream
1608    cyc = ARM_DWT_CYCCNT + CYCLES_400;
1609    while(p < end) {
1610      pix = *p++;
1611      for(mask = 0x80; mask; mask >>=  1) {
1612        while(ARM_DWT_CYCCNT - cyc < CYCLES_400);
1613        cyc  = ARM_DWT_CYCCNT;
1614        *set = 1;
1615        if(pix & mask) {
1616          while(ARM_DWT_CYCCNT  - cyc < CYCLES_400_T1H);
1617        } else {
1618          while(ARM_DWT_CYCCNT -  cyc < CYCLES_400_T0H);
1619        }
1620        *clr = 1;
1621      }
1622    }
1623    while(ARM_DWT_CYCCNT - cyc < CYCLES_400);
1624  }
1625#endif // NEO_KHZ400
1626
1627#elif  defined(TEENSYDUINO) && defined(__MKL26Z64__) // Teensy-LC
1628
1629#if F_CPU == 48000000
1630  uint8_t          *p   = pixels,
1631		   pix, count, dly,
1632                   bitmask  = digitalPinToBitMask(pin);
1633  volatile uint8_t *reg = portSetRegister(pin);
1634  uint32_t         num = numBytes;
1635  asm volatile(
1636	"L%=_begin:"				"\
1637\	"
1638	"ldrb	%[pix],  [%[p], #0]"		"\
1639\	"
1640	"lsl	%[pix], #24"			"\
1641\	"
1642	"movs	%[count],  #7"			"\
1643\	"
1644	"L%=_loop:"				"\
1645\	"
1646	"lsl	%[pix], #1"			"\
1647\	"
1648	"bcs	L%=_loop_one"			"\
1649\	"
1650	"L%=_loop_zero:"
1651	"strb	%[bitmask],  [%[reg], #0]"	"\
1652\	"
1653	"movs	%[dly], #4"			"\
1654\	"
1655	"L%=_loop_delay_T0H:"			"\
1656\	"
1657	"sub	%[dly],  #1"			"\
1658\	"
1659	"bne	L%=_loop_delay_T0H"		"\
1660\	"
1661	"strb	%[bitmask],  [%[reg], #4]"	"\
1662\	"
1663	"movs	%[dly], #13"			"\
1664\	"
1665	"L%=_loop_delay_T0L:"			"\
1666\	"
1667	"sub	%[dly],  #1"			"\
1668\	"
1669	"bne	L%=_loop_delay_T0L"		"\
1670\	"
1671	"b	L%=_next"			"\
1672\	"
1673	"L%=_loop_one:"
1674	"strb	%[bitmask],  [%[reg], #0]"	"\
1675\	"
1676	"movs	%[dly], #13"			"\
1677\	"
1678	"L%=_loop_delay_T1H:"			"\
1679\	"
1680	"sub	%[dly],  #1"			"\
1681\	"
1682	"bne	L%=_loop_delay_T1H"		"\
1683\	"
1684	"strb	%[bitmask],  [%[reg], #4]"	"\
1685\	"
1686	"movs	%[dly], #4"			"\
1687\	"
1688	"L%=_loop_delay_T1L:"			"\
1689\	"
1690	"sub	%[dly],  #1"			"\
1691\	"
1692	"bne	L%=_loop_delay_T1L"		"\
1693\	"
1694	"nop"					"\
1695\	"
1696	"L%=_next:"				"\
1697\	"
1698	"sub	%[count],  #1"			"\
1699\	"
1700	"bne	L%=_loop"			"\
1701\	"
1702	"lsl	%[pix],  #1"			"\
1703\	"
1704	"bcs	L%=_last_one"			"\
1705\	"
1706	"L%=_last_zero:"
1707	"strb	%[bitmask],  [%[reg], #0]"	"\
1708\	"
1709	"movs	%[dly], #4"			"\
1710\	"
1711	"L%=_last_delay_T0H:"			"\
1712\	"
1713	"sub	%[dly],  #1"			"\
1714\	"
1715	"bne	L%=_last_delay_T0H"		"\
1716\	"
1717	"strb	%[bitmask],  [%[reg], #4]"	"\
1718\	"
1719	"movs	%[dly], #10"			"\
1720\	"
1721	"L%=_last_delay_T0L:"			"\
1722\	"
1723	"sub	%[dly],  #1"			"\
1724\	"
1725	"bne	L%=_last_delay_T0L"		"\
1726\	"
1727	"b	L%=_repeat"			"\
1728\	"
1729	"L%=_last_one:"
1730	"strb	%[bitmask],  [%[reg], #0]"	"\
1731\	"
1732	"movs	%[dly], #13"			"\
1733\	"
1734	"L%=_last_delay_T1H:"			"\
1735\	"
1736	"sub	%[dly],  #1"			"\
1737\	"
1738	"bne	L%=_last_delay_T1H"		"\
1739\	"
1740	"strb	%[bitmask],  [%[reg], #4]"	"\
1741\	"
1742	"movs	%[dly], #1"			"\
1743\	"
1744	"L%=_last_delay_T1L:"			"\
1745\	"
1746	"sub	%[dly],  #1"			"\
1747\	"
1748	"bne	L%=_last_delay_T1L"		"\
1749\	"
1750	"nop"					"\
1751\	"
1752	"L%=_repeat:"				"\
1753\	"
1754	"add	%[p],  #1"			"\
1755\	"
1756	"sub	%[num], #1"			"\
1757\	"
1758	"bne	L%=_begin"			"\
1759\	"
1760	"L%=_done:"				"\
1761\	"
1762	:  [p] "+r" (p),
1763	  [pix] "=&r" (pix),
1764	  [count] "=&r" (count),
1765	  [dly] "=&r" (dly),
1766	  [num] "+r" (num)
1767	: [bitmask] "r" (bitmask),
1768	  [reg] "r" (reg)
1769  );
1770#else
1771#error "Sorry, only 48 MHz is supported,  please set Tools > CPU Speed to 48 MHz"
1772#endif // F_CPU == 48000000
1773
1774//  Begin of support for NRF52832 based boards  -------------------------
1775
1776#elif  defined(NRF52)
1777// [[[Begin of the Neopixel NRF52 EasyDMA implementation
1778//                                    by the Hackerspace San Salvador]]]
1779// This  technique uses the PWM peripheral on the NRF52. The PWM uses the
1780// EasyDMA feature  included on the chip. This technique loads the duty 
1781// cycle configuration for  each cycle when the PWM is enabled. For this 
1782// to work we need to store a 16  bit configuration for each bit of the
1783// RGB(W) values in the pixel buffer.
1784//  Comparator values for the PWM were hand picked and are guaranteed to
1785// be 100%  organic to preserve freshness and high accuracy. Current 
1786// parameters are:
1787//   * PWM Clock: 16Mhz
1788//   * Minimum step time: 62.5ns
1789//   * Time for zero  in high (T0H): 0.31ms
1790//   * Time for one in high (T1H): 0.75ms
1791//   * Cycle  time:  1.25us
1792//   * Frequency: 800Khz
1793// For 400Khz we just double the calculated  times.
1794// ---------- BEGIN Constants for the EasyDMA implementation -----------
1795//  The PWM starts the duty cycle in LOW. To start with HIGH we
1796// need to set the  15th bit on each register.
1797
1798// WS2812 (rev A) timing is 0.35 and 0.7us
1799//#define  MAGIC_T0H               5UL | (0x8000) // 0.3125us
1800//#define MAGIC_T1H              12UL  | (0x8000) // 0.75us
1801
1802// WS2812B (rev B) timing is 0.4 and 0.8 us
1803#define  MAGIC_T0H               6UL | (0x8000) // 0.375us
1804#define MAGIC_T1H              13UL  | (0x8000) // 0.8125us
1805
1806// WS2811 (400 khz) timing is 0.5 and 1.2
1807#define  MAGIC_T0H_400KHz        8UL  | (0x8000) // 0.5us
1808#define MAGIC_T1H_400KHz        19UL  | (0x8000) // 1.1875us
1809
1810// For 400Khz, we double value of CTOPVAL
1811#define  CTOPVAL                20UL            // 1.25us
1812#define CTOPVAL_400KHz         40UL            // 2.5us
1813
1814// ---------- END Constants for the EasyDMA implementation  -------------
1815// 
1816// If there is no device available an alternative cycle-counter
1817//  implementation is tried.
1818// The nRF52832 runs with a fixed clock of 64Mhz. The  alternative
1819// implementation is the same as the one used for the Teensy 3.0/1/2  but
1820// with the Nordic SDK HAL & registers syntax.
1821// The number of cycles  was hand picked and is guaranteed to be 100% 
1822// organic to preserve freshness  and high accuracy.
1823// ---------- BEGIN Constants for cycle counter implementation  ---------
1824#define CYCLES_800_T0H  18  // ~0.36 uS
1825#define CYCLES_800_T1H  41  // ~0.76 uS
1826#define CYCLES_800      71  // ~1.25 uS
1827
1828#define CYCLES_400_T0H  26  // ~0.50 uS
1829#define CYCLES_400_T1H  70  // ~1.26 uS
1830#define CYCLES_400      156 // ~2.50 uS
1831// ---------- END of Constants for cycle counter implementation  --------
1832
1833  // To support both the SoftDevice + Neopixels we use the EasyDMA
1834  // feature from the NRF25. However this technique implies to
1835  // generate  a pattern and store it on the memory. The actual
1836  // memory used in bytes corresponds  to the following formula:
1837  //              totalMem = numBytes*8*2+(2*2)
1838  // The two additional bytes at the end are needed to reset the
1839  // sequence.
1840  //
1841  // If there is not enough memory, we will fall back to cycle counter
1842  // using DWT
1843  uint32_t  pattern_size   = numBytes*8*sizeof(uint16_t)+2*sizeof(uint16_t);
1844  uint16_t* pixels_pattern = NULL;
1845
1846  NRF_PWM_Type* pwm = NULL;
1847
1848  //  Try to find a free PWM device, which is not enabled
1849  // and has no connected  pins
1850  NRF_PWM_Type* PWM[3] = {NRF_PWM0, NRF_PWM1, NRF_PWM2};
1851  for(int device  = 0; device<3; device++) {
1852    if( (PWM[device]->ENABLE == 0)                            &&
1853        (PWM[device]->PSEL.OUT[0] & PWM_PSEL_OUT_CONNECT_Msk) &&
1854        (PWM[device]->PSEL.OUT[1]  & PWM_PSEL_OUT_CONNECT_Msk) &&
1855        (PWM[device]->PSEL.OUT[2] & PWM_PSEL_OUT_CONNECT_Msk)  &&
1856        (PWM[device]->PSEL.OUT[3] & PWM_PSEL_OUT_CONNECT_Msk)
1857    ) {
1858      pwm = PWM[device];
1859      break;
1860    }
1861  }
1862  
1863  // only malloc  if there is PWM device available
1864  if ( pwm != NULL ) {
1865    #ifdef ARDUINO_FEATHER52  // use thread-safe malloc
1866      pixels_pattern = (uint16_t *) rtos_malloc(pattern_size);
1867    #else
1868      pixels_pattern = (uint16_t *) malloc(pattern_size);
1869    #endif
1870  }
1871
1872  // Use the identified device to choose the implementation
1873  // If  a PWM device is available use DMA
1874  if( (pixels_pattern != NULL) && (pwm != NULL)  ) {
1875    uint16_t pos = 0; // bit position
1876
1877    for(uint16_t n=0; n<numBytes;  n++) {
1878      uint8_t pix = pixels[n];
1879
1880      for(uint8_t mask=0x80, i=0;  mask>0; mask >>= 1, i++) {
1881        #ifdef NEO_KHZ400
1882        if( !is800KHz  ) {
1883          pixels_pattern[pos] = (pix & mask) ? MAGIC_T1H_400KHz : MAGIC_T0H_400KHz;
1884        }else
1885        #endif
1886        {
1887          pixels_pattern[pos] =  (pix & mask) ? MAGIC_T1H : MAGIC_T0H;
1888        }
1889
1890        pos++;
1891      }
1892    }
1893
1894    // Zero padding to indicate the end of que sequence
1895    pixels_pattern[++pos]  = 0 | (0x8000); // Seq end
1896    pixels_pattern[++pos] = 0 | (0x8000); // Seq end
1897
1898    // Set the wave mode to count UP
1899    pwm->MODE = (PWM_MODE_UPDOWN_Up << PWM_MODE_UPDOWN_Pos);
1900
1901    // Set the PWM to use the 16MHz clock
1902    pwm->PRESCALER = (PWM_PRESCALER_PRESCALER_DIV_1  << PWM_PRESCALER_PRESCALER_Pos);
1903
1904    // Setting of the maximum count
1905    // but keeping it on 16Mhz allows for more granularity just
1906    // in case  someone wants to do more fine-tuning of the timing.
1907#ifdef NEO_KHZ400
1908    if(  !is800KHz ) {
1909      pwm->COUNTERTOP = (CTOPVAL_400KHz << PWM_COUNTERTOP_COUNTERTOP_Pos);
1910    }else
1911#endif
1912    {
1913      pwm->COUNTERTOP = (CTOPVAL << PWM_COUNTERTOP_COUNTERTOP_Pos);
1914    }
1915
1916    // Disable loops, we want the sequence to repeat only once
1917    pwm->LOOP = (PWM_LOOP_CNT_Disabled << PWM_LOOP_CNT_Pos);
1918
1919    // On the  "Common" setting the PWM uses the same pattern for the
1920    // for supported  sequences. The pattern is stored on half-word
1921    // of 16bits
1922    pwm->DECODER  = (PWM_DECODER_LOAD_Common << PWM_DECODER_LOAD_Pos) |
1923                   (PWM_DECODER_MODE_RefreshCount  << PWM_DECODER_MODE_Pos);
1924
1925    // Pointer to the memory storing the patter
1926    pwm->SEQ[0].PTR = (uint32_t)(pixels_pattern) << PWM_SEQ_PTR_PTR_Pos;
1927
1928    // Calculation of the number of steps loaded from memory.
1929    pwm->SEQ[0].CNT  = (pattern_size/sizeof(uint16_t)) << PWM_SEQ_CNT_CNT_Pos;
1930
1931    // The following  settings are ignored with the current config.
1932    pwm->SEQ[0].REFRESH  = 0;
1933    pwm->SEQ[0].ENDDELAY = 0;
1934
1935    // The Neopixel implementation is a blocking  algorithm. DMA
1936    // allows for non-blocking operation. To "simulate" a blocking
1937    // operation we enable the interruption for the end of sequence
1938    // and  block the execution thread until the event flag is set by
1939    // the peripheral.
1940//    pwm->INTEN |= (PWM_INTEN_SEQEND0_Enabled<<PWM_INTEN_SEQEND0_Pos);
1941
1942    //  PSEL must be configured before enabling PWM
1943    pwm->PSEL.OUT[0] = g_ADigitalPinMap[pin];
1944
1945    // Enable the PWM
1946    pwm->ENABLE = 1;
1947
1948    // After all of this and  many hours of reading the documentation
1949    // we are ready to start the sequence...
1950    pwm->EVENTS_SEQEND[0]  = 0;
1951    pwm->TASKS_SEQSTART[0] = 1;
1952
1953    //  But we have to wait for the flag to be set.
1954    while(!pwm->EVENTS_SEQEND[0])
1955    {
1956      #ifdef ARDUINO_FEATHER52
1957      yield();
1958      #endif
1959    }
1960
1961    // Before leave we clear the flag for the event.
1962    pwm->EVENTS_SEQEND[0]  = 0;
1963
1964    // We need to disable the device and disconnect
1965    // all the  outputs before leave or the device will not
1966    // be selected on the next call.
1967    // TODO: Check if disabling the device causes performance issues.
1968    pwm->ENABLE  = 0;
1969
1970    pwm->PSEL.OUT[0] = 0xFFFFFFFFUL;
1971
1972    #ifdef ARDUINO_FEATHER52  // use thread-safe free
1973      rtos_free(pixels_pattern);
1974    #else
1975      free(pixels_pattern);
1976    #endif
1977  }// End of DMA implementation
1978  // ---------------------------------------------------------------------
1979  else{
1980    // Fall back to DWT
1981    #ifdef ARDUINO_FEATHER52
1982      // Bluefruit  Feather 52 uses freeRTOS
1983      // Critical Section is used since it does not  block SoftDevice execution
1984      taskENTER_CRITICAL();
1985    #elif defined(NRF52_DISABLE_INT)
1986      // If you are using the Bluetooth SoftDevice we advise you to not disable
1987      // the interrupts. Disabling the interrupts even for short periods of time
1988      // causes the SoftDevice to stop working.
1989      // Disable the interrupts  only in cases where you need high performance for
1990      // the LEDs and if you  are not using the EasyDMA feature.
1991      __disable_irq();
1992    #endif
1993
1994    uint32_t pinMask = 1UL << g_ADigitalPinMap[pin];
1995
1996    uint32_t CYCLES_X00     = CYCLES_800;
1997    uint32_t CYCLES_X00_T1H = CYCLES_800_T1H;
1998    uint32_t  CYCLES_X00_T0H = CYCLES_800_T0H;
1999
2000#ifdef NEO_KHZ400
2001    if( !is800KHz )
2002    {
2003      CYCLES_X00     = CYCLES_400;
2004      CYCLES_X00_T1H = CYCLES_400_T1H;
2005      CYCLES_X00_T0H = CYCLES_400_T0H;
2006    }
2007#endif
2008
2009    // Enable DWT  in debug core
2010    CoreDebug->DEMCR |= CoreDebug_DEMCR_TRCENA_Msk;
2011    DWT->CTRL  |= DWT_CTRL_CYCCNTENA_Msk;
2012
2013    // Tries to re-send the frame if is interrupted  by the SoftDevice.
2014    while(1) {
2015      uint8_t *p = pixels;
2016
2017      uint32_t  cycStart = DWT->CYCCNT;
2018      uint32_t cyc = 0;
2019
2020      for(uint16_t n=0;  n<numBytes; n++) {
2021        uint8_t pix = *p++;
2022
2023        for(uint8_t mask  = 0x80; mask; mask >>= 1) {
2024          while(DWT->CYCCNT - cyc < CYCLES_X00);
2025          cyc  = DWT->CYCCNT;
2026
2027          NRF_GPIO->OUTSET |= pinMask;
2028
2029          if(pix & mask) {
2030            while(DWT->CYCCNT - cyc < CYCLES_X00_T1H);
2031          } else {
2032            while(DWT->CYCCNT - cyc < CYCLES_X00_T0H);
2033          }
2034
2035          NRF_GPIO->OUTCLR |= pinMask;
2036        }
2037      }
2038      while(DWT->CYCCNT - cyc < CYCLES_X00);
2039
2040
2041      // If total time longer  than 25%, resend the whole data.
2042      // Since we are likely to be interrupted  by SoftDevice
2043      if ( (DWT->CYCCNT - cycStart) < ( 8*numBytes*((CYCLES_X00*5)/4)  ) ) {
2044        break;
2045      }
2046
2047      // re-send need 300us delay
2048      delayMicroseconds(300);
2049    }
2050
2051    // Enable interrupts again
2052    #ifdef ARDUINO_FEATHER52
2053      taskEXIT_CRITICAL();
2054    #elif defined(NRF52_DISABLE_INT)
2055      __enable_irq();
2056    #endif
2057  }
2058// END of NRF52 implementation
2059
2060#elif  defined (__SAMD21E17A__) || defined(__SAMD21G18A__)  || defined(__SAMD21E18A__)  || defined(__SAMD21J18A__) // Arduino Zero, Gemma/Trinket M0, SODAQ Autonomo and  others
2061  // Tried this with a timer/counter, couldn't quite get adequate
2062  // resolution.  So yay, you get a load of goofball NOPs...
2063
2064  uint8_t  *ptr,  *end, p, bitMask, portNum;
2065  uint32_t  pinMask;
2066
2067  portNum =  g_APinDescription[pin].ulPort;
2068  pinMask =  1ul << g_APinDescription[pin].ulPin;
2069  ptr     =  pixels;
2070  end     =  ptr + numBytes;
2071  p       = *ptr++;
2072  bitMask =  0x80;
2073
2074  volatile  uint32_t *set = &(PORT->Group[portNum].OUTSET.reg),
2075                    *clr  = &(PORT->Group[portNum].OUTCLR.reg);
2076
2077#ifdef NEO_KHZ400 // 800 KHz check  needed only if 400 KHz support enabled
2078  if(is800KHz) {
2079#endif
2080    for(;;)  {
2081      *set = pinMask;
2082      asm("nop; nop; nop; nop; nop; nop; nop; nop;");
2083      if(p & bitMask) {
2084        asm("nop; nop; nop; nop; nop; nop; nop; nop;"
2085            "nop; nop; nop; nop; nop; nop; nop; nop;"
2086            "nop; nop;  nop; nop;");
2087        *clr = pinMask;
2088      } else {
2089        *clr = pinMask;
2090        asm("nop; nop; nop; nop; nop; nop; nop; nop;"
2091            "nop; nop;  nop; nop; nop; nop; nop; nop;"
2092            "nop; nop; nop; nop;");
2093      }
2094      if(bitMask >>= 1) {
2095        asm("nop; nop; nop; nop; nop; nop; nop; nop;  nop;");
2096      } else {
2097        if(ptr >= end) break;
2098        p       =  *ptr++;
2099        bitMask = 0x80;
2100      }
2101    }
2102#ifdef NEO_KHZ400
2103  } else { // 400 KHz bitstream
2104    for(;;) {
2105      *set = pinMask;
2106      asm("nop;  nop; nop; nop; nop; nop; nop; nop; nop; nop; nop;");
2107      if(p & bitMask) {
2108        asm("nop; nop; nop; nop; nop; nop; nop; nop;"
2109            "nop; nop;  nop; nop; nop; nop; nop; nop;"
2110            "nop; nop; nop; nop; nop; nop; nop;  nop;"
2111            "nop; nop; nop;");
2112        *clr = pinMask;
2113      }  else {
2114        *clr = pinMask;
2115        asm("nop; nop; nop; nop; nop; nop;  nop; nop;"
2116            "nop; nop; nop; nop; nop; nop; nop; nop;"
2117            "nop;  nop; nop; nop; nop; nop; nop; nop;"
2118            "nop; nop; nop;");
2119      }
2120      asm("nop; nop; nop; nop; nop; nop; nop; nop;"
2121          "nop; nop; nop;  nop; nop; nop; nop; nop;"
2122          "nop; nop; nop; nop; nop; nop; nop; nop;"
2123          "nop; nop; nop; nop; nop; nop; nop; nop;");
2124      if(bitMask >>=  1) {
2125        asm("nop; nop; nop; nop; nop; nop; nop;");
2126      } else {
2127        if(ptr >= end) break;
2128        p       = *ptr++;
2129        bitMask =  0x80;
2130      }
2131    }
2132  }
2133#endif
2134
2135#elif defined (__SAMD51__) //  M4 @ 120mhz
2136  // Tried this with a timer/counter, couldn't quite get adequate
2137  // resolution.  So yay, you get a load of goofball NOPs...
2138
2139  uint8_t  *ptr,  *end, p, bitMask, portNum;
2140  uint32_t  pinMask;
2141
2142  portNum =  g_APinDescription[pin].ulPort;
2143  pinMask =  1ul << g_APinDescription[pin].ulPin;
2144  ptr     =  pixels;
2145  end     =  ptr + numBytes;
2146  p       = *ptr++;
2147  bitMask =  0x80;
2148
2149  volatile  uint32_t *set = &(PORT->Group[portNum].OUTSET.reg),
2150                    *clr  = &(PORT->Group[portNum].OUTCLR.reg);
2151
2152#ifdef NEO_KHZ400 // 800 KHz check  needed only if 400 KHz support enabled
2153  if(is800KHz) {
2154#endif
2155    for(;;)  {
2156      if(p & bitMask) { // ONE
2157        // High 800ns
2158        *set = pinMask;
2159        asm("nop; nop; nop; nop; nop; nop; nop; nop;"
2160            "nop; nop;  nop; nop; nop; nop; nop; nop;"
2161            "nop; nop; nop; nop; nop; nop; nop;  nop;"
2162            "nop; nop; nop; nop; nop; nop; nop; nop;"
2163            "nop;  nop; nop; nop; nop; nop; nop; nop;"
2164            "nop; nop; nop; nop; nop; nop;  nop; nop;"
2165            "nop; nop; nop; nop; nop; nop; nop; nop;"
2166            "nop;  nop; nop; nop; nop; nop; nop; nop;"
2167            "nop; nop; nop; nop; nop; nop;  nop; nop;"
2168            "nop; nop; nop; nop; nop; nop; nop; nop;");
2169        //  Low 450ns
2170        *clr = pinMask;
2171        asm("nop; nop; nop; nop; nop; nop;  nop; nop;"
2172            "nop; nop; nop; nop; nop; nop; nop; nop;"
2173            "nop;  nop; nop; nop; nop; nop; nop; nop;"
2174            "nop; nop; nop; nop; nop; nop;  nop; nop;"
2175            "nop;");
2176      } else { // ZERO
2177        // High  400ns
2178        *set = pinMask;
2179        asm("nop; nop; nop; nop; nop; nop;  nop; nop;"
2180            "nop; nop; nop; nop; nop; nop; nop; nop;"
2181            "nop;  nop; nop; nop; nop; nop; nop; nop;"
2182            "nop; nop; nop; nop; nop; nop;  nop; nop;"
2183            "nop;");
2184        // Low 850ns
2185        *clr =  pinMask;
2186        asm("nop; nop; nop; nop; nop; nop; nop; nop;"
2187            "nop;  nop; nop; nop; nop; nop; nop; nop;"
2188            "nop; nop; nop; nop; nop; nop;  nop; nop;"
2189            "nop; nop; nop; nop; nop; nop; nop; nop;"
2190            "nop;  nop; nop; nop; nop; nop; nop; nop;"
2191            "nop; nop; nop; nop; nop; nop;  nop; nop;"
2192            "nop; nop; nop; nop; nop; nop; nop; nop;"
2193            "nop;  nop; nop; nop; nop; nop; nop; nop;"
2194            "nop; nop; nop; nop; nop; nop;  nop; nop;"
2195            "nop; nop; nop; nop; nop; nop; nop; nop;");
2196      }
2197      if(bitMask >>= 1) {
2198        // Move on to the next pixel
2199        asm("nop;");
2200      } else {
2201        if(ptr >= end) break;
2202        p       = *ptr++;
2203        bitMask = 0x80;
2204      }
2205    }
2206#ifdef NEO_KHZ400
2207  } else { //  400 KHz bitstream
2208    // ToDo!
2209  }
2210#endif
2211
2212#elif defined (ARDUINO_STM32_FEATHER)  // FEATHER WICED (120MHz)
2213
2214  // Tried this with a timer/counter, couldn't  quite get adequate
2215  // resolution.  So yay, you get a load of goofball NOPs...
2216
2217  uint8_t  *ptr, *end, p, bitMask;
2218  uint32_t  pinMask;
2219
2220  pinMask =  BIT(PIN_MAP[pin].gpio_bit);
2221  ptr     =  pixels;
2222  end     =  ptr + numBytes;
2223  p       = *ptr++;
2224  bitMask =  0x80;
2225
2226  volatile uint16_t *set = &(PIN_MAP[pin].gpio_device->regs->BSRRL);
2227  volatile uint16_t *clr = &(PIN_MAP[pin].gpio_device->regs->BSRRH);
2228
2229#ifdef  NEO_KHZ400 // 800 KHz check needed only if 400 KHz support enabled
2230  if(is800KHz)  {
2231#endif
2232    for(;;) {
2233      if(p & bitMask) { // ONE
2234        // High  800ns
2235        *set = pinMask;
2236        asm("nop; nop; nop; nop; nop; nop;  nop; nop;"
2237            "nop; nop; nop; nop; nop; nop; nop; nop;"
2238            "nop;  nop; nop; nop; nop; nop; nop; nop;"
2239            "nop; nop; nop; nop; nop; nop;  nop; nop;"
2240            "nop; nop; nop; nop; nop; nop; nop; nop;"
2241            "nop;  nop; nop; nop; nop; nop; nop; nop;"
2242            "nop; nop; nop; nop; nop; nop;  nop; nop;"
2243            "nop; nop; nop; nop; nop; nop; nop; nop;"
2244            "nop;  nop; nop; nop; nop; nop; nop; nop;"
2245            "nop; nop; nop; nop; nop; nop;  nop; nop;"
2246            "nop; nop; nop; nop; nop; nop; nop; nop;"
2247            "nop;  nop; nop; nop; nop; nop;");
2248        // Low 450ns
2249        *clr = pinMask;
2250        asm("nop; nop; nop; nop; nop; nop; nop; nop;"
2251            "nop; nop;  nop; nop; nop; nop; nop; nop;"
2252            "nop; nop; nop; nop; nop; nop; nop;  nop;"
2253            "nop; nop; nop; nop; nop; nop; nop; nop;"
2254            "nop;  nop; nop; nop; nop; nop;");
2255      } else { // ZERO
2256        // High 400ns
2257        *set = pinMask;
2258        asm("nop; nop; nop; nop; nop; nop; nop; nop;"
2259            "nop; nop; nop; nop; nop; nop; nop; nop;"
2260            "nop; nop;  nop; nop; nop; nop; nop; nop;"
2261            "nop; nop; nop; nop; nop; nop; nop;  nop;"
2262            "nop; nop; nop; nop; nop; nop; nop; nop;"
2263            "nop;");
2264        // Low 850ns
2265        *clr = pinMask;
2266        asm("nop; nop; nop;  nop; nop; nop; nop; nop;"
2267            "nop; nop; nop; nop; nop; nop; nop; nop;"
2268            "nop; nop; nop; nop; nop; nop; nop; nop;"
2269            "nop; nop;  nop; nop; nop; nop; nop; nop;"
2270            "nop; nop; nop; nop; nop; nop; nop;  nop;"
2271            "nop; nop; nop; nop; nop; nop; nop; nop;"
2272            "nop;  nop; nop; nop; nop; nop; nop; nop;"
2273            "nop; nop; nop; nop; nop; nop;  nop; nop;"
2274            "nop; nop; nop; nop; nop; nop; nop; nop;"
2275            "nop;  nop; nop; nop; nop; nop; nop; nop;"
2276            "nop; nop; nop; nop; nop; nop;  nop; nop;"
2277            "nop; nop; nop; nop;");
2278      }
2279      if(bitMask  >>= 1) {
2280        // Move on to the next pixel
2281        asm("nop;");
2282      }  else {
2283        if(ptr >= end) break;
2284        p       = *ptr++;
2285        bitMask  = 0x80;
2286      }
2287    }
2288#ifdef NEO_KHZ400
2289  } else { // 400 KHz bitstream
2290    // ToDo!
2291  }
2292#endif
2293
2294#else // Other ARM architecture -- Presumed  Arduino Due
2295
2296  #define SCALE      VARIANT_MCK / 2UL / 1000000UL
2297  #define  INST       (2UL * F_CPU / VARIANT_MCK)
2298  #define TIME_800_0 ((int)(0.40 * SCALE  + 0.5) - (5 * INST))
2299  #define TIME_800_1 ((int)(0.80 * SCALE + 0.5) - (5 * INST))
2300  #define PERIOD_800 ((int)(1.25 * SCALE + 0.5) - (5 * INST))
2301  #define TIME_400_0  ((int)(0.50 * SCALE + 0.5) - (5 * INST))
2302  #define TIME_400_1 ((int)(1.20 * SCALE  + 0.5) - (5 * INST))
2303  #define PERIOD_400 ((int)(2.50 * SCALE + 0.5) - (5 * INST))
2304
2305  int             pinMask, time0, time1, period, t;
2306  Pio            *port;
2307  volatile WoReg *portSet, *portClear, *timeValue, *timeReset;
2308  uint8_t        *p,  *end, pix, mask;
2309
2310  pmc_set_writeprotect(false);
2311  pmc_enable_periph_clk((uint32_t)TC3_IRQn);
2312  TC_Configure(TC1, 0,
2313    TC_CMR_WAVE | TC_CMR_WAVSEL_UP | TC_CMR_TCCLKS_TIMER_CLOCK1);
2314  TC_Start(TC1, 0);
2315
2316  pinMask   = g_APinDescription[pin].ulPin; // Don't  'optimize' these into
2317  port      = g_APinDescription[pin].pPort; // declarations  above.  Want to
2318  portSet   = &(port->PIO_SODR);            // burn a few cycles  after
2319  portClear = &(port->PIO_CODR);            // starting timer to minimize
2320  timeValue = &(TC1->TC_CHANNEL[0].TC_CV);  // the initial 'while'.
2321  timeReset  = &(TC1->TC_CHANNEL[0].TC_CCR);
2322  p         =  pixels;
2323  end       =  p +  numBytes;
2324  pix       = *p++;
2325  mask      = 0x80;
2326
2327#ifdef NEO_KHZ400  // 800 KHz check needed only if 400 KHz support enabled
2328  if(is800KHz) {
2329#endif
2330    time0  = TIME_800_0;
2331    time1  = TIME_800_1;
2332    period = PERIOD_800;
2333#ifdef  NEO_KHZ400
2334  } else { // 400 KHz bitstream
2335    time0  = TIME_400_0;
2336    time1  = TIME_400_1;
2337    period = PERIOD_400;
2338  }
2339#endif
2340
2341  for(t = time0;;  t = time0) {
2342    if(pix & mask) t = time1;
2343    while(*timeValue < period);
2344    *portSet   = pinMask;
2345    *timeReset = TC_CCR_CLKEN | TC_CCR_SWTRG;
2346    while(*timeValue  < t);
2347    *portClear = pinMask;
2348    if(!(mask >>= 1)) {   // This 'inside-out'  loop logic utilizes
2349      if(p >= end) break; // idle time to minimize inter-byte  delays.
2350      pix = *p++;
2351      mask = 0x80;
2352    }
2353  }
2354  while(*timeValue  < period); // Wait for last bit
2355  TC_Stop(TC1, 0);
2356
2357#endif // end Due
2358
2359//  END ARM ----------------------------------------------------------------
2360
2361
2362#elif  defined(ESP8266) || defined(ESP32)
2363
2364// ESP8266 ----------------------------------------------------------------
2365
2366  // ESP8266 show() is external to enforce ICACHE_RAM_ATTR execution
2367  espShow(pin,  pixels, numBytes, is800KHz);
2368
2369#elif defined(__ARDUINO_ARC__)
2370
2371// Arduino  101  -----------------------------------------------------------
2372
2373#define  NOPx7 { __builtin_arc_nop(); \\
2374  __builtin_arc_nop(); __builtin_arc_nop(); \\
2375  __builtin_arc_nop(); __builtin_arc_nop(); \\
2376  __builtin_arc_nop(); __builtin_arc_nop();  }
2377
2378  PinDescription *pindesc = &g_APinDescription[pin];
2379  register uint32_t  loop = 8 * numBytes; // one loop to handle all bytes and all bits
2380  register  uint8_t *p = pixels;
2381  register uint32_t currByte = (uint32_t) (*p);
2382  register  uint32_t currBit = 0x80 & currByte;
2383  register uint32_t bitCounter = 0;
2384  register  uint32_t first = 1;
2385
2386  // The loop is unusual. Very first iteration puts all  the way LOW to the wire -
2387  // constant LOW does not affect NEOPIXEL, so there  is no visible effect displayed.
2388  // During that very first iteration CPU caches  instructions in the loop.
2389  // Because of the caching process, "CPU slows down".  NEOPIXEL pulse is very time sensitive
2390  // that's why we let the CPU cache first  and we start regular pulse from 2nd iteration
2391  if (pindesc->ulGPIOType == SS_GPIO)  {
2392    register uint32_t reg = pindesc->ulGPIOBase + SS_GPIO_SWPORTA_DR;
2393    uint32_t  reg_val = __builtin_arc_lr((volatile uint32_t)reg);
2394    register uint32_t reg_bit_high  = reg_val | (1 << pindesc->ulGPIOId);
2395    register uint32_t reg_bit_low  = reg_val  & ~(1 << pindesc->ulGPIOId);
2396
2397    loop += 1; // include first, special iteration
2398    while(loop--) {
2399      if(!first) {
2400        currByte <<= 1;
2401        bitCounter++;
2402      }
2403
2404      // 1 is >550ns high and >450ns low; 0 is 200..500ns high and  >450ns low
2405      __builtin_arc_sr(first ? reg_bit_low : reg_bit_high, (volatile  uint32_t)reg);
2406      if(currBit) { // ~400ns HIGH (740ns overall)
2407        NOPx7
2408        NOPx7
2409      }
2410      // ~340ns HIGH
2411      NOPx7
2412     __builtin_arc_nop();
2413
2414      // 820ns LOW; per spec, max allowed low here is 5000ns */
2415      __builtin_arc_sr(reg_bit_low,  (volatile uint32_t)reg);
2416      NOPx7
2417      NOPx7
2418
2419      if(bitCounter  >= 8) {
2420        bitCounter = 0;
2421        currByte = (uint32_t) (*++p);
2422      }
2423
2424      currBit = 0x80 & currByte;
2425      first = 0;
2426    }
2427  } else if(pindesc->ulGPIOType == SOC_GPIO) {
2428    register uint32_t reg = pindesc->ulGPIOBase  + SOC_GPIO_SWPORTA_DR;
2429    uint32_t reg_val = MMIO_REG_VAL(reg);
2430    register  uint32_t reg_bit_high = reg_val | (1 << pindesc->ulGPIOId);
2431    register uint32_t  reg_bit_low  = reg_val & ~(1 << pindesc->ulGPIOId);
2432
2433    loop += 1; // include  first, special iteration
2434    while(loop--) {
2435      if(!first) {
2436        currByte  <<= 1;
2437        bitCounter++;
2438      }
2439      MMIO_REG_VAL(reg) = first ?  reg_bit_low : reg_bit_high;
2440      if(currBit) { // ~430ns HIGH (740ns overall)
2441        NOPx7
2442        NOPx7
2443        __builtin_arc_nop();
2444      }
2445      //  ~310ns HIGH
2446      NOPx7
2447
2448      // 850ns LOW; per spec, max allowed low  here is 5000ns */
2449      MMIO_REG_VAL(reg) = reg_bit_low;
2450      NOPx7
2451      NOPx7
2452
2453      if(bitCounter >= 8) {
2454        bitCounter = 0;
2455        currByte = (uint32_t)  (*++p);
2456      }
2457
2458      currBit = 0x80 & currByte;
2459      first = 0;
2460    }
2461  }
2462
2463#else 
2464#error Architecture not supported
2465#endif
2466
2467
2468//  END ARCHITECTURE SELECT ------------------------------------------------
2469
2470#ifndef  NRF52
2471  interrupts();
2472#endif
2473
2474  endTime = micros(); // Save EOD time  for latch on next call
2475}
2476
2477// Set the output pin number
2478void Adafruit_NeoPixel::setPin(uint8_t  p) {
2479  if(begun && (pin >= 0)) pinMode(pin, INPUT);
2480    pin = p;
2481    if(begun)  {
2482      pinMode(p, OUTPUT);
2483      digitalWrite(p, LOW);
2484    }
2485#ifdef  __AVR__
2486    port    = portOutputRegister(digitalPinToPort(p));
2487    pinMask  = digitalPinToBitMask(p);
2488#endif
2489}
2490
2491// Set pixel color from separate  R,G,B components:
2492void Adafruit_NeoPixel::setPixelColor(
2493 uint16_t n, uint8_t  r, uint8_t g, uint8_t b) {
2494
2495  if(n < numLEDs) {
2496    if(brightness) { //  See notes in setBrightness()
2497      r = (r * brightness) >> 8;
2498      g = (g  * brightness) >> 8;
2499      b = (b * brightness) >> 8;
2500    }
2501    uint8_t  *p;
2502    if(wOffset == rOffset) { // Is an RGB-type strip
2503      p = &pixels[n  * 3];    // 3 bytes per pixel
2504    } else {                 // Is a WRGB-type  strip
2505      p = &pixels[n * 4];    // 4 bytes per pixel
2506      p[wOffset] =  0;        // But only R,G,B passed -- set W to 0
2507    }
2508    p[rOffset] = r;          // R,G,B always stored
2509    p[gOffset] = g;
2510    p[bOffset] = b;
2511  }
2512}
2513
2514void Adafruit_NeoPixel::setPixelColor(
2515 uint16_t n, uint8_t r,  uint8_t g, uint8_t b, uint8_t w) {
2516
2517  if(n < numLEDs) {
2518    if(brightness)  { // See notes in setBrightness()
2519      r = (r * brightness) >> 8;
2520      g  = (g * brightness) >> 8;
2521      b = (b * brightness) >> 8;
2522      w = (w * brightness)  >> 8;
2523    }
2524    uint8_t *p;
2525    if(wOffset == rOffset) { // Is an RGB-type  strip
2526      p = &pixels[n * 3];    // 3 bytes per pixel (ignore W)
2527    } else  {                 // Is a WRGB-type strip
2528      p = &pixels[n * 4];    // 4 bytes  per pixel
2529      p[wOffset] = w;        // Store W
2530    }
2531    p[rOffset]  = r;          // Store R,G,B
2532    p[gOffset] = g;
2533    p[bOffset] = b;
2534  }
2535}
2536
2537//  Set pixel color from 'packed' 32-bit RGB color:
2538void Adafruit_NeoPixel::setPixelColor(uint16_t  n, uint32_t c) {
2539  if(n < numLEDs) {
2540    uint8_t *p,
2541      r = (uint8_t)(c  >> 16),
2542      g = (uint8_t)(c >>  8),
2543      b = (uint8_t)c;
2544    if(brightness)  { // See notes in setBrightness()
2545      r = (r * brightness) >> 8;
2546      g  = (g * brightness) >> 8;
2547      b = (b * brightness) >> 8;
2548    }
2549    if(wOffset  == rOffset) {
2550      p = &pixels[n * 3];
2551    } else {
2552      p = &pixels[n  * 4];
2553      uint8_t w = (uint8_t)(c >> 24);
2554      p[wOffset] = brightness  ? ((w * brightness) >> 8) : w;
2555    }
2556    p[rOffset] = r;
2557    p[gOffset]  = g;
2558    p[bOffset] = b;
2559  }
2560}
2561
2562// Convert separate R,G,B into packed  32-bit RGB color.
2563// Packed format is always RGB, regardless of LED strand color  order.
2564uint32_t Adafruit_NeoPixel::Color(uint8_t r, uint8_t g, uint8_t b) {
2565  return ((uint32_t)r << 16) | ((uint32_t)g <<  8) | b;
2566}
2567
2568// Convert separate  R,G,B,W into packed 32-bit WRGB color.
2569// Packed format is always WRGB, regardless  of LED strand color order.
2570uint32_t Adafruit_NeoPixel::Color(uint8_t r, uint8_t  g, uint8_t b, uint8_t w) {
2571  return ((uint32_t)w << 24) | ((uint32_t)r << 16)  | ((uint32_t)g <<  8) | b;
2572}
2573
2574// Query color from previously-set pixel  (returns packed 32-bit RGB value)
2575uint32_t Adafruit_NeoPixel::getPixelColor(uint16_t  n) const {
2576  if(n >= numLEDs) return 0; // Out of bounds, return no color.
2577
2578  uint8_t *p;
2579
2580  if(wOffset == rOffset) { // Is RGB-type device
2581    p =  &pixels[n * 3];
2582    if(brightness) {
2583      // Stored color was decimated by  setBrightness().  Returned value
2584      // attempts to scale back to an approximation  of the original 24-bit
2585      // value used when setting the pixel color, but  there will always be
2586      // some error -- those bits are simply gone.  Issue  is most
2587      // pronounced at low brightness levels.
2588      return (((uint32_t)(p[rOffset]  << 8) / brightness) << 16) |
2589             (((uint32_t)(p[gOffset] << 8) / brightness)  <<  8) |
2590             ( (uint32_t)(p[bOffset] << 8) / brightness       );
2591    } else {
2592      // No brightness adjustment has been made -- return 'raw'  color
2593      return ((uint32_t)p[rOffset] << 16) |
2594             ((uint32_t)p[gOffset]  <<  8) |
2595              (uint32_t)p[bOffset];
2596    }
2597  } else {                 //  Is RGBW-type device
2598    p = &pixels[n * 4];
2599    if(brightness) { // Return  scaled color
2600      return (((uint32_t)(p[wOffset] << 8) / brightness) << 24)  |
2601             (((uint32_t)(p[rOffset] << 8) / brightness) << 16) |
2602             (((uint32_t)(p[gOffset]  << 8) / brightness) <<  8) |
2603             ( (uint32_t)(p[bOffset] << 8) / brightness       );
2604    } else { // Return raw color
2605      return ((uint32_t)p[wOffset]  << 24) |
2606             ((uint32_t)p[rOffset] << 16) |
2607             ((uint32_t)p[gOffset]  <<  8) |
2608              (uint32_t)p[bOffset];
2609    }
2610  }
2611}
2612
2613// Returns  pointer to pixels[] array.  Pixel data is stored in device-
2614// native format  and is not translated here.  Application will need to be
2615// aware of specific  pixel data format and handle colors appropriately.
2616uint8_t *Adafruit_NeoPixel::getPixels(void)  const {
2617  return pixels;
2618}
2619
2620uint16_t Adafruit_NeoPixel::numPixels(void)  const {
2621  return numLEDs;
2622}
2623
2624// Adjust output brightness; 0=darkest  (off), 255=brightest.  This does
2625// NOT immediately affect what's currently displayed  on the LEDs.  The
2626// next call to show() will refresh the LEDs at this level.  However,
2627// this process is potentially "lossy," especially when increasing
2628//  brightness.  The tight timing in the WS2811/WS2812 code means there
2629// aren't  enough free cycles to perform this scaling on the fly as data
2630// is issued.  So  we make a pass through the existing color data in RAM
2631// and scale it (subsequent  graphics commands also work at this
2632// brightness level).  If there's a significant  step up in brightness,
2633// the limited number of steps (quantization) in the old  data will be
2634// quite visible in the re-scaled version.  For a non-destructive
2635//  change, you'll need to re-render the full strip data.  C'est la vie.
2636void Adafruit_NeoPixel::setBrightness(uint8_t  b) {
2637  // Stored brightness value is different than what's passed.
2638  // This  simplifies the actual scaling math later, allowing a fast
2639  // 8x8-bit multiply  and taking the MSB.  'brightness' is a uint8_t,
2640  // adding 1 here may (intentionally)  roll over...so 0 = max brightness
2641  // (color values are interpreted literally;  no scaling), 1 = min
2642  // brightness (off), 255 = just below max brightness.
2643  uint8_t newBrightness = b + 1;
2644  if(newBrightness != brightness) { // Compare  against prior value
2645    // Brightness has changed -- re-scale existing data in  RAM
2646    uint8_t  c,
2647            *ptr           = pixels,
2648             oldBrightness  = brightness - 1; // De-wrap old brightness value
2649    uint16_t scale;
2650    if(oldBrightness  == 0) scale = 0; // Avoid /0
2651    else if(b == 255) scale = 65535 / oldBrightness;
2652    else scale = (((uint16_t)newBrightness << 8) - 1) / oldBrightness;
2653    for(uint16_t  i=0; i<numBytes; i++) {
2654      c      = *ptr;
2655      *ptr++ = (c * scale) >>  8;
2656    }
2657    brightness = newBrightness;
2658  }
2659}
2660
2661//Return the brightness  value
2662uint8_t Adafruit_NeoPixel::getBrightness(void) const {
2663  return brightness  - 1;
2664}
2665
2666void Adafruit_NeoPixel::clear() {
2667  memset(pixels, 0, numBytes);
2668}
2669