Adafruit_IS31FL3741.h

#ifndef _ADAFRUIT_IS31FL3741_H_
#define _ADAFRUIT_IS31FL3741_H_

#include <Adafruit_BusIO_Register.h>
#include <Adafruit_GFX.h>
#include <Adafruit_I2CDevice.h>
#include <Arduino.h>

#define IS3741_ADDR_DEFAULT 0x30

#define IS3741_COMMANDREGISTER 0xFD
#define IS3741_COMMANDREGISTERLOCK 0xFE
#define IS3741_INTMASKREGISTER 0xF0
#define IS3741_INTSTATUSREGISTER 0xF1
#define IS3741_IDREGISTER 0xFC

#define IS3741_FUNCREG_CONFIG 0x00
#define IS3741_FUNCREG_GCURRENT 0x01
#define IS3741_FUNCREG_RESET 0x3F

// RGB pixel color order permutations
typedef enum {
  // Offset:     R          G          B
  IS3741_RGB = ((0 << 4) | (1 << 2) | (2)), // Encode as R,G,B
  IS3741_RBG = ((0 << 4) | (2 << 2) | (1)), // Encode as R,B,G
  IS3741_GRB = ((1 << 4) | (0 << 2) | (2)), // Encode as G,R,B
  IS3741_GBR = ((2 << 4) | (0 << 2) | (1)), // Encode as G,B,R
  IS3741_BRG = ((1 << 4) | (2 << 2) | (0)), // Encode as B,R,G
  IS3741_BGR = ((2 << 4) | (1 << 2) | (0)), // Encode as B,G,R
} IS3741_order;

// 8-bit gamma correction table for the gamma8() and gamma32() funcs.
static const uint8_t PROGMEM _IS31GammaTable[256] = {
    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
    0,   0,   0,   0,   0,   0,   0,   0,   0,   1,   1,   1,   1,   1,   1,
    1,   1,   1,   1,   1,   1,   2,   2,   2,   2,   2,   2,   2,   2,   3,
    3,   3,   3,   3,   3,   4,   4,   4,   4,   5,   5,   5,   5,   5,   6,
    6,   6,   6,   7,   7,   7,   8,   8,   8,   9,   9,   9,   10,  10,  10,
    11,  11,  11,  12,  12,  13,  13,  13,  14,  14,  15,  15,  16,  16,  17,
    17,  18,  18,  19,  19,  20,  20,  21,  21,  22,  22,  23,  24,  24,  25,
    25,  26,  27,  27,  28,  29,  29,  30,  31,  31,  32,  33,  34,  34,  35,
    36,  37,  38,  38,  39,  40,  41,  42,  42,  43,  44,  45,  46,  47,  48,
    49,  50,  51,  52,  53,  54,  55,  56,  57,  58,  59,  60,  61,  62,  63,
    64,  65,  66,  68,  69,  70,  71,  72,  73,  75,  76,  77,  78,  80,  81,
    82,  84,  85,  86,  88,  89,  90,  92,  93,  94,  96,  97,  99,  100, 102,
    103, 105, 106, 108, 109, 111, 112, 114, 115, 117, 119, 120, 122, 124, 125,
    127, 129, 130, 132, 134, 136, 137, 139, 141, 143, 145, 146, 148, 150, 152,
    154, 156, 158, 160, 162, 164, 166, 168, 170, 172, 174, 176, 178, 180, 182,
    184, 186, 188, 191, 193, 195, 197, 199, 202, 204, 206, 209, 211, 213, 215,
    218, 220, 223, 225, 227, 230, 232, 235, 237, 240, 242, 245, 247, 250, 252,
    255};

// BASE IS31 CLASSES -------------------------------------------------------

/**************************************************************************/
/**************************************************************************/
class Adafruit_IS31FL3741 {
public:
  Adafruit_IS31FL3741() {}
  bool begin(uint8_t addr = IS3741_ADDR_DEFAULT, TwoWire *theWire = &Wire);
  bool reset(void);
  bool enable(bool en);

  bool unlock(void);

  bool setGlobalCurrent(uint8_t current);
  uint8_t getGlobalCurrent(void);

  bool setLEDscaling(uint16_t lednum, uint8_t scale);
  bool setLEDscaling(uint8_t scale);

  bool setLEDPWM(uint16_t lednum, uint8_t pwm);
  bool fill(uint8_t fillpwm = 0);

  inline void show(void) {}

  // Although Adafruit_IS31FL3741 itself has no concept of color, most of
  // its subclasses do. These color-related operations go here so that all
  // subclasses have access. Any 'packed' 24-bit colors received or returned
  // by these functions are always in 0xRRGGBB order; RGB reordering for
  // specific devices takes place elsewhere, in subclasses.

