Adafruit_NeoPXL8.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2017 P Burgess for Adafruit Industries
//
// SPDX-License-Identifier: MIT

#ifndef _ADAFRUIT_NEOPXL8_H_
#define _ADAFRUIT_NEOPXL8_H_

#include <Adafruit_NeoPixel.h>
#if defined(ARDUINO_ARCH_RP2040)
#include "../../hardware_dma/include/hardware/dma.h"
#include "hardware/irq.h"
#include "hardware/pio.h"
#include "pico/mutex.h"
#elif defined(CONFIG_IDF_TARGET_ESP32S3)
#include <driver/periph_ctrl.h>
#include <esp_private/gdma.h>
#include <esp_rom_gpio.h>
#include <hal/dma_types.h>
#include <hal/gpio_hal.h>
#if defined(ESP_IDF_VERSION_MAJOR) && (ESP_IDF_VERSION_MAJOR >= 5)
#include <hal/gpio_ll.h>
#endif
#include <soc/lcd_cam_struct.h>
#else // SAMD
#include <Adafruit_ZeroDMA.h>
#endif

// NEOPXL8 CLASS -----------------------------------------------------------

class Adafruit_NeoPXL8 : public Adafruit_NeoPixel {

public:
  Adafruit_NeoPXL8(uint16_t n, int8_t *p = NULL, neoPixelType t = NEO_GRB);
  ~Adafruit_NeoPXL8(void);

  bool begin(bool dbuf = false);

  void show(void);

  void stage(void);

  bool canShow(void) const;

  bool canStage(void) const;

  // Brightness is stored differently here than in normal NeoPixel library.
  // In either case it's *specified* the same: 0 (off) to 255 (brightest).
  // Classic NeoPixel rearranges this internally so 0 is max, 1 is off and
  // 255 is just below max...it's a decision based on how fixed-point math
  // is handled in that code. Here it's stored internally as 1 (off) to
  // 256 (brightest), requiring a 16-bit value.

  void setBrightness(uint8_t b) { brightness = (uint16_t)b + 1; }

  uint8_t getBrightness(void) const { return brightness - 1; }

  void setLatchTime(uint16_t us = 300) { latchtime = us; };

#if defined(ARDUINO_ARCH_RP2040)

  void dma_callback(void);
#endif

protected:
#if defined(ARDUINO_ARCH_RP2040)
  PIO pio = NULL; 
  uint sm = -1;   
  uint offset = 0;
  int dma_channel;               
  dma_channel_config dma_config; 
#elif defined(CONFIG_IDF_TARGET_ESP32S3)
  gdma_channel_handle_t dma_chan; 
  dma_descriptor_t *desc;         
  uint8_t *allocAddr;             
  uint32_t *alignedAddr[2];       
#else // SAMD
  Adafruit_ZeroDMA dma;     
  DmacDescriptor *desc;     
  uint8_t *allocAddr;       
  uint32_t *alignedAddr[2]; 
#endif
  int8_t pins[8];                    
  uint8_t bitmask[8];                
  uint8_t *dmaBuf[2] = {NULL, NULL}; 
  uint16_t brightness = 255;         
  bool staged;                       
  uint16_t latchtime = 300;          
  uint8_t dbuf_index = 0;            
};

// NEOPXL8HDR CLASS --------------------------------------------------------

class Adafruit_NeoPXL8HDR : public Adafruit_NeoPXL8 {

public:
  Adafruit_NeoPXL8HDR(uint16_t n, int8_t *p = NULL, neoPixelType t = NEO_GRB);
  ~Adafruit_NeoPXL8HDR();

  bool begin(bool blend = false, uint8_t bits = 4, bool dbuf = false);

  void setBrightness(uint8_t b);

  void setBrightness(uint16_t b, float y);

  void setBrightness(uint16_t r, uint16_t g, uint16_t b);

  void setBrightness(uint16_t r, uint16_t g, uint16_t b, uint16_t w);

  void setBrightness(uint16_t r, uint16_t g, uint16_t b, float y);

  void setBrightness(uint16_t r, uint16_t g, uint16_t b, uint16_t w, float y);

