Merged changes from main FastLED repo (upstream)

Author: samguyer

.gitignore

@@ -1,3 +1,5 @@
-html/
 *.gch
 *~
+/.vscode
+/docs/html
+/docs/latex

PORTING.md

@@ -1,6 +1,7 @@
-=New platform porting guide=
+New platform porting guide
+==========================
 
-== Fast porting for a new board on existing hardware ==
+# Fast porting for a new board on existing hardware
 
 Sometimes "porting" FastLED simply consists of supplying new pin definitions for the given platform.  For example, platforms/avr/fastpin_avr.h contains various pin definitions for all the AVR variant chipsets/boards that FastLED supports.  Defining a set of pins involves setting up a set of definitions - for example here's one full set from the avr fastpin file:
 
@@ -26,7 +27,7 @@ The ```_FL_IO``` macro is used to define the port registers for the platform whi
 
 The ```HAS_HARDWARE_PIN_SUPPORT``` define tells the rest of the FastLED library that there is hardware pin support available.  There may be other platform specific defines for things like hardware SPI ports and such.
 
-== Setting up the basic files/folders ==
+## Setting up the basic files/folders
 
 * Create platform directory (e.g. platforms/arm/kl26)
 * Create configuration header led_sysdefs_arm_kl26.h:
@@ -38,18 +39,18 @@ The ```HAS_HARDWARE_PIN_SUPPORT``` define tells the rest of the FastLED library
 * Modify led_sysdefs.h to conditionally include platform sysdefs header file
 * Modify platforms.h to conditionally include platform fastled header
 
-== Porting fastpin.h ==
+## Porting fastpin.h
 
 The heart of the FastLED library is the fast pin accesss.  This is a templated class that provides 1-2 cycle pin access, bypassing digital write and other such things.  As such, this will usually be the first bit of the library that you will want to port when moving to a new platform.  Once you have FastPIN up and running then you can do some basic work like testing toggles or running bit-bang'd SPI output.
 
 There's two low level FastPin classes.  There's the base FastPIN template class, and then there is FastPinBB which is for bit-banded access on those MCUs that support bitbanding.  Note that the bitband class is optional and primarily useful in the implementation of other functionality internal to the platform.  This file is also where you would do the pin to port/bit mapping defines.
 
 Explaining how the macros work and should be used is currently beyond the scope of this document.
 
-== Porting fastspi.h ==
+## Porting fastspi.h
 
 This is where you define the low level interface to the hardware SPI system (including a writePixels method that does a bunch of housekeeping for writing led data).  Use the fastspi_nop.h file as a reference for the methods that need to be implemented.  There are ofteh other useful methods that can help with the internals of the SPI code, I recommend taking a look at how the various platforms implement their SPI classes.
 
-== Porting clockless.h ==
+## Porting clockless.h
 
 This is where you define the code for the clockless controllers.  Across ARM platforms this will usually be fairly similar - though different arm platforms will have different clock sources that you can/should use.

docs/Doxyfile