  static uint16_t color565(uint8_t red, uint8_t green, uint8_t blue) {
    return ((red & 0xF8) << 8) | ((green & 0xFC) << 3) | (blue >> 3);
  }

  static uint16_t color565(uint32_t color) {
    return ((color >> 8) & 0xF800) | ((color >> 5) & 0x07E0) |
           ((color >> 3) & 0x001F);
  }

  static uint32_t Color(uint8_t r, uint8_t g, uint8_t b) {
    return ((uint32_t)r << 16) | ((uint32_t)g << 8) | b;
  }

  static uint8_t gamma8(uint8_t x) {
    return pgm_read_byte(&_IS31GammaTable[x]); // 0-255 in, 0-255 out
  }

  // These are documented in .cpp file:
  static uint32_t gamma32(uint32_t x);
  static uint32_t ColorHSV(uint16_t hue, uint8_t sat = 255, uint8_t val = 255);

protected:
  bool selectPage(uint8_t page);
  bool setLEDvalue(uint8_t first_page, uint16_t lednum, uint8_t value);
  bool fillTwoPages(uint8_t first_page, uint8_t value);

  int8_t _page = -1; 
  Adafruit_I2CDevice *_i2c_dev = NULL; 
};

/**************************************************************************/
/**************************************************************************/
class Adafruit_IS31FL3741_buffered : public Adafruit_IS31FL3741 {
public:
  Adafruit_IS31FL3741_buffered();
  bool begin(uint8_t addr = IS3741_ADDR_DEFAULT, TwoWire *theWire = &Wire);
  void show(void); // DON'T const this
  uint8_t *getBuffer(void) { return &ledbuf[1]; } // See notes in show()
protected:
  uint8_t ledbuf[352]; 
};

// INTERMEDIARY CLASSES FOR COLORS AND GFX ---------------------------------

/**************************************************************************/
/**************************************************************************/
class Adafruit_IS31FL3741_ColorOrder {
public:
  Adafruit_IS31FL3741_ColorOrder(IS3741_order order)
      : rOffset((order >> 4) & 3), gOffset((order >> 2) & 3),
        bOffset(order & 3) {}
  uint8_t rOffset; 
  uint8_t gOffset; 
  uint8_t bOffset; 
};

/**************************************************************************/
/**************************************************************************/
class Adafruit_IS31FL3741_colorGFX : public Adafruit_IS31FL3741,
                                     public Adafruit_IS31FL3741_ColorOrder,
                                     public Adafruit_GFX {
public:
  Adafruit_IS31FL3741_colorGFX(uint8_t width, uint8_t height,
                               IS3741_order order);
  // Overload the base (monochrome) fill() with a GFX RGB565-style color.
  void fill(uint16_t color = 0);
};

/**************************************************************************/
/**************************************************************************/
class Adafruit_IS31FL3741_colorGFX_buffered
    : public Adafruit_IS31FL3741_buffered,
      public Adafruit_IS31FL3741_ColorOrder,
      public Adafruit_GFX {
public:
  Adafruit_IS31FL3741_colorGFX_buffered(uint8_t width, uint8_t height,
                                        IS3741_order order);
  // Overload the base (monochrome) fill() with a GFX RGB565-style color.
  void fill(uint16_t color = 0);
};

/* =======================================================================
   So, IN PRINCIPLE, additional classes Adafruit_IS31FL3741_monoGFX and
   Adafruit_IS31FL3741_monoGFX_buffered could go here for hypothetical
   single-color "grayscale" matrices -- they'd be similar to the two
   colorGFX classes above, but without inheriting ColorOrder. Since no
   actual hardware along such lines currently exists, they are not
   implemented, but this is where they'd be. I've got deadlines.

   Now we'll build on the classes above to create specific LED board
   varieties. These "complete" items are then instantiated in user code.
   There are two of each -- a direct (unbuffered) and buffered version.
   It's done this way (rather than a single class with a buffer flag) to
   avoid dynamic allocation -- object & buffer just go on heap or stack
   as needed (the optional canvas in glasses is an exception).
   =======================================================================*/

/**************************************************************************/
/**************************************************************************/
class Adafruit_IS31FL3741_EVB : public Adafruit_IS31FL3741_colorGFX {
public:
  Adafruit_IS31FL3741_EVB(IS3741_order order = IS3741_BGR)
      : Adafruit_IS31FL3741_colorGFX(9, 13, order) {}
  void drawPixel(int16_t x, int16_t y, uint16_t color);
};

