Adding leds/[] operators on controllers and LEDS.

Author: focalintent

FastLED.cpp

@@ -21,7 +21,7 @@ CFastLED::CFastLED() {
 }
 
 CLEDController &CFastLED::addLeds(CLEDController *pLed,
-									   const struct CRGB *data,
+									   struct CRGB *data,
 									   int nLedsOrOffset, int nLedsIfOffset) {
 	int nOffset = (nLedsIfOffset > 0) ? nLedsOrOffset : 0;
 	int nLeds = (nLedsIfOffset > 0) ? nLedsIfOffset : nLedsOrOffset;
@@ -39,6 +39,18 @@ void CFastLED::show(uint8_t scale) {
 	}
 }
 
+CLEDController & CFastLED::operator[](int x) {
+	CLEDController *pCur = CLEDController::head();
+	while(x-- && pCur) {
+		pCur = pCur->next();
+	}
+	if(pCur == NULL) {
+		return *(CLEDController::head());
+	} else {
+		return *pCur;
+	}
+}
+
 void CFastLED::showColor(const struct CRGB & color, uint8_t scale) {
 	CLEDController *pCur = CLEDController::head();
 	while(pCur) {

FastLED.h

@@ -81,7 +81,7 @@ class CFastLED {
 public:
 	CFastLED();
 
-	static CLEDController &addLeds(CLEDController *pLed, const struct CRGB *data, int nLedsOrOffset, int nLedsIfOffset = 0);
+	static CLEDController &addLeds(CLEDController *pLed, struct CRGB *data, int nLedsOrOffset, int nLedsIfOffset = 0);
 
 	template<ESPIChipsets CHIPSET,  uint8_t DATA_PIN, uint8_t CLOCK_PIN > static CLEDController &addLeds(const struct CRGB *data, int nLedsOrOffset, int nLedsIfOffset = 0) {
 		switch(CHIPSET) {
@@ -93,7 +93,7 @@ class CFastLED {
 		}
 	}
 
-	template<ESPIChipsets CHIPSET,  uint8_t DATA_PIN, uint8_t CLOCK_PIN, EOrder RGB_ORDER > static CLEDController &addLeds(const struct CRGB *data, int nLedsOrOffset, int nLedsIfOffset = 0) {
+	template<ESPIChipsets CHIPSET,  uint8_t DATA_PIN, uint8_t CLOCK_PIN, EOrder RGB_ORDER > static CLEDController &addLeds(struct CRGB *data, int nLedsOrOffset, int nLedsIfOffset = 0) {
 		switch(CHIPSET) {
 			case LPD8806: { static LPD8806Controller<DATA_PIN, CLOCK_PIN, RGB_ORDER> c; return addLeds(&c, data, nLedsOrOffset, nLedsIfOffset); }
 			case WS2801: { static WS2801Controller<DATA_PIN, CLOCK_PIN, RGB_ORDER> c; return addLeds(&c, data, nLedsOrOffset, nLedsIfOffset); }
@@ -103,7 +103,7 @@ class CFastLED {
 		}
 	}
 
-	template<ESPIChipsets CHIPSET,  uint8_t DATA_PIN, uint8_t CLOCK_PIN, EOrder RGB_ORDER, uint8_t SPI_DATA_RATE > CLEDController &addLeds(const struct CRGB *data, int nLedsOrOffset, int nLedsIfOffset = 0) {
+	template<ESPIChipsets CHIPSET,  uint8_t DATA_PIN, uint8_t CLOCK_PIN, EOrder RGB_ORDER, uint8_t SPI_DATA_RATE > CLEDController &addLeds(struct CRGB *data, int nLedsOrOffset, int nLedsIfOffset = 0) {
 		switch(CHIPSET) {
 			case LPD8806: { static LPD8806Controller<DATA_PIN, CLOCK_PIN, RGB_ORDER, SPI_DATA_RATE> c; return addLeds(&c, data, nLedsOrOffset, nLedsIfOffset); }
 			case WS2801: { static WS2801Controller<DATA_PIN, CLOCK_PIN, RGB_ORDER, SPI_DATA_RATE> c; return addLeds(&c, data, nLedsOrOffset, nLedsIfOffset); }
@@ -114,50 +114,50 @@ class CFastLED {
 	}
 
 #ifdef SPI_DATA
-	template<ESPIChipsets CHIPSET> static CLEDController &addLeds(const struct CRGB *data, int nLedsOrOffset, int nLedsIfOffset = 0) {
+	template<ESPIChipsets CHIPSET> static CLEDController &addLeds(struct CRGB *data, int nLedsOrOffset, int nLedsIfOffset = 0) {
 		return addLeds<CHIPSET, SPI_DATA, SPI_CLOCK, RGB>(data, nLedsOrOffset, nLedsIfOffset);
 	}
 
-	template<ESPIChipsets CHIPSET, EOrder RGB_ORDER> static CLEDController &addLeds(const struct CRGB *data, int nLedsOrOffset, int nLedsIfOffset = 0) {
+	template<ESPIChipsets CHIPSET, EOrder RGB_ORDER> static CLEDController &addLeds(struct CRGB *data, int nLedsOrOffset, int nLedsIfOffset = 0) {
 		return addLeds<CHIPSET, SPI_DATA, SPI_CLOCK, RGB_ORDER>(data, nLedsOrOffset, nLedsIfOffset);
 	}
 
-	template<ESPIChipsets CHIPSET, EOrder RGB_ORDER, uint8_t SPI_DATA_RATE> static CLEDController &addLeds(const struct CRGB *data, int nLedsOrOffset, int nLedsIfOffset = 0) {
+	template<ESPIChipsets CHIPSET, EOrder RGB_ORDER, uint8_t SPI_DATA_RATE> static CLEDController &addLeds(struct CRGB *data, int nLedsOrOffset, int nLedsIfOffset = 0) {
 		return addLeds<CHIPSET, SPI_DATA, SPI_CLOCK, RGB_ORDER, SPI_DATA_RATE>(data, nLedsOrOffset, nLedsIfOffset);
 	}
 
 #endif
 
 	template<template<uint8_t DATA_PIN> class CHIPSET, uint8_t DATA_PIN>
-	static CLEDController &addLeds(const struct CRGB *data, int nLedsOrOffset, int nLedsIfOffset = 0) {
+	static CLEDController &addLeds(struct CRGB *data, int nLedsOrOffset, int nLedsIfOffset = 0) {
 		static CHIPSET<DATA_PIN> c;
 		return addLeds(&c, data, nLedsOrOffset, nLedsIfOffset);
 	}
 
 	template<template<uint8_t DATA_PIN, EOrder RGB_ORDER> class CHIPSET, uint8_t DATA_PIN, EOrder RGB_ORDER>
-	static CLEDController &addLeds(const struct CRGB *data, int nLedsOrOffset, int nLedsIfOffset = 0) {
+	static CLEDController &addLeds(struct CRGB *data, int nLedsOrOffset, int nLedsIfOffset = 0) {
 		static CHIPSET<DATA_PIN, RGB_ORDER> c;
 		return addLeds(&c, data, nLedsOrOffset, nLedsIfOffset);
 	}
 
 	template<template<uint8_t DATA_PIN, EOrder RGB_ORDER> class CHIPSET, uint8_t DATA_PIN>
-	static CLEDController &addLeds(const struct CRGB *data, int nLedsOrOffset, int nLedsIfOffset = 0) {
+	static CLEDController &addLeds(struct CRGB *data, int nLedsOrOffset, int nLedsIfOffset = 0) {
 		static CHIPSET<DATA_PIN, RGB> c;
 		return addLeds(&c, data, nLedsOrOffset, nLedsIfOffset);
 	}
 
 
 #ifdef FASTSPI_USE_DMX_SIMPLE
 	template<EClocklessChipsets CHIPSET, uint8_t DATA_PIN>
-	static CLEDController &addLeds(const struct CRGB *data, int nLedsOrOffset, int nLedsIfOffset = 0)
+	static CLEDController &addLeds(struct CRGB *data, int nLedsOrOffset, int nLedsIfOffset = 0)
 	 {
 		switch(CHIPSET) {
 			case DMX: { static DMXController<DATA_PIN> controller; return addLeds(&controller, data, nLedsOrOffset, nLedsIfOffset); }
 		}
 	}
 
 	template<EClocklessChipsets CHIPSET, uint8_t DATA_PIN, EOrder RGB_ORDER>
-	static CLEDController &addLeds(const struct CRGB *data, int nLedsOrOffset, int nLedsIfOffset = 0) {
+	static CLEDController &addLeds(struct CRGB *data, int nLedsOrOffset, int nLedsIfOffset = 0) {
 		switch(CHIPSET) {
 			case DMX: {static  DMXController<DATA_PIN, RGB_ORDER> controller; return addLeds(&controller, data, nLedsOrOffset, nLedsIfOffset); }
 		}
@@ -166,7 +166,7 @@ class CFastLED {
 
 #ifdef HAS_BLOCKLESS
 	template<EBlockChipsets CHIPSET, int NUM_LANES>
-	static CLEDController &addLeds(const struct CRGB *data, int nLedsOrOffset, int nLedsIfOffset = 0) {
+	static CLEDController &addLeds(struct CRGB *data, int nLedsOrOffset, int nLedsIfOffset = 0) {
 		switch(CHIPSET) {
 			case WS2811_PORTC: return addLeds(new BlockClocklessController<NUM_LANES, NS(350), NS(350), NS(550)>(), data, nLedsOrOffset, nLedsIfOffset);
 		}
@@ -200,6 +200,12 @@ class CFastLED {
 	// nFrames calls, it will print a summary of FPS info out to the serial port.
 	// If the serial port isn't opened, this function does nothing.
 	void countFPS(int nFrames=100);
+
+	CLEDController & operator[](int x);
+
+	int size() { return (*this)[0].size(); }
+
+	CRGB *leds() { return (*this)[0].leds(); }
 };
 
 extern CFastLED & FastSPI_LED;

controller.h

@@ -8,8 +8,8 @@
 #define RO(X) RGB_BYTE(RGB_ORDER, X)
 #define RGB_BYTE(RO,X) (((RO)>>(3*(2-(X)))) & 0x3)
 
-#define RGB_BYTE0(RO) ((RO>>6) & 0x3) 
-#define RGB_BYTE1(RO) ((RO>>3) & 0x3) 
+#define RGB_BYTE0(RO) ((RO>>6) & 0x3)
+#define RGB_BYTE1(RO) ((RO>>3) & 0x3)
 #define RGB_BYTE2(RO) ((RO) & 0x3)
 
 // operator byte *(struct CRGB[] arr) { return (byte*)arr; }
@@ -19,20 +19,20 @@
 typedef uint8_t EDitherMode;
 
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-// 
+//
 // LED Controller interface definition
 //
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
-/// Base definition for an LED controller.  Pretty much the methods that every LED controller object will make available.  
+/// Base definition for an LED controller.  Pretty much the methods that every LED controller object will make available.
 /// Note that the showARGB method is not impelemented for all controllers yet.   Note also the methods for eventual checking
 /// of background writing of data (I'm looking at you, teensy 3.0 DMA controller!).  If you want to pass LED controllers around
 /// to methods, make them references to this type, keeps your code saner.  However, most people won't be seeing/using these objects
 /// directly at all
-class CLEDController { 
+class CLEDController {
 protected:
     friend class CFastLED;
-    const CRGB *m_Data;
+    CRGB *m_Data;
     CLEDController *m_pNext;
     CRGB m_ColorCorrection;
     CRGB m_ColorTemperature;
@@ -44,7 +44,7 @@ class CLEDController {
     // set all the leds on the controller to a given color
     virtual void showColor(const struct CRGB & data, int nLeds, CRGB scale) = 0;
 
-    // note that the uint8_ts will be in the order that you want them sent out to the device. 
+    // note that the uint8_ts will be in the order that you want them sent out to the device.
     // nLeds is the number of RGB leds being written to
     virtual void show(const struct CRGB *data, int nLeds, CRGB scale) = 0;
 
@@ -77,11 +77,11 @@ class CLEDController {
     }
 
     // show function using the "attached to this controller" led data
-    void showLeds(uint8_t brightness=255) { 
+    void showLeds(uint8_t brightness=255) {
         show(m_Data, m_nLeds, getAdjustment(brightness));
     }
 
-    void showColor(const struct CRGB & data, uint8_t brightness=255) { 
+    void showColor(const struct CRGB & data, uint8_t brightness=255) {
         showColor(data, m_nLeds, getAdjustment(brightness));
     }
 
@@ -95,19 +95,28 @@ class CLEDController {
         show(data, nLeds, getAdjustment(brightness))
     }
 #endif
-   
-    CLEDController & setLeds(const CRGB *data, int nLeds) { 
+
+    CLEDController & setLeds(CRGB *data, int nLeds) {
         m_Data = data;
         m_nLeds = nLeds;
         return *this;
     }
 
     void clearLedData() {
-        if(m_Data) { 
+        if(m_Data) {
             memset8((void*)m_Data, 0, sizeof(struct CRGB) * m_nLeds);
         }
     }
 
+    // How many leds does this controller manage?
+    int size() { return m_nLeds; }
+
+    // Pointer to the CRGB array for this controller
+    CRGB* leds() { return m_Data; }
+
+    // Reference to the n'th item in the controller
+    CRGB &operator[](int x) { return m_Data[x]; }
+
     inline CLEDController & setDither(uint8_t ditherMode = BINARY_DITHER) { m_DitherMode = ditherMode; return *this; }
     inline uint8_t getDither() { return m_DitherMode; }
 
@@ -119,17 +128,17 @@ class CLEDController {
     CLEDController & setTemperature(ColorTemperature temperature) { m_ColorTemperature = temperature; return *this; }
     CRGB getTemperature() { return m_ColorTemperature; }
 
-    CRGB getAdjustment(uint8_t scale) { 
+    CRGB getAdjustment(uint8_t scale) {
 #if defined(NO_CORRECTION) && (NO_CORRECTION==1)
         return CRGB(scale,scale,scale);
 #else
         CRGB adj(0,0,0);
 
-        if(scale > 0) { 
-            for(uint8_t i = 0; i < 3; i++) { 
+        if(scale > 0) {
+            for(uint8_t i = 0; i < 3; i++) {
                 uint8_t cc = m_ColorCorrection.raw[i];
                 uint8_t ct = m_ColorTemperature.raw[i];
-                if(cc > 0 && ct > 0) { 
+                if(cc > 0 && ct > 0) {
                     uint32_t work = (((uint32_t)cc)+1) * (((uint32_t)ct)+1) * scale;
                     work /= 0x10000L;
                     adj.raw[i] = work & 0xFF;
@@ -143,11 +152,11 @@ class CLEDController {
 };
 
 // Pixel controller class.  This is the class that we use to centralize pixel access in a block of data, including
-// support for things like RGB reordering, scaling, dithering, skipping (for ARGB data), and eventually, we will 
+// support for things like RGB reordering, scaling, dithering, skipping (for ARGB data), and eventually, we will
 // centralize 8/12/16 conversions here as well.
 template<EOrder RGB_ORDER>
 struct PixelController {
-        const uint8_t *mData; 
+        const uint8_t *mData;
         int mLen;
         uint8_t d[3];
         uint8_t e[3];
@@ -186,7 +195,7 @@ struct PixelController {
 #ifdef SUPPORT_ARGB
         PixelController(const CARGB &d, int len, CRGB & s, EDitherMode dither = BINARY_DITHER) : mData((const uint8_t*)&d), mLen(len), mScale(s) {
             enable_dithering(dither);
-            // skip the A in CARGB            
+            // skip the A in CARGB
             mData += 1;
             mAdvance = 0;
         }
@@ -195,7 +204,7 @@ struct PixelController {
             enable_dithering(dither);
             // skip the A in CARGB
             mData += 1;
-            mAdvance = 4; 
+            mAdvance = 4;
         }
 #endif
 
@@ -239,7 +248,7 @@ struct PixelController {
             // It's initialized to the reversed bits of R.
             // If 'ditherBits' is 2, Q here will cycle through (0,128,64,192)
             byte Q = 0;
-        
+
             // Reverse bits in a byte
             {
                 if(R & 0x01) { Q |= 0x80; }
@@ -251,21 +260,21 @@ struct PixelController {
                 if(R & 0x40) { Q |= 0x02; }
                 if(R & 0x80) { Q |= 0x01; }
             }
-            
+
             // Now we adjust Q to fall in the center of each range,
             // instead of at the start of the range.
             // If ditherBits is 2, Q will be (0, 128, 64, 192) at first,
             // and this adjustment makes it (31, 159, 95, 223).
             if( ditherBits < 8) {
                 Q += 0x01 << (7 - ditherBits);
             }
-            
+
             // D and E form the "scaled dither signal"
             // which is added to pixel values to affect the
             // actual dithering.
-            
+
             // Setup the initial D and E values
-            for(int i = 0; i < 3; i++) {                        
+            for(int i = 0; i < 3; i++) {
                     byte s = mScale.raw[i];
                     e[i] = s ? (256/s) + 1 : 0;
                     d[i] = scale8(Q, e[i]);
@@ -275,10 +284,10 @@ struct PixelController {
         }
 
         // Do we have n pixels left to process?
-        __attribute__((always_inline)) inline bool has(int n) { 
+        __attribute__((always_inline)) inline bool has(int n) {
             return mLen >= n;
         }
-        
+
         // toggle dithering enable
         void enable_dithering(EDitherMode dither) {
             switch(dither) {
@@ -287,23 +296,23 @@ struct PixelController {
             }
         }
 
-        // get the amount to advance the pointer by 
+        // get the amount to advance the pointer by
         __attribute__((always_inline)) inline int advanceBy() { return mAdvance; }
-        
+
         // advance the data pointer forward, adjust position counter
          __attribute__((always_inline)) inline void advanceData() { mData += mAdvance; mLen--;}
 
-        // step the dithering forward 
+        // step the dithering forward
          __attribute__((always_inline)) inline void stepDithering() {
-         		// IF UPDATING HERE, BE SURE TO UPDATE THE ASM VERSION IN 
+         		// IF UPDATING HERE, BE SURE TO UPDATE THE ASM VERSION IN
          		// clockless_trinket.h!
                 d[0] = e[0] - d[0];
                 d[1] = e[1] - d[1];
                 d[2] = e[2] - d[2];
         }
 
         // Some chipsets pre-cycle the first byte, which means we want to cycle byte 0's dithering separately
-        __attribute__((always_inline)) inline void preStepFirstByteDithering() { 
+        __attribute__((always_inline)) inline void preStepFirstByteDithering() {
             d[RO(0)] = e[RO(0)] - d[RO(0)];
         }
 
@@ -316,11 +325,11 @@ struct PixelController {
         template<int SLOT>  __attribute__((always_inline)) inline static uint8_t advanceAndLoadAndScale(PixelController & pc) { pc.advanceData(); return pc.loadAndScale<SLOT>(pc); }
 
 		// Helper functions to get around gcc stupidities
-		__attribute__((always_inline)) inline uint8_t loadAndScale0() { return loadAndScale<0>(*this); }    
-		__attribute__((always_inline)) inline uint8_t loadAndScale1() { return loadAndScale<1>(*this); }    
-		__attribute__((always_inline)) inline uint8_t loadAndScale2() { return loadAndScale<2>(*this); }    
-		__attribute__((always_inline)) inline uint8_t advanceAndLoadAndScale0() { return advanceAndLoadAndScale<0>(*this); }    
-        __attribute__((always_inline)) inline uint8_t stepAdvanceAndLoadAndScale0() { stepDithering(); return advanceAndLoadAndScale<0>(*this); }    
+		__attribute__((always_inline)) inline uint8_t loadAndScale0() { return loadAndScale<0>(*this); }
+		__attribute__((always_inline)) inline uint8_t loadAndScale1() { return loadAndScale<1>(*this); }
+		__attribute__((always_inline)) inline uint8_t loadAndScale2() { return loadAndScale<2>(*this); }
+		__attribute__((always_inline)) inline uint8_t advanceAndLoadAndScale0() { return advanceAndLoadAndScale<0>(*this); }
+        __attribute__((always_inline)) inline uint8_t stepAdvanceAndLoadAndScale0() { stepDithering(); return advanceAndLoadAndScale<0>(*this); }
 };
 
-#endif
+#endif