@@ -62,7 +62,7 @@ void FillLEDsFromPaletteColors( uint8_t colorIndex)
 {
     uint8_t brightness = 255;
 
-    for( int i = 0; i < NUM_LEDS; i++) {
+    for( int i = 0; i < NUM_LEDS; ++i) {
         leds[i] = ColorFromPalette( currentPalette, colorIndex, brightness, currentBlending);
         colorIndex += 3;
     }
@@ -101,7 +101,7 @@ void ChangePalettePeriodically()
 // This function fills the palette with totally random colors.
 void SetupTotallyRandomPalette()
 {
-    for( int i = 0; i < 16; i++) {
+    for( int i = 0; i < 16; ++i) {
         currentPalette[i] = CHSV( random8(), 255, random8());
     }
 }

examples/ColorPalette/ColorPalette.ino

@@ -30,6 +30,7 @@ const uint8_t kMatrixHeight = 16;
 
 // Param for different pixel layouts
 const bool    kMatrixSerpentineLayout = true;
+const bool    kMatrixVertical = false;
 // Set 'kMatrixSerpentineLayout' to false if your pixels are 
 // laid out all running the same way, like this:
 //
@@ -88,17 +89,29 @@ uint16_t XY( uint8_t x, uint8_t y)
   uint16_t i;
 
   if( kMatrixSerpentineLayout == false) {
-    i = (y * kMatrixWidth) + x;
+    if (kMatrixVertical == false) {
+      i = (y * kMatrixWidth) + x;
+    } else {
+      i = kMatrixHeight * (kMatrixWidth - (x+1))+y;
+    }
   }
 
   if( kMatrixSerpentineLayout == true) {
-    if( y & 0x01) {
-      // Odd rows run backwards
-      uint8_t reverseX = (kMatrixWidth - 1) - x;
-      i = (y * kMatrixWidth) + reverseX;
-    } else {
-      // Even rows run forwards
-      i = (y * kMatrixWidth) + x;
+    if (kMatrixVertical == false) {
+      if( y & 0x01) {
+        // Odd rows run backwards
+        uint8_t reverseX = (kMatrixWidth - 1) - x;
+        i = (y * kMatrixWidth) + reverseX;
+      } else {
+        // Even rows run forwards
+        i = (y * kMatrixWidth) + x;
+      }
+    } else { // vertical positioning
+      if ( x & 0x01) {
+        i = kMatrixHeight * (kMatrixWidth - (x+1))+y;
+      } else {
+        i = kMatrixHeight * (kMatrixWidth - x) - (y+1);
+      }
     }
   }
 

examples/XYMatrix/XYMatrix.ino

@@ -31,8 +31,8 @@ CFastLED::CFastLED() {
 }
 
 CLEDController &CFastLED::addLeds(CLEDController *pLed,
-									   struct CRGB *data,
-									   int nLedsOrOffset, int nLedsIfOffset) {
+								  struct CRGB *data,
+								  int nLedsOrOffset, int nLedsIfOffset) {
 	int nOffset = (nLedsIfOffset > 0) ? nLedsOrOffset : 0;
 	int nLeds = (nLedsIfOffset > 0) ? nLedsIfOffset : nLedsOrOffset;
 
@@ -67,7 +67,7 @@ int CFastLED::count() {
     int x = 0;
 	CLEDController *pCur = CLEDController::head();
 	while( pCur) {
-        x++;
+        ++x;
 		pCur = pCur->next();
 	}
     return x;
@@ -204,33 +204,33 @@ extern int noise_min;
 extern int noise_max;
 
 void CFastLED::countFPS(int nFrames) {
-  static int br = 0;
-  static uint32_t lastframe = 0; // millis();
-
-  if(br++ >= nFrames) {
-      uint32_t now = millis();
-      now -= lastframe;
-      if( now == 0 ) {
-          now = 1; // prevent division by zero below
-      }
-      m_nFPS = (br * 1000) / now;
-    br = 0;
-    lastframe = millis();
-  }
+	static int br = 0;
+	static uint32_t lastframe = 0; // millis();
+
+	if(br++ >= nFrames) {
+		uint32_t now = millis();
+		now -= lastframe;
+		if(now == 0) {
+			now = 1; // prevent division by zero below
+		}
+		m_nFPS = (br * 1000) / now;
+		br = 0;
+		lastframe = millis();
+	}
 }
 
 void CFastLED::setMaxRefreshRate(uint16_t refresh, bool constrain) {
-  if(constrain) {
-    // if we're constraining, the new value of m_nMinMicros _must_ be higher than previously (because we're only
-    // allowed to slow things down if constraining)
-    if(refresh > 0) {
-      m_nMinMicros = ( (1000000/refresh) >  m_nMinMicros) ? (1000000/refresh) : m_nMinMicros;
-    }
-  } else if(refresh > 0) {
-    m_nMinMicros = 1000000 / refresh;
-  } else {
-    m_nMinMicros = 0;
-  }
+	if(constrain) {
+		// if we're constraining, the new value of m_nMinMicros _must_ be higher than previously (because we're only
+		// allowed to slow things down if constraining)
+		if(refresh > 0) {
+			m_nMinMicros = ((1000000 / refresh) > m_nMinMicros) ? (1000000 / refresh) : m_nMinMicros;
+		}
+	} else if(refresh > 0) {
+		m_nMinMicros = 1000000 / refresh;
+	} else {
+		m_nMinMicros = 0;
+	}
 }
 
 extern "C" int atexit(void (* /*func*/ )()) { return 0; }

src/FastLED.cpp

@@ -316,11 +316,11 @@ class CFastLED {
 	}
 
 #if defined(__FASTLED_HAS_FIBCC) && (__FASTLED_HAS_FIBCC == 1)
-  template<uint8_t NUM_LANES, template<uint8_t DATA_PIN, EOrder RGB_ORDER> class CHIPSET, uint8_t DATA_PIN, EOrder RGB_ORDER=RGB>
-  static CLEDController &addLeds(struct CRGB *data, int nLeds) {
-    static __FIBCC<CHIPSET, DATA_PIN, NUM_LANES, RGB_ORDER> c;
-    return addLeds(&c, data, nLeds);
-  }
+	template<uint8_t NUM_LANES, template<uint8_t DATA_PIN, EOrder RGB_ORDER> class CHIPSET, uint8_t DATA_PIN, EOrder RGB_ORDER=RGB>
+	static CLEDController &addLeds(struct CRGB *data, int nLeds) {
+		static __FIBCC<CHIPSET, DATA_PIN, NUM_LANES, RGB_ORDER> c;
+		return addLeds(&c, data, nLeds);
+	}
 #endif
 
 	#ifdef FASTSPI_USE_DMX_SIMPLE
@@ -556,19 +556,19 @@ class CFastLED {
 	uint16_t getFPS() { return m_nFPS; }
 
 	/// Get how many controllers have been registered
-  /// @returns the number of controllers (strips) that have been added with addLeds
+	/// @returns the number of controllers (strips) that have been added with addLeds
 	int count();
 
 	/// Get a reference to a registered controller
-  /// @returns a reference to the Nth controller
+	/// @returns a reference to the Nth controller
 	CLEDController & operator[](int x);
 
 	/// Get the number of leds in the first controller
-  /// @returns the number of LEDs in the first controller
+	/// @returns the number of LEDs in the first controller
 	int size() { return (*this)[0].size(); }
 
 	/// Get a pointer to led data for the first controller
-  /// @returns pointer to the CRGB buffer for the first controller
+	/// @returns pointer to the CRGB buffer for the first controller
 	CRGB *leds() { return (*this)[0].leds(); }
 };
 

src/FastLED.h

@@ -4,25 +4,25 @@
 /// Simplified form of bits rotating function.  Based on code found here - http://www.hackersdelight.org/hdcodetxt/transpose8.c.txt - rotating
 /// data into LSB for a faster write (the code using this data can happily walk the array backwards)
 void transpose8x1_noinline(unsigned char *A, unsigned char *B) {
-  uint32_t x, y, t;
+    uint32_t x, y, t;
 
-  // Load the array and pack it into x and y.
-  y = *(unsigned int*)(A);
-  x = *(unsigned int*)(A+4);
+    // Load the array and pack it into x and y.
+    y = *(unsigned int*)(A);
+    x = *(unsigned int*)(A+4);
 
-  // pre-transform x
-  t = (x ^ (x >> 7)) & 0x00AA00AA;  x = x ^ t ^ (t << 7);
-  t = (x ^ (x >>14)) & 0x0000CCCC;  x = x ^ t ^ (t <<14);
+    // pre-transform x
+    t = (x ^ (x >> 7)) & 0x00AA00AA;  x = x ^ t ^ (t << 7);
+    t = (x ^ (x >>14)) & 0x0000CCCC;  x = x ^ t ^ (t <<14);
 
-  // pre-transform y
-  t = (y ^ (y >> 7)) & 0x00AA00AA;  y = y ^ t ^ (t << 7);
-  t = (y ^ (y >>14)) & 0x0000CCCC;  y = y ^ t ^ (t <<14);
+    // pre-transform y
+    t = (y ^ (y >> 7)) & 0x00AA00AA;  y = y ^ t ^ (t << 7);
+    t = (y ^ (y >>14)) & 0x0000CCCC;  y = y ^ t ^ (t <<14);
 
-  // final transform
-  t = (x & 0xF0F0F0F0) | ((y >> 4) & 0x0F0F0F0F);
-  y = ((x << 4) & 0xF0F0F0F0) | (y & 0x0F0F0F0F);
-  x = t;
+    // final transform
+    t = (x & 0xF0F0F0F0) | ((y >> 4) & 0x0F0F0F0F);
+    y = ((x << 4) & 0xF0F0F0F0) | (y & 0x0F0F0F0F);
+    x = t;
 
-  *((uint32_t*)B) = y;
-  *((uint32_t*)(B+4)) = x;
+    *((uint32_t*)B) = y;
+    *((uint32_t*)(B+4)) = x;
 }

src/bitswap.cpp

@@ -126,7 +126,7 @@ __attribute__((always_inline)) inline void swapbits8(bitswap_type in, bitswap_ty
   // SWAPSB(b.c,1);
   // SWAPSB(b.d,0);
 
-  for(int i = 0; i < 8; i++) {
+  for(int i = 0; i < 8; ++i) {
     just8bits work;
     work.a3 = in.word[0] >> 31;
     work.a2 = in.word[0] >> 23;
@@ -145,7 +145,7 @@ __attribute__((always_inline)) inline void swapbits8(bitswap_type in, bitswap_ty
 /// Slow version of the 8 byte by 8 bit rotation
 __attribute__((always_inline)) inline void slowswap(unsigned char *A, unsigned char *B) {
 
-  for(int row = 0; row < 7; row++) {
+  for(int row = 0; row < 7; ++row) {
     uint8_t x = A[row];
 
     uint8_t bit = (1<<row);

src/bitswap.h

@@ -16,7 +16,7 @@ FASTLED_NAMESPACE_BEGIN
 #if defined(ARDUINO) //&& defined(SoftwareSerial_h)
 
 
-#if defined(SoftwareSerial_h)
+#if defined(SoftwareSerial_h) || defined(__SoftwareSerial_h)
 #include <SoftwareSerial.h>
 
 #define HAS_PIXIE
@@ -28,6 +28,7 @@ template<uint8_t DATA_PIN, EOrder RGB_ORDER = RGB>
 class PixieController : public CPixelLEDController<RGB_ORDER> {
 	SoftwareSerial Serial;
 	CMinWait<2000> mWait;
+
 public:
 	PixieController() : Serial(-1, DATA_PIN) {}
 
@@ -92,8 +93,8 @@ class LPD8806Controller : public CPixelLEDController<RGB_ORDER> {
 	};
 
 	SPI mSPI;
-public:
 
+public:
 	LPD8806Controller()  {}
 	virtual void init() {
 		mSPI.init();
@@ -123,6 +124,7 @@ class WS2801Controller : public CPixelLEDController<RGB_ORDER> {
 	typedef SPIOutput<DATA_PIN, CLOCK_PIN, SPI_SPEED> SPI;
 	SPI mSPI;
 	CMinWait<1000>  mWaitDelay;
+
 public:
 	WS2801Controller() {}
 
@@ -132,7 +134,6 @@ class WS2801Controller : public CPixelLEDController<RGB_ORDER> {
 	}
 
 protected:
-
 	virtual void showPixels(PixelController<RGB_ORDER> & pixels) {
 		mWaitDelay.wait();
 		mSPI.template writePixels<0, DATA_NOP, RGB_ORDER>(pixels);
@@ -166,7 +167,6 @@ class LPD6803Controller : public CPixelLEDController<RGB_ORDER> {
 	}
 
 protected:
-
 	virtual void showPixels(PixelController<RGB_ORDER> & pixels) {
 		mSPI.select();
 
@@ -232,7 +232,6 @@ class APA102Controller : public CPixelLEDController<RGB_ORDER> {
 	}
 
 protected:
-
 	virtual void showPixels(PixelController<RGB_ORDER> & pixels) {
 		mSPI.select();
 
@@ -297,7 +296,6 @@ class SK9822Controller : public CPixelLEDController<RGB_ORDER> {
 	}
 
 protected:
-
 	virtual void showPixels(PixelController<RGB_ORDER> & pixels) {
 		mSPI.select();
 
@@ -360,7 +358,6 @@ class P9813Controller : public CPixelLEDController<RGB_ORDER> {
 	}
 
 protected:
-
 	virtual void showPixels(PixelController<RGB_ORDER> & pixels) {
 		mSPI.select();
 
@@ -418,7 +415,6 @@ class SM16716Controller : public CPixelLEDController<RGB_ORDER> {
 	}
 
 protected:
-
 	virtual void showPixels(PixelController<RGB_ORDER> & pixels) {
 		// Make sure the FLAG_START_BIT flag is set to ensure that an extra 1 bit is sent at the start
 		// of each triplet of bytes for rgb data
@@ -458,7 +454,7 @@ class SM16716Controller : public CPixelLEDController<RGB_ORDER> {
 
 // We want to force all avr's to use the Trinket controller when running at 8Mhz, because even the 328's at 8Mhz
 // need the more tightly defined timeframes.
-#if (CLOCKLESS_FREQUENCY == 8000000 || CLOCKLESS_FREQUENCY == 16000000 || CLOCKLESS_FREQUENCY == 24000000) //  || CLOCKLESS_FREQUENCY == 48000000 || CLOCKLESS_FREQUENCY == 96000000) // 125ns/clock
+#if defined(__LGT8F__) || (CLOCKLESS_FREQUENCY == 8000000 || CLOCKLESS_FREQUENCY == 16000000 || CLOCKLESS_FREQUENCY == 24000000) //  || CLOCKLESS_FREQUENCY == 48000000 || CLOCKLESS_FREQUENCY == 96000000) // 125ns/clock
 #define FMUL (CLOCKLESS_FREQUENCY/8000000)
 
 // GE8822