/**************************************************************************/
/**************************************************************************/
class Adafruit_IS31FL3741_EVB_buffered
    : public Adafruit_IS31FL3741_colorGFX_buffered {
public:
  Adafruit_IS31FL3741_EVB_buffered(IS3741_order order = IS3741_BGR)
      : Adafruit_IS31FL3741_colorGFX_buffered(9, 13, order) {}
  void drawPixel(int16_t x, int16_t y, uint16_t color);
};

/**************************************************************************/
/**************************************************************************/
class Adafruit_IS31FL3741_QT : public Adafruit_IS31FL3741_colorGFX {
public:
  Adafruit_IS31FL3741_QT(IS3741_order order = IS3741_BGR)
      : Adafruit_IS31FL3741_colorGFX(13, 9, order) {}
  void drawPixel(int16_t x, int16_t y, uint16_t color);
};

/**************************************************************************/
/**************************************************************************/
class Adafruit_IS31FL3741_QT_buffered
    : public Adafruit_IS31FL3741_colorGFX_buffered {
public:
  Adafruit_IS31FL3741_QT_buffered(IS3741_order order = IS3741_BGR)
      : Adafruit_IS31FL3741_colorGFX_buffered(13, 9, order) {}
  void drawPixel(int16_t x, int16_t y, uint16_t color);
};

/* =======================================================================
   This is the newer and simpler way (to the user) of using Adafruit
   EyeLights LED glasses. Declaring an EyeLights object (direct or
   buffered) gets you the matrix and rings automatically; no need to
   instantiate as separate objects, nor does one need to explicitly
   declare a base Adafruit_IS31FL3741 object and pass it in. Internally
   the code has a few more layers but the user doesn't need to see that.
   =======================================================================*/

/**************************************************************************/
/**************************************************************************/
class Adafruit_EyeLights_Ring_Base {
public:
  Adafruit_EyeLights_Ring_Base(void *parent, bool isRight);
  uint8_t numPixels(void) const { return 24; }
  void setBrightness(uint8_t b) { _brightness = b + 1; }

protected:
  uint16_t _brightness = 256; 
  void *parent;               
  const uint16_t *ring_map;   
};

/**************************************************************************/
/**************************************************************************/
class Adafruit_EyeLights_Ring : public Adafruit_EyeLights_Ring_Base {
public:
  Adafruit_EyeLights_Ring(void *parent, bool isRight)
      : Adafruit_EyeLights_Ring_Base(parent, isRight) {}
  void setPixelColor(int16_t n, uint32_t color);
  void setPixelColor(int16_t n, uint8_t t, uint8_t g, uint8_t b);
  void fill(uint32_t color);
  void fill(uint8_t r, uint8_t g, uint8_t b);
};

/**************************************************************************/
/**************************************************************************/
class Adafruit_EyeLights_Ring_buffered : public Adafruit_EyeLights_Ring_Base {
public:
  Adafruit_EyeLights_Ring_buffered(void *parent, bool isRight)
      : Adafruit_EyeLights_Ring_Base(parent, isRight) {}
  void setPixelColor(int16_t n, uint32_t color);
  void setPixelColor(int16_t n, uint8_t r, uint8_t g, uint8_t b);
  void fill(uint32_t color);
  void fill(uint8_t r, uint8_t g, uint8_t b);
};

/**************************************************************************/
/**************************************************************************/
class Adafruit_EyeLights_Base {
public:
  Adafruit_EyeLights_Base(bool withCanvas) {
    if (withCanvas)
      canvas = new GFXcanvas16(18 * 3, 5 * 3);
  }
  GFXcanvas16 *getCanvas(void) const { return canvas; }

protected:
  GFXcanvas16 *canvas = NULL; 
};

/**************************************************************************/
/**************************************************************************/
class Adafruit_EyeLights : public Adafruit_EyeLights_Base,
                           public Adafruit_IS31FL3741_colorGFX {
public:
  Adafruit_EyeLights(bool withCanvas = false, IS3741_order order = IS3741_BGR)
      : Adafruit_EyeLights_Base(withCanvas),
        Adafruit_IS31FL3741_colorGFX(18, 5, order), left_ring(this, false),
        right_ring(this, true) {}
  void drawPixel(int16_t x, int16_t y, uint16_t color);
  void scale();
  Adafruit_EyeLights_Ring left_ring;  
  Adafruit_EyeLights_Ring right_ring; 
};

/**************************************************************************/
/**************************************************************************/
class Adafruit_EyeLights_buffered
    : public Adafruit_EyeLights_Base,
      public Adafruit_IS31FL3741_colorGFX_buffered {
public:
  Adafruit_EyeLights_buffered(bool withCanvas = false,
                              IS3741_order order = IS3741_BGR)
      : Adafruit_EyeLights_Base(withCanvas),
        Adafruit_IS31FL3741_colorGFX_buffered(18, 5, order),
        left_ring(this, false), right_ring(this, true) {}
  void drawPixel(int16_t x, int16_t y, uint16_t color);
  void scale();
  Adafruit_EyeLights_Ring_buffered left_ring;  
  Adafruit_EyeLights_Ring_buffered right_ring; 
};

/* =======================================================================
   This is the older (likely deprecated) way of using Adafruit EyeLights.
   It requires a few extra steps of the user for object declarations, and
   doesn't handle different RGB color orders.
   =======================================================================*/

/**************************************************************************/
/**************************************************************************/
class Adafruit_IS31FL3741_GlassesMatrix : public Adafruit_GFX {
public:
  Adafruit_IS31FL3741_GlassesMatrix(Adafruit_IS31FL3741 *controller)
      : Adafruit_GFX(18, 5), _is31(controller) {}
  void drawPixel(int16_t x, int16_t y, uint16_t color);

protected:
  Adafruit_IS31FL3741 *_is31 = NULL; 
};

/**************************************************************************/
/**************************************************************************/
class Adafruit_IS31FL3741_GlassesRing {
public:
  Adafruit_IS31FL3741_GlassesRing(Adafruit_IS31FL3741 *controller,
                                  bool isRight);
  void setPixelColor(int16_t n, uint32_t color);
  void fill(uint32_t color);
  uint8_t numPixels(void) const { return 24; }
  void setBrightness(uint8_t b) { _brightness = b + 1; }

protected:
  Adafruit_IS31FL3741 *_is31 = NULL; 
  uint16_t _brightness = 256;        
  const uint16_t *ring_map;          
};

/**************************************************************************/
/**************************************************************************/
class Adafruit_IS31FL3741_GlassesLeftRing
    : public Adafruit_IS31FL3741_GlassesRing {
public:
  Adafruit_IS31FL3741_GlassesLeftRing(Adafruit_IS31FL3741 *controller)
      : Adafruit_IS31FL3741_GlassesRing(controller, false) {}
};

/**************************************************************************/
/**************************************************************************/
class Adafruit_IS31FL3741_GlassesRightRing
    : public Adafruit_IS31FL3741_GlassesRing {
public:
  Adafruit_IS31FL3741_GlassesRightRing(Adafruit_IS31FL3741 *controller)
      : Adafruit_IS31FL3741_GlassesRing(controller, true) {}
};

/**************************************************************************/
/**************************************************************************/
class Adafruit_IS31FL3741_GlassesMatrix_buffered : public Adafruit_GFX {
public:
  Adafruit_IS31FL3741_GlassesMatrix_buffered(
      Adafruit_IS31FL3741_buffered *controller = NULL, bool withCanvas = false);
  void drawPixel(int16_t x, int16_t y, uint16_t color);
  void scale();
  GFXcanvas16 *getCanvas(void) const { return canvas; }

protected:
  Adafruit_IS31FL3741_buffered *_is31; 
  GFXcanvas16 *canvas = NULL;          
};

/**************************************************************************/
/**************************************************************************/
class Adafruit_IS31FL3741_GlassesRing_buffered {
public:
  Adafruit_IS31FL3741_GlassesRing_buffered(
      Adafruit_IS31FL3741_buffered *controller, bool isRight);
  void setPixelColor(int16_t n, uint32_t color);
  void fill(uint32_t color);
  uint8_t numPixels(void) const { return 24; }
  void setBrightness(uint8_t b) { _brightness = b + 1; }

protected:
  Adafruit_IS31FL3741_buffered *_is31 = NULL; 
  uint16_t _brightness = 256;                 
  const uint16_t *ring_map;                   
};

/**************************************************************************/
/**************************************************************************/
class Adafruit_IS31FL3741_GlassesLeftRing_buffered
    : public Adafruit_IS31FL3741_GlassesRing_buffered {
public:
  Adafruit_IS31FL3741_GlassesLeftRing_buffered(
      Adafruit_IS31FL3741_buffered *controller)
      : Adafruit_IS31FL3741_GlassesRing_buffered(controller, false) {}
};

/**************************************************************************/
/**************************************************************************/
class Adafruit_IS31FL3741_GlassesRightRing_buffered
    : public Adafruit_IS31FL3741_GlassesRing_buffered {
public:
  Adafruit_IS31FL3741_GlassesRightRing_buffered(
      Adafruit_IS31FL3741_buffered *controller)
      : Adafruit_IS31FL3741_GlassesRing_buffered(controller, true) {}
};

#endif // _ADAFRUIT_IS31FL3741_H_