  void show(void);

  void refresh(void);

  void stage(void) const {};

  bool canStage(void) const { return true; }

  bool canShow(void) const { return true; }

  void setPixelColor(uint16_t n, uint8_t r, uint8_t g, uint8_t b);

  void setPixelColor(uint16_t n, uint8_t r, uint8_t g, uint8_t b, uint8_t w);

  void setPixelColor(uint16_t n, uint32_t c);

  void set16(uint16_t n, uint16_t r, uint16_t g, uint16_t b, uint16_t w = 0);

  uint32_t getPixelColor(uint16_t n) const;

  void get16(uint16_t n, uint16_t *r, uint16_t *g, uint16_t *b,
             uint16_t *w = NULL) const;

  uint16_t *getPixels(void) const { return pixel_buf[2]; }

  uint32_t getFPS(void) const { return fps; }

  void clear(void) { memset(pixel_buf[2], 0, numBytes * sizeof(uint16_t)); }

protected:
  void calc_gamma_table(void);
  float gfactor;                               
  uint16_t *pixel_buf[3] = {NULL, NULL, NULL}; 
  uint16_t *dither_table = NULL;               
  uint32_t last_show_time = 0;                 
  uint32_t avg_show_interval = 0;              
  uint32_t fps = 0;                            
  uint32_t last_fps_time = 0;                  
  uint16_t g16[4][256];                        
  uint16_t brightness_rgbw[4];                 
  uint8_t dither_bits;                         
  uint8_t dither_index = 0;                    
  uint8_t stage_index = 0;                     
  volatile bool new_pixels = true;             
#if defined(ARDUINO_ARCH_RP2040)
  mutex_t mutex; 
#elif defined(CONFIG_IDF_TARGET_ESP32S3)
  SemaphoreHandle_t mutex; 
#endif
};

// The DEFAULT_PINS macros provide shortcuts for the most commonly-used pin
// lists on certain boards. For example, with a Feather M0, the default list
// will match an unaltered, factory-fresh NeoPXL8 FeatherWing M0. If ANY pins
// are changed on the FeatherWing, or if using a different pin sequence than
// these defaults, a user sketch must provide its own correct pin list.
// These may work for sloppy quick code but are NOT true in all situations!
#if defined(ARDUINO_ADAFRUIT_FEATHER_RP2040_SCORPIO)
#define NEOPXL8_DEFAULT_PINS                                                   \
  { 16, 17, 18, 19, 20, 21, 22, 23 }
#elif defined(ADAFRUIT_FEATHER_M0) || defined(ARDUINO_SAMD_FEATHER_M0_EXPRESS)
#define NEOPXL8_DEFAULT_PINS                                                   \
  { PIN_SERIAL1_RX, PIN_SERIAL1_TX, MISO, 13, 5, SDA, A4, A3 }
#elif defined(ADAFRUIT_FEATHER_M4_EXPRESS) ||                                  \
    defined(ARDUINO_ADAFRUIT_FEATHER_ESP32S3) ||                               \
    defined(ARDUINO_ADAFRUIT_FEATHER_ESP32S3_NOPSRAM)
#define NEOPXL8_DEFAULT_PINS                                                   \
  { SCK, 5, 9, 6, 13, 12, 11, 10 }
#elif defined(ADAFRUIT_METRO_M4_EXPRESS)
#define NEOPXL8_DEFAULT_PINS                                                   \
  { 7, 4, 5, 6, 3, 2, 10, 11 }
#elif defined(ADAFRUIT_GRAND_CENTRAL_M4)
#define NEOPXL8_DEFAULT_PINS                                                   \
  { 30, 31, 32, 33, 36, 37, 34, 35 }
#elif defined(ARDUINO_ADAFRUIT_FEATHER_RP2040)
#define NEOPXL8_DEFAULT_PINS                                                   \
  { 6, 7, 9, 8, 13, 12, 11, 10 }
#else
#define NEOPXL8_DEFAULT_PINS                                                   \
  { 0, 1, 2, 3, 4, 5, 6, 7 } 
#endif

#endif // _ADAFRUIT_NEOPXL8_H_