NEOPIXEL driver and macros

EXRAILMacros.h

@@ -71,6 +71,8 @@
 //const byte TRACK_POWER_0=0, TRACK_POWER_OFF=0;    
 //const byte TRACK_POWER_1=1, TRACK_POWER_ON=1;   
 
+// NEOPIXEL RGB generator 
+#define NeoRGB(red,green,blue) (((red & 0x1F)<<11) | ((green & 0x1F)<<6) | ((blue & 0x1F)<<1) ) 
 
 // Pass 1 Implements aliases 
 #include "EXRAIL2MacroReset.h"
@@ -433,7 +435,7 @@ const FSH * RMFT2::getRosterFunctions(int16_t id) {
 #undef DCCX_SIGNAL
 #define DCCX_SIGNAL(id,redAspect,amberAspect,greenAspect) id | RMFT2::DCCX_SIGNAL_FLAG,redAspect,amberAspect,greenAspect,
 #undef NEOPIXEL_SIGNAL
-#define NEOPIXEL_SIGNAL(sigid,redcolour,ambercolour,greencolour) id | RMFT2::NEOPIXEL_SIGNAL_FLAG,redcolour | NEOPIXEL_FLAG_ON, ambercolour | NEOPIXEL_FLAG_ON, greencolour | NEOPIXEL_FLAG_ON,
+#define NEOPIXEL_SIGNAL(id,redcolour,ambercolour,greencolour) id | RMFT2::NEOPIXEL_SIGNAL_FLAG,redcolour | NEOPIXEL_FLAG_ON, ambercolour | NEOPIXEL_FLAG_ON, greencolour | NEOPIXEL_FLAG_ON,
 #undef VIRTUAL_SIGNAL
 #define VIRTUAL_SIGNAL(id) id,0,0,0,
 

IO_NeoPixel.h

@@ -25,8 +25,8 @@
 * To create NEOPIXEL devices, these are defined in myAutomation.h:
 * (Note the device driver is included by default)
 *
-* HAL(NEOPIXEL,first vpin, number of pixels, i2c address) 
-* e.g. HAL(NEOPIXEL,1000,64,0x60)
+* HAL(NEOPIXEL,first vpin, number of pixels,mode, i2c address) 
+* e.g. HAL(NEOPIXEL,1000,64,NEO_RGB,0x60)
 * This gives each pixel in the chain an individual vpin
 * The number of pixels must match the physical pixels in the chain. 
 * 
@@ -44,25 +44,116 @@
 #include "DIAG.h"
 #include "FSH.h"
 
+
+// The following macros to define the Neopixel String type
+// have been copied from the Adafruit Seesaw Library under the 
+// terms of the GPL. 
+// Credit to: https://github.com/adafruit/Adafruit_Seesaw
+
+// The order of primary colors in the NeoPixel data stream can vary
+// among device types, manufacturers and even different revisions of
+// the same item.  The third parameter to the seesaw_NeoPixel
+// constructor encodes the per-pixel byte offsets of the red, green
+// and blue primaries (plus white, if present) in the data stream --
+// the following #defines provide an easier-to-use named version for
+// each permutation.  e.g. NEO_GRB indicates a NeoPixel-compatible
+// device expecting three bytes per pixel, with the first byte
+// containing the green value, second containing red and third
+// containing blue.  The in-memory representation of a chain of
+// NeoPixels is the same as the data-stream order; no re-ordering of
+// bytes is required when issuing data to the chain.
+
+// Bits 5,4 of this value are the offset (0-3) from the first byte of
+// a pixel to the location of the red color byte.  Bits 3,2 are the
+// green offset and 1,0 are the blue offset.  If it is an RGBW-type
+// device (supporting a white primary in addition to R,G,B), bits 7,6
+// are the offset to the white byte...otherwise, bits 7,6 are set to
+// the same value as 5,4 (red) to indicate an RGB (not RGBW) device.
+// i.e. binary representation:
+// 0bWWRRGGBB for RGBW devices
+// 0bRRRRGGBB for RGB
+
+// RGB NeoPixel permutations; white and red offsets are always same
+// Offset:         W          R          G          B
+#define NEO_RGB ((0 << 6) | (0 << 4) | (1 << 2) | (2))
+#define NEO_RBG ((0 << 6) | (0 << 4) | (2 << 2) | (1))
+#define NEO_GRB ((1 << 6) | (1 << 4) | (0 << 2) | (2))
+#define NEO_GBR ((2 << 6) | (2 << 4) | (0 << 2) | (1))
+#define NEO_BRG ((1 << 6) | (1 << 4) | (2 << 2) | (0))
+#define NEO_BGR ((2 << 6) | (2 << 4) | (1 << 2) | (0))
+
+// RGBW NeoPixel permutations; all 4 offsets are distinct
+// Offset:         W          R          G          B
+#define NEO_WRGB ((0 << 6) | (1 << 4) | (2 << 2) | (3))
+#define NEO_WRBG ((0 << 6) | (1 << 4) | (3 << 2) | (2))
+#define NEO_WGRB ((0 << 6) | (2 << 4) | (1 << 2) | (3))
+#define NEO_WGBR ((0 << 6) | (3 << 4) | (1 << 2) | (2))
+#define NEO_WBRG ((0 << 6) | (2 << 4) | (3 << 2) | (1))
+#define NEO_WBGR ((0 << 6) | (3 << 4) | (2 << 2) | (1))
+
+#define NEO_RWGB ((1 << 6) | (0 << 4) | (2 << 2) | (3))
+#define NEO_RWBG ((1 << 6) | (0 << 4) | (3 << 2) | (2))
+#define NEO_RGWB ((2 << 6) | (0 << 4) | (1 << 2) | (3))
+#define NEO_RGBW ((3 << 6) | (0 << 4) | (1 << 2) | (2))
+#define NEO_RBWG ((2 << 6) | (0 << 4) | (3 << 2) | (1))
+#define NEO_RBGW ((3 << 6) | (0 << 4) | (2 << 2) | (1))
+
+#define NEO_GWRB ((1 << 6) | (2 << 4) | (0 << 2) | (3))
+#define NEO_GWBR ((1 << 6) | (3 << 4) | (0 << 2) | (2))
+#define NEO_GRWB ((2 << 6) | (1 << 4) | (0 << 2) | (3))
+#define NEO_GRBW ((3 << 6) | (1 << 4) | (0 << 2) | (2))
+#define NEO_GBWR ((2 << 6) | (3 << 4) | (0 << 2) | (1))
+#define NEO_GBRW ((3 << 6) | (2 << 4) | (0 << 2) | (1))
+
+#define NEO_BWRG ((1 << 6) | (2 << 4) | (3 << 2) | (0))
+#define NEO_BWGR ((1 << 6) | (3 << 4) | (2 << 2) | (0))
+#define NEO_BRWG ((2 << 6) | (1 << 4) | (3 << 2) | (0))
+#define NEO_BRGW ((3 << 6) | (1 << 4) | (2 << 2) | (0))
+#define NEO_BGWR ((2 << 6) | (3 << 4) | (1 << 2) | (0))
+#define NEO_BGRW ((3 << 6) | (2 << 4) | (1 << 2) | (0))
+
+// If 400 KHz support is enabled, the third parameter to the constructor
+// requires a 16-bit value (in order to select 400 vs 800 KHz speed).
+// If only 800 KHz is enabled (as is default on ATtiny), an 8-bit value
+// is sufficient to encode pixel color order, saving some space.
+
+#define NEO_KHZ800 0x0000 // 800 KHz datastream
+#define NEO_KHZ400 0x0100 // 400 KHz datastream
+
 /////////////////////////////////////////////////////////////////////////////////////////////////////
 /*
  * IODevice subclass for NeoPixel.
  */
+
 class NeoPixel : public IODevice {
 public:
-
 
-  static void create(VPIN vpin, int nPins, I2CAddress i2cAddress) {
-    if (checkNoOverlap(vpin, nPins, i2cAddress)) new NeoPixel(vpin, nPins, i2cAddress);
+  static void create(VPIN vpin, int nPins, uint16_t mode, I2CAddress i2cAddress) {
+    if (checkNoOverlap(vpin, nPins, mode, i2cAddress)) new NeoPixel(vpin, nPins, mode, i2cAddress);
   }
 
 private:
   static const uint16_t NEOPIXEL_ON_FLAG=0x0001; 
 
+  static const byte SEESAW_NEOPIXEL_BASE=0x0E;
+  static const byte SEESAW_NEOPIXEL_STATUS = 0x00;
+  static const byte SEESAW_NEOPIXEL_PIN = 0x01;
+  static const byte SEESAW_NEOPIXEL_SPEED = 0x02;
+  static const byte SEESAW_NEOPIXEL_BUF_LENGTH = 0x03;
+  static const byte SEESAW_NEOPIXEL_BUF=0x04;
+  static const byte SEESAW_NEOPIXEL_SHOW=0x05;
+
   // Constructor
-  NeoPixel(VPIN firstVpin, int nPins, I2CAddress i2cAddress) {
+  NeoPixel(VPIN firstVpin, int nPins, uint16_t mode, I2CAddress i2cAddress) {
     _firstVpin = firstVpin;
     _I2CAddress = i2cAddress;
+    _brightness=2; // 0,1,2,3 
+    _redOffset=mode >> 4 & 0x03;
+    _greenOffset=mode >> 2 & 0x03; 
+    _blueOffset=mode & 0x03; 
+    if ((mode >>6 & 0x03) == _redOffset) _bytesPerPixel=3; 
+    else _bytesPerPixel=4; // string has a white byte.
+    _kHz800=(mode & NEO_KHZ400)==0;
     addDevice(this);
   }
 
@@ -75,7 +166,12 @@ class NeoPixel : public IODevice {
       return;
     }
 
-    // TODO - initialize the neopixel board
+    byte setbuffer[] = {SEESAW_NEOPIXEL_BASE, SEESAW_NEOPIXEL_BUF_LENGTH,
+                  (byte)(_bytesPerPixel >> 8), (byte)(_bytesPerPixel & 0xFF)};
+    I2CManager.write(_I2CAddress, setbuffer, sizeof(setbuffer));
+    byte speedBuffer[]={SEESAW_NEOPIXEL_BASE, SEESAW_NEOPIXEL_SPEED,_kHz800};
+    I2CManager.write(_I2CAddress, speedBuffer, sizeof(speedBuffer));
+
 
     pixelBuffer=(uint16_t *) calloc(_nPins,sizeof(uint16_t)); // all pixels off  
      _display();
@@ -139,18 +235,32 @@ class NeoPixel : public IODevice {
     _deviceState = DEVSTATE_FAILED;
   }
 
+
   void transmit(uint16_t pin) {
-    auto colour=pixelBuffer[pin];
+
+    byte buffer[8]={SEESAW_NEOPIXEL_BASE,SEESAW_NEOPIXEL_BUF,0x00,0x00,0x00,0x00,0x00};
+    uint16_t offset= pin * _bytesPerPixel;
+    buffer[2]=(byte)(offset>>8);
+    buffer[3]=(byte)(offset &0xFF);
+    auto colour=pixelBuffer[pin];    
     if (colour & NEOPIXEL_ON_FLAG) {
-      // TODO convert 5,5,5 to RGB 
-    } 
-    else {
-      // TODO set black
-    }
-    // TODO transmit pixel to driver
+      buffer[_redOffset]=(colour>>11 & 0x1F) <<_brightness;
+      buffer[_greenOffset]=(colour>>6 & 0x1F) <<_brightness;
+      buffer[_blueOffset]=(colour>>1 & 0x1F) <<_brightness;
+    } // else leave buffer black
+
+    // Transmit pixel to driver
+    I2CManager.write(_I2CAddress,buffer,4 +_bytesPerPixel);
+    buffer[1]=SEESAW_NEOPIXEL_SHOW;
+    I2CManager.write(_I2CAddress,buffer,2);  
   }
   uint16_t*  pixelBuffer = nullptr;
-
+  byte _brightness;
+  byte _bytesPerPixel;
+  byte _redOffset;
+  byte _greenOffset;
+  byte _blueOffset;
+  bool _kHz800; 
 };
 
 #endif