mirror of
https://github.com/bbulkow/FastLED-idf.git
synced 2025-06-25 01:11:39 +02:00
Check in the current Arduino FastLED code, but nothing
compiles yet.
This commit is contained in:
Brian Bulkowski
6
CMakeLists.txt
Normal file
6
CMakeLists.txt
Normal file
@ -0,0 +1,6 @@
|
||||
# The following lines of boilerplate have to be in your project's
|
||||
# CMakeLists in this exact order for cmake to work correctly
|
||||
cmake_minimum_required(VERSION 3.5)
|
||||
|
||||
include($ENV{IDF_PATH}/tools/cmake/project.cmake)
|
||||
project(hello-world)
|
||||
9
Makefile
Normal file
9
Makefile
Normal file
@ -0,0 +1,9 @@
|
||||
#
|
||||
# This is a project Makefile. It is assumed the directory this Makefile resides in is a
|
||||
# project subdirectory.
|
||||
#
|
||||
|
||||
PROJECT_NAME := hello-world
|
||||
|
||||
include $(IDF_PATH)/make/project.mk
|
||||
|
||||
9
components/FastLED-idf/ESP-IDF.md
Normal file
9
components/FastLED-idf/ESP-IDF.md
Normal file
@ -0,0 +1,9 @@
|
||||
# Port to ESP-IDF
|
||||
|
||||
Describe what had to be done, when we did it
|
||||
|
||||
# Environment
|
||||
|
||||
This port is to be used with ESP-IDF version 4.x, which went GA on about Feb, 2020.
|
||||
|
||||
The FastLED code is vintage 3.3, which includes sophisticated ESP32 support.
|
||||
275
components/FastLED-idf/FastLED.cpp
Normal file
275
components/FastLED-idf/FastLED.cpp
Normal file
@ -0,0 +1,275 @@
|
||||
#define FASTLED_INTERNAL
|
||||
#include "FastLED.h"
|
||||
|
||||
|
||||
#if defined(__SAM3X8E__)
|
||||
volatile uint32_t fuckit;
|
||||
#endif
|
||||
|
||||
FASTLED_NAMESPACE_BEGIN
|
||||
|
||||
void *pSmartMatrix = NULL;
|
||||
|
||||
CFastLED FastLED;
|
||||
|
||||
CLEDController *CLEDController::m_pHead = NULL;
|
||||
CLEDController *CLEDController::m_pTail = NULL;
|
||||
static uint32_t lastshow = 0;
|
||||
|
||||
uint32_t _frame_cnt=0;
|
||||
uint32_t _retry_cnt=0;
|
||||
|
||||
// uint32_t CRGB::Squant = ((uint32_t)((__TIME__[4]-'0') * 28))<<16 | ((__TIME__[6]-'0')*50)<<8 | ((__TIME__[7]-'0')*28);
|
||||
|
||||
CFastLED::CFastLED() {
|
||||
// clear out the array of led controllers
|
||||
// m_nControllers = 0;
|
||||
m_Scale = 255;
|
||||
m_nFPS = 0;
|
||||
m_pPowerFunc = NULL;
|
||||
m_nPowerData = 0xFFFFFFFF;
|
||||
}
|
||||
|
||||
CLEDController &CFastLED::addLeds(CLEDController *pLed,
|
||||
struct CRGB *data,
|
||||
int nLedsOrOffset, int nLedsIfOffset) {
|
||||
int nOffset = (nLedsIfOffset > 0) ? nLedsOrOffset : 0;
|
||||
int nLeds = (nLedsIfOffset > 0) ? nLedsIfOffset : nLedsOrOffset;
|
||||
|
||||
pLed->init();
|
||||
pLed->setLeds(data + nOffset, nLeds);
|
||||
FastLED.setMaxRefreshRate(pLed->getMaxRefreshRate(),true);
|
||||
return *pLed;
|
||||
}
|
||||
|
||||
void CFastLED::show(uint8_t scale) {
|
||||
// guard against showing too rapidly
|
||||
while(m_nMinMicros && ((micros()-lastshow) < m_nMinMicros));
|
||||
lastshow = micros();
|
||||
|
||||
// If we have a function for computing power, use it!
|
||||
if(m_pPowerFunc) {
|
||||
scale = (*m_pPowerFunc)(scale, m_nPowerData);
|
||||
}
|
||||
|
||||
CLEDController *pCur = CLEDController::head();
|
||||
while(pCur) {
|
||||
uint8_t d = pCur->getDither();
|
||||
if(m_nFPS < 100) { pCur->setDither(0); }
|
||||
pCur->showLeds(scale);
|
||||
pCur->setDither(d);
|
||||
pCur = pCur->next();
|
||||
}
|
||||
countFPS();
|
||||
}
|
||||
|
||||
int CFastLED::count() {
|
||||
int x = 0;
|
||||
CLEDController *pCur = CLEDController::head();
|
||||
while( pCur) {
|
||||
x++;
|
||||
pCur = pCur->next();
|
||||
}
|
||||
return x;
|
||||
}
|
||||
|
||||
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) {
|
||||
while(m_nMinMicros && ((micros()-lastshow) < m_nMinMicros));
|
||||
lastshow = micros();
|
||||
|
||||
// If we have a function for computing power, use it!
|
||||
if(m_pPowerFunc) {
|
||||
scale = (*m_pPowerFunc)(scale, m_nPowerData);
|
||||
}
|
||||
|
||||
CLEDController *pCur = CLEDController::head();
|
||||
while(pCur) {
|
||||
uint8_t d = pCur->getDither();
|
||||
if(m_nFPS < 100) { pCur->setDither(0); }
|
||||
pCur->showColor(color, scale);
|
||||
pCur->setDither(d);
|
||||
pCur = pCur->next();
|
||||
}
|
||||
countFPS();
|
||||
}
|
||||
|
||||
void CFastLED::clear(bool writeData) {
|
||||
if(writeData) {
|
||||
showColor(CRGB(0,0,0), 0);
|
||||
}
|
||||
clearData();
|
||||
}
|
||||
|
||||
void CFastLED::clearData() {
|
||||
CLEDController *pCur = CLEDController::head();
|
||||
while(pCur) {
|
||||
pCur->clearLedData();
|
||||
pCur = pCur->next();
|
||||
}
|
||||
}
|
||||
|
||||
void CFastLED::delay(unsigned long ms) {
|
||||
unsigned long start = millis();
|
||||
do {
|
||||
#ifndef FASTLED_ACCURATE_CLOCK
|
||||
// make sure to allow at least one ms to pass to ensure the clock moves
|
||||
// forward
|
||||
::delay(1);
|
||||
#endif
|
||||
show();
|
||||
yield();
|
||||
}
|
||||
while((millis()-start) < ms);
|
||||
}
|
||||
|
||||
void CFastLED::setTemperature(const struct CRGB & temp) {
|
||||
CLEDController *pCur = CLEDController::head();
|
||||
while(pCur) {
|
||||
pCur->setTemperature(temp);
|
||||
pCur = pCur->next();
|
||||
}
|
||||
}
|
||||
|
||||
void CFastLED::setCorrection(const struct CRGB & correction) {
|
||||
CLEDController *pCur = CLEDController::head();
|
||||
while(pCur) {
|
||||
pCur->setCorrection(correction);
|
||||
pCur = pCur->next();
|
||||
}
|
||||
}
|
||||
|
||||
void CFastLED::setDither(uint8_t ditherMode) {
|
||||
CLEDController *pCur = CLEDController::head();
|
||||
while(pCur) {
|
||||
pCur->setDither(ditherMode);
|
||||
pCur = pCur->next();
|
||||
}
|
||||
}
|
||||
|
||||
//
|
||||
// template<int m, int n> void transpose8(unsigned char A[8], unsigned char B[8]) {
|
||||
// uint32_t x, y, t;
|
||||
//
|
||||
// // Load the array and pack it into x and y.
|
||||
// y = *(unsigned int*)(A);
|
||||
// x = *(unsigned int*)(A+4);
|
||||
//
|
||||
// // x = (A[0]<<24) | (A[m]<<16) | (A[2*m]<<8) | A[3*m];
|
||||
// // y = (A[4*m]<<24) | (A[5*m]<<16) | (A[6*m]<<8) | A[7*m];
|
||||
//
|
||||
// // 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);
|
||||
//
|
||||
// // final transform
|
||||
// t = (x & 0xF0F0F0F0) | ((y >> 4) & 0x0F0F0F0F);
|
||||
// y = ((x << 4) & 0xF0F0F0F0) | (y & 0x0F0F0F0F);
|
||||
// x = t;
|
||||
//
|
||||
// B[7*n] = y; y >>= 8;
|
||||
// B[6*n] = y; y >>= 8;
|
||||
// B[5*n] = y; y >>= 8;
|
||||
// B[4*n] = y;
|
||||
//
|
||||
// B[3*n] = x; x >>= 8;
|
||||
// B[2*n] = x; x >>= 8;
|
||||
// B[n] = x; x >>= 8;
|
||||
// B[0] = x;
|
||||
// // B[0]=x>>24; B[n]=x>>16; B[2*n]=x>>8; B[3*n]=x>>0;
|
||||
// // B[4*n]=y>>24; B[5*n]=y>>16; B[6*n]=y>>8; B[7*n]=y>>0;
|
||||
// }
|
||||
//
|
||||
// void transposeLines(Lines & out, Lines & in) {
|
||||
// transpose8<1,2>(in.bytes, out.bytes);
|
||||
// transpose8<1,2>(in.bytes + 8, out.bytes + 1);
|
||||
// }
|
||||
|
||||
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();
|
||||
}
|
||||
}
|
||||
|
||||
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;
|
||||
}
|
||||
}
|
||||
|
||||
extern "C" int atexit(void (* /*func*/ )()) { return 0; }
|
||||
|
||||
#ifdef FASTLED_NEEDS_YIELD
|
||||
extern "C" void yield(void) { }
|
||||
#endif
|
||||
|
||||
#ifdef NEED_CXX_BITS
|
||||
namespace __cxxabiv1
|
||||
{
|
||||
#if !defined(ESP8266) && !defined(ESP32)
|
||||
extern "C" void __cxa_pure_virtual (void) {}
|
||||
#endif
|
||||
|
||||
/* guard variables */
|
||||
|
||||
/* The ABI requires a 64-bit type. */
|
||||
__extension__ typedef int __guard __attribute__((mode(__DI__)));
|
||||
|
||||
extern "C" int __cxa_guard_acquire (__guard *) __attribute__((weak));
|
||||
extern "C" void __cxa_guard_release (__guard *) __attribute__((weak));
|
||||
extern "C" void __cxa_guard_abort (__guard *) __attribute__((weak));
|
||||
|
||||
extern "C" int __cxa_guard_acquire (__guard *g)
|
||||
{
|
||||
return !*(char *)(g);
|
||||
}
|
||||
|
||||
extern "C" void __cxa_guard_release (__guard *g)
|
||||
{
|
||||
*(char *)g = 1;
|
||||
}
|
||||
|
||||
extern "C" void __cxa_guard_abort (__guard *)
|
||||
{
|
||||
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
FASTLED_NAMESPACE_END
|
||||
592
components/FastLED-idf/FastLED.h
Normal file
592
components/FastLED-idf/FastLED.h
Normal file
@ -0,0 +1,592 @@
|
||||
#ifndef __INC_FASTSPI_LED2_H
|
||||
#define __INC_FASTSPI_LED2_H
|
||||
|
||||
///@file FastLED.h
|
||||
/// central include file for FastLED, defines the CFastLED class/object
|
||||
|
||||
#if (__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 4)
|
||||
#define FASTLED_HAS_PRAGMA_MESSAGE
|
||||
#endif
|
||||
|
||||
#define FASTLED_VERSION 3003002
|
||||
#ifndef FASTLED_INTERNAL
|
||||
# ifdef FASTLED_HAS_PRAGMA_MESSAGE
|
||||
# pragma message "FastLED version 3.003.003"
|
||||
# else
|
||||
# warning FastLED version 3.003.003 (Not really a warning, just telling you here.)
|
||||
# endif
|
||||
#endif
|
||||
|
||||
#ifndef __PROG_TYPES_COMPAT__
|
||||
#define __PROG_TYPES_COMPAT__
|
||||
#endif
|
||||
|
||||
#ifdef SmartMatrix_h
|
||||
#include <SmartMatrix.h>
|
||||
#endif
|
||||
|
||||
#ifdef DmxSimple_h
|
||||
#include <DmxSimple.h>
|
||||
#endif
|
||||
|
||||
#ifdef DmxSerial_h
|
||||
#include <DMXSerial.h>
|
||||
#endif
|
||||
|
||||
#include <stdint.h>
|
||||
|
||||
#include "cpp_compat.h"
|
||||
|
||||
#include "fastled_config.h"
|
||||
#include "led_sysdefs.h"
|
||||
|
||||
// Utility functions
|
||||
#include "fastled_delay.h"
|
||||
#include "bitswap.h"
|
||||
|
||||
#include "controller.h"
|
||||
#include "fastpin.h"
|
||||
#include "fastspi_types.h"
|
||||
#include "dmx.h"
|
||||
|
||||
#include "platforms.h"
|
||||
#include "fastled_progmem.h"
|
||||
|
||||
#include "lib8tion.h"
|
||||
#include "pixeltypes.h"
|
||||
#include "hsv2rgb.h"
|
||||
#include "colorutils.h"
|
||||
#include "pixelset.h"
|
||||
#include "colorpalettes.h"
|
||||
|
||||
#include "noise.h"
|
||||
#include "power_mgt.h"
|
||||
|
||||
#include "fastspi.h"
|
||||
#include "chipsets.h"
|
||||
|
||||
FASTLED_NAMESPACE_BEGIN
|
||||
|
||||
/// definitions for the spi chipset constants
|
||||
enum ESPIChipsets {
|
||||
LPD6803,
|
||||
LPD8806,
|
||||
WS2801,
|
||||
WS2803,
|
||||
SM16716,
|
||||
P9813,
|
||||
APA102,
|
||||
SK9822,
|
||||
DOTSTAR
|
||||
};
|
||||
|
||||
enum ESM { SMART_MATRIX };
|
||||
enum OWS2811 { OCTOWS2811,OCTOWS2811_400, OCTOWS2813};
|
||||
enum SWS2812 { WS2812SERIAL };
|
||||
|
||||
#ifdef HAS_PIXIE
|
||||
template<uint8_t DATA_PIN, EOrder RGB_ORDER> class PIXIE : public PixieController<DATA_PIN, RGB_ORDER> {};
|
||||
#endif
|
||||
|
||||
#ifdef FASTLED_HAS_CLOCKLESS
|
||||
template<uint8_t DATA_PIN> class NEOPIXEL : public WS2812Controller800Khz<DATA_PIN, GRB> {};
|
||||
template<uint8_t DATA_PIN, EOrder RGB_ORDER> class SM16703 : public SM16703Controller<DATA_PIN, RGB_ORDER> {};
|
||||
template<uint8_t DATA_PIN, EOrder RGB_ORDER> class TM1829 : public TM1829Controller800Khz<DATA_PIN, RGB_ORDER> {};
|
||||
template<uint8_t DATA_PIN, EOrder RGB_ORDER> class TM1812 : public TM1809Controller800Khz<DATA_PIN, RGB_ORDER> {};
|
||||
template<uint8_t DATA_PIN, EOrder RGB_ORDER> class TM1809 : public TM1809Controller800Khz<DATA_PIN, RGB_ORDER> {};
|
||||
template<uint8_t DATA_PIN, EOrder RGB_ORDER> class TM1804 : public TM1809Controller800Khz<DATA_PIN, RGB_ORDER> {};
|
||||
template<uint8_t DATA_PIN, EOrder RGB_ORDER> class TM1803 : public TM1803Controller400Khz<DATA_PIN, RGB_ORDER> {};
|
||||
template<uint8_t DATA_PIN, EOrder RGB_ORDER> class UCS1903 : public UCS1903Controller400Khz<DATA_PIN, RGB_ORDER> {};
|
||||
template<uint8_t DATA_PIN, EOrder RGB_ORDER> class UCS1903B : public UCS1903BController800Khz<DATA_PIN, RGB_ORDER> {};
|
||||
template<uint8_t DATA_PIN, EOrder RGB_ORDER> class UCS1904 : public UCS1904Controller800Khz<DATA_PIN, RGB_ORDER> {};
|
||||
template<uint8_t DATA_PIN, EOrder RGB_ORDER> class UCS2903 : public UCS2903Controller<DATA_PIN, RGB_ORDER> {};
|
||||
template<uint8_t DATA_PIN, EOrder RGB_ORDER> class WS2812 : public WS2812Controller800Khz<DATA_PIN, RGB_ORDER> {};
|
||||
template<uint8_t DATA_PIN, EOrder RGB_ORDER> class WS2852 : public WS2812Controller800Khz<DATA_PIN, RGB_ORDER> {};
|
||||
template<uint8_t DATA_PIN, EOrder RGB_ORDER> class WS2812B : public WS2812Controller800Khz<DATA_PIN, RGB_ORDER> {};
|
||||
template<uint8_t DATA_PIN, EOrder RGB_ORDER> class GS1903 : public WS2812Controller800Khz<DATA_PIN, RGB_ORDER> {};
|
||||
template<uint8_t DATA_PIN, EOrder RGB_ORDER> class SK6812 : public SK6812Controller<DATA_PIN, RGB_ORDER> {};
|
||||
template<uint8_t DATA_PIN, EOrder RGB_ORDER> class SK6822 : public SK6822Controller<DATA_PIN, RGB_ORDER> {};
|
||||
template<uint8_t DATA_PIN, EOrder RGB_ORDER> class APA106 : public SK6822Controller<DATA_PIN, RGB_ORDER> {};
|
||||
template<uint8_t DATA_PIN, EOrder RGB_ORDER> class PL9823 : public PL9823Controller<DATA_PIN, RGB_ORDER> {};
|
||||
template<uint8_t DATA_PIN, EOrder RGB_ORDER> class WS2811 : public WS2811Controller800Khz<DATA_PIN, RGB_ORDER> {};
|
||||
template<uint8_t DATA_PIN, EOrder RGB_ORDER> class WS2813 : public WS2813Controller<DATA_PIN, RGB_ORDER> {};
|
||||
template<uint8_t DATA_PIN, EOrder RGB_ORDER> class APA104 : public WS2811Controller800Khz<DATA_PIN, RGB_ORDER> {};
|
||||
template<uint8_t DATA_PIN, EOrder RGB_ORDER> class WS2811_400 : public WS2811Controller400Khz<DATA_PIN, RGB_ORDER> {};
|
||||
template<uint8_t DATA_PIN, EOrder RGB_ORDER> class GE8822 : public GE8822Controller800Khz<DATA_PIN, RGB_ORDER> {};
|
||||
template<uint8_t DATA_PIN, EOrder RGB_ORDER> class GW6205 : public GW6205Controller800Khz<DATA_PIN, RGB_ORDER> {};
|
||||
template<uint8_t DATA_PIN, EOrder RGB_ORDER> class GW6205_400 : public GW6205Controller400Khz<DATA_PIN, RGB_ORDER> {};
|
||||
template<uint8_t DATA_PIN, EOrder RGB_ORDER> class LPD1886 : public LPD1886Controller1250Khz<DATA_PIN, RGB_ORDER> {};
|
||||
template<uint8_t DATA_PIN, EOrder RGB_ORDER> class LPD1886_8BIT : public LPD1886Controller1250Khz_8bit<DATA_PIN, RGB_ORDER> {};
|
||||
#ifdef DmxSimple_h
|
||||
template<uint8_t DATA_PIN, EOrder RGB_ORDER> class DMXSIMPLE : public DMXSimpleController<DATA_PIN, RGB_ORDER> {};
|
||||
#endif
|
||||
#ifdef DmxSerial_h
|
||||
template<EOrder RGB_ORDER> class DMXSERIAL : public DMXSerialController<RGB_ORDER> {};
|
||||
#endif
|
||||
#endif
|
||||
|
||||
enum EBlockChipsets {
|
||||
#ifdef PORTA_FIRST_PIN
|
||||
WS2811_PORTA,
|
||||
WS2813_PORTA,
|
||||
WS2811_400_PORTA,
|
||||
TM1803_PORTA,
|
||||
UCS1903_PORTA,
|
||||
#endif
|
||||
#ifdef PORTB_FIRST_PIN
|
||||
WS2811_PORTB,
|
||||
WS2813_PORTB,
|
||||
WS2811_400_PORTB,
|
||||
TM1803_PORTB,
|
||||
UCS1903_PORTB,
|
||||
#endif
|
||||
#ifdef PORTC_FIRST_PIN
|
||||
WS2811_PORTC,
|
||||
WS2813_PORTC,
|
||||
WS2811_400_PORTC,
|
||||
TM1803_PORTC,
|
||||
UCS1903_PORTC,
|
||||
#endif
|
||||
#ifdef PORTD_FIRST_PIN
|
||||
WS2811_PORTD,
|
||||
WS2813_PORTD,
|
||||
WS2811_400_PORTD,
|
||||
TM1803_PORTD,
|
||||
UCS1903_PORTD,
|
||||
#endif
|
||||
#ifdef HAS_PORTDC
|
||||
WS2811_PORTDC,
|
||||
WS2813_PORTDC,
|
||||
WS2811_400_PORTDC,
|
||||
TM1803_PORTDC,
|
||||
UCS1903_PORTDC,
|
||||
#endif
|
||||
};
|
||||
|
||||
#if defined(LIB8_ATTINY)
|
||||
#define NUM_CONTROLLERS 2
|
||||
#else
|
||||
#define NUM_CONTROLLERS 8
|
||||
#endif
|
||||
|
||||
typedef uint8_t (*power_func)(uint8_t scale, uint32_t data);
|
||||
|
||||
/// High level controller interface for FastLED. This class manages controllers, global settings and trackings
|
||||
/// such as brightness, and refresh rates, and provides access functions for driving led data to controllers
|
||||
/// via the show/showColor/clear methods.
|
||||
/// @nosubgrouping
|
||||
class CFastLED {
|
||||
// int m_nControllers;
|
||||
uint8_t m_Scale; ///< The current global brightness scale setting
|
||||
uint16_t m_nFPS; ///< Tracking for current FPS value
|
||||
uint32_t m_nMinMicros; ///< minimum µs between frames, used for capping frame rates.
|
||||
uint32_t m_nPowerData; ///< max power use parameter
|
||||
power_func m_pPowerFunc; ///< function for overriding brightness when using FastLED.show();
|
||||
|
||||
public:
|
||||
CFastLED();
|
||||
|
||||
|
||||
/// Add a CLEDController instance to the world. Exposed to the public to allow people to implement their own
|
||||
/// CLEDController objects or instances. There are two ways to call this method (as well as the other addLeds)
|
||||
/// variations. The first is with 3 arguments, in which case the arguments are the controller, a pointer to
|
||||
/// led data, and the number of leds used by this controller. The second is with 4 arguments, in which case
|
||||
/// the first two arguments are the same, the third argument is an offset into the CRGB data where this controller's
|
||||
/// CRGB data begins, and the fourth argument is the number of leds for this controller object.
|
||||
/// @param pLed - the led controller being added
|
||||
/// @param data - base point to an array of CRGB data structures
|
||||
/// @param nLedsOrOffset - number of leds (3 argument version) or offset into the data array
|
||||
/// @param nLedsIfOffset - number of leds (4 argument version)
|
||||
/// @returns a reference to the added controller
|
||||
static CLEDController &addLeds(CLEDController *pLed, struct CRGB *data, int nLedsOrOffset, int nLedsIfOffset = 0);
|
||||
|
||||
/// @name Adding SPI based controllers
|
||||
//@{
|
||||
/// Add an SPI based CLEDController instance to the world.
|
||||
/// There are two ways to call this method (as well as the other addLeds)
|
||||
/// variations. The first is with 2 arguments, in which case the arguments are a pointer to
|
||||
/// led data, and the number of leds used by this controller. The second is with 3 arguments, in which case
|
||||
/// the first argument is the same, the second argument is an offset into the CRGB data where this controller's
|
||||
/// CRGB data begins, and the third argument is the number of leds for this controller object.
|
||||
///
|
||||
/// This method also takes a 1 to 5 template parameters for identifying the specific chipset, data and clock pins,
|
||||
/// RGB ordering, and SPI data rate
|
||||
/// @param data - base point to an array of CRGB data structures
|
||||
/// @param nLedsOrOffset - number of leds (3 argument version) or offset into the data array
|
||||
/// @param nLedsIfOffset - number of leds (4 argument version)
|
||||
/// @tparam CHIPSET - the chipset type
|
||||
/// @tparam DATA_PIN - the optional data pin for the leds (if omitted, will default to the first hardware SPI MOSI pin)
|
||||
/// @tparam CLOCK_PIN - the optional clock pin for the leds (if omitted, will default to the first hardware SPI clock pin)
|
||||
/// @tparam RGB_ORDER - the rgb ordering for the leds (e.g. what order red, green, and blue data is written out in)
|
||||
/// @tparam SPI_DATA_RATE - the data rate to drive the SPI clock at, defined using DATA_RATE_MHZ or DATA_RATE_KHZ macros
|
||||
/// @returns a reference to the added controller
|
||||
template<ESPIChipsets CHIPSET, uint8_t DATA_PIN, uint8_t CLOCK_PIN, EOrder RGB_ORDER, uint32_t SPI_DATA_RATE > CLEDController &addLeds(struct CRGB *data, int nLedsOrOffset, int nLedsIfOffset = 0) {
|
||||
switch(CHIPSET) {
|
||||
case LPD6803: { static LPD6803Controller<DATA_PIN, CLOCK_PIN, RGB_ORDER, SPI_DATA_RATE> c; return addLeds(&c, data, nLedsOrOffset, nLedsIfOffset); }
|
||||
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); }
|
||||
case WS2803: { static WS2803Controller<DATA_PIN, CLOCK_PIN, RGB_ORDER, SPI_DATA_RATE> c; return addLeds(&c, data, nLedsOrOffset, nLedsIfOffset); }
|
||||
case SM16716: { static SM16716Controller<DATA_PIN, CLOCK_PIN, RGB_ORDER, SPI_DATA_RATE> c; return addLeds(&c, data, nLedsOrOffset, nLedsIfOffset); }
|
||||
case P9813: { static P9813Controller<DATA_PIN, CLOCK_PIN, RGB_ORDER, SPI_DATA_RATE> c; return addLeds(&c, data, nLedsOrOffset, nLedsIfOffset); }
|
||||
case DOTSTAR:
|
||||
case APA102: { static APA102Controller<DATA_PIN, CLOCK_PIN, RGB_ORDER, SPI_DATA_RATE> c; return addLeds(&c, data, nLedsOrOffset, nLedsIfOffset); }
|
||||
case SK9822: { static SK9822Controller<DATA_PIN, CLOCK_PIN, RGB_ORDER, SPI_DATA_RATE> c; return addLeds(&c, data, nLedsOrOffset, nLedsIfOffset); }
|
||||
}
|
||||
}
|
||||
|
||||
template<ESPIChipsets CHIPSET, uint8_t DATA_PIN, uint8_t CLOCK_PIN > static CLEDController &addLeds(struct CRGB *data, int nLedsOrOffset, int nLedsIfOffset = 0) {
|
||||
switch(CHIPSET) {
|
||||
case LPD6803: { static LPD6803Controller<DATA_PIN, CLOCK_PIN> c; return addLeds(&c, data, nLedsOrOffset, nLedsIfOffset); }
|
||||
case LPD8806: { static LPD8806Controller<DATA_PIN, CLOCK_PIN> c; return addLeds(&c, data, nLedsOrOffset, nLedsIfOffset); }
|
||||
case WS2801: { static WS2801Controller<DATA_PIN, CLOCK_PIN> c; return addLeds(&c, data, nLedsOrOffset, nLedsIfOffset); }
|
||||
case WS2803: { static WS2803Controller<DATA_PIN, CLOCK_PIN> c; return addLeds(&c, data, nLedsOrOffset, nLedsIfOffset); }
|
||||
case SM16716: { static SM16716Controller<DATA_PIN, CLOCK_PIN> c; return addLeds(&c, data, nLedsOrOffset, nLedsIfOffset); }
|
||||
case P9813: { static P9813Controller<DATA_PIN, CLOCK_PIN> c; return addLeds(&c, data, nLedsOrOffset, nLedsIfOffset); }
|
||||
case DOTSTAR:
|
||||
case APA102: { static APA102Controller<DATA_PIN, CLOCK_PIN> c; return addLeds(&c, data, nLedsOrOffset, nLedsIfOffset); }
|
||||
case SK9822: { static SK9822Controller<DATA_PIN, CLOCK_PIN> c; return addLeds(&c, data, nLedsOrOffset, nLedsIfOffset); }
|
||||
}
|
||||
}
|
||||
|
||||
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 LPD6803: { static LPD6803Controller<DATA_PIN, CLOCK_PIN, RGB_ORDER> c; return addLeds(&c, data, nLedsOrOffset, nLedsIfOffset); }
|
||||
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); }
|
||||
case WS2803: { static WS2803Controller<DATA_PIN, CLOCK_PIN, RGB_ORDER> c; return addLeds(&c, data, nLedsOrOffset, nLedsIfOffset); }
|
||||
case SM16716: { static SM16716Controller<DATA_PIN, CLOCK_PIN, RGB_ORDER> c; return addLeds(&c, data, nLedsOrOffset, nLedsIfOffset); }
|
||||
case P9813: { static P9813Controller<DATA_PIN, CLOCK_PIN, RGB_ORDER> c; return addLeds(&c, data, nLedsOrOffset, nLedsIfOffset); }
|
||||
case DOTSTAR:
|
||||
case APA102: { static APA102Controller<DATA_PIN, CLOCK_PIN, RGB_ORDER> c; return addLeds(&c, data, nLedsOrOffset, nLedsIfOffset); }
|
||||
case SK9822: { static SK9822Controller<DATA_PIN, CLOCK_PIN, RGB_ORDER> c; return addLeds(&c, data, nLedsOrOffset, nLedsIfOffset); }
|
||||
}
|
||||
}
|
||||
|
||||
#ifdef SPI_DATA
|
||||
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(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, uint32_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
|
||||
//@}
|
||||
|
||||
#ifdef FASTLED_HAS_CLOCKLESS
|
||||
/// @name Adding 3-wire led controllers
|
||||
//@{
|
||||
/// Add a clockless (aka 3wire, also DMX) based CLEDController instance to the world.
|
||||
/// There are two ways to call this method (as well as the other addLeds)
|
||||
/// variations. The first is with 2 arguments, in which case the arguments are a pointer to
|
||||
/// led data, and the number of leds used by this controller. The second is with 3 arguments, in which case
|
||||
/// the first argument is the same, the second argument is an offset into the CRGB data where this controller's
|
||||
/// CRGB data begins, and the third argument is the number of leds for this controller object.
|
||||
///
|
||||
/// This method also takes a 2 to 3 template parameters for identifying the specific chipset, data pin, and rgb ordering
|
||||
/// RGB ordering, and SPI data rate
|
||||
/// @param data - base point to an array of CRGB data structures
|
||||
/// @param nLedsOrOffset - number of leds (3 argument version) or offset into the data array
|
||||
/// @param nLedsIfOffset - number of leds (4 argument version)
|
||||
/// @tparam CHIPSET - the chipset type (required)
|
||||
/// @tparam DATA_PIN - the optional data pin for the leds (required)
|
||||
/// @tparam RGB_ORDER - the rgb ordering for the leds (e.g. what order red, green, and blue data is written out in)
|
||||
/// @returns a reference to the added controller
|
||||
template<template<uint8_t DATA_PIN, EOrder RGB_ORDER> class CHIPSET, uint8_t DATA_PIN, EOrder RGB_ORDER>
|
||||
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(struct CRGB *data, int nLedsOrOffset, int nLedsIfOffset = 0) {
|
||||
static CHIPSET<DATA_PIN, RGB> c;
|
||||
return addLeds(&c, data, nLedsOrOffset, nLedsIfOffset);
|
||||
}
|
||||
|
||||
template<template<uint8_t DATA_PIN> class CHIPSET, uint8_t DATA_PIN>
|
||||
static CLEDController &addLeds(struct CRGB *data, int nLedsOrOffset, int nLedsIfOffset = 0) {
|
||||
static CHIPSET<DATA_PIN> c;
|
||||
return addLeds(&c, data, nLedsOrOffset, nLedsIfOffset);
|
||||
}
|
||||
|
||||
#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);
|
||||
}
|
||||
#endif
|
||||
|
||||
#ifdef FASTSPI_USE_DMX_SIMPLE
|
||||
template<EClocklessChipsets CHIPSET, uint8_t DATA_PIN, EOrder RGB_ORDER=RGB>
|
||||
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); }
|
||||
}
|
||||
}
|
||||
#endif
|
||||
//@}
|
||||
#endif
|
||||
|
||||
/// @name Adding 3rd party library controllers
|
||||
//@{
|
||||
/// Add a 3rd party library based CLEDController instance to the world.
|
||||
/// There are two ways to call this method (as well as the other addLeds)
|
||||
/// variations. The first is with 2 arguments, in which case the arguments are a pointer to
|
||||
/// led data, and the number of leds used by this controller. The second is with 3 arguments, in which case
|
||||
/// the first argument is the same, the second argument is an offset into the CRGB data where this controller's
|
||||
/// CRGB data begins, and the third argument is the number of leds for this controller object. This class includes the SmartMatrix
|
||||
/// and OctoWS2811 based controllers
|
||||
///
|
||||
/// This method also takes a 1 to 2 template parameters for identifying the specific chipset and rgb ordering
|
||||
/// RGB ordering, and SPI data rate
|
||||
/// @param data - base point to an array of CRGB data structures
|
||||
/// @param nLedsOrOffset - number of leds (3 argument version) or offset into the data array
|
||||
/// @param nLedsIfOffset - number of leds (4 argument version)
|
||||
/// @tparam CHIPSET - the chipset type (required)
|
||||
/// @tparam RGB_ORDER - the rgb ordering for the leds (e.g. what order red, green, and blue data is written out in)
|
||||
/// @returns a reference to the added controller
|
||||
template<template<EOrder RGB_ORDER> class CHIPSET, EOrder RGB_ORDER>
|
||||
static CLEDController &addLeds(struct CRGB *data, int nLedsOrOffset, int nLedsIfOffset = 0) {
|
||||
static CHIPSET<RGB_ORDER> c;
|
||||
return addLeds(&c, data, nLedsOrOffset, nLedsIfOffset);
|
||||
}
|
||||
|
||||
template<template<EOrder RGB_ORDER> class CHIPSET>
|
||||
static CLEDController &addLeds(struct CRGB *data, int nLedsOrOffset, int nLedsIfOffset = 0) {
|
||||
static CHIPSET<RGB> c;
|
||||
return addLeds(&c, data, nLedsOrOffset, nLedsIfOffset);
|
||||
}
|
||||
|
||||
#ifdef USE_OCTOWS2811
|
||||
template<OWS2811 CHIPSET, EOrder RGB_ORDER>
|
||||
static CLEDController &addLeds(struct CRGB *data, int nLedsOrOffset, int nLedsIfOffset = 0)
|
||||
{
|
||||
switch(CHIPSET) {
|
||||
case OCTOWS2811: { static COctoWS2811Controller<RGB_ORDER,WS2811_800kHz> controller; return addLeds(&controller, data, nLedsOrOffset, nLedsIfOffset); }
|
||||
case OCTOWS2811_400: { static COctoWS2811Controller<RGB_ORDER,WS2811_400kHz> controller; return addLeds(&controller, data, nLedsOrOffset, nLedsIfOffset); }
|
||||
#ifdef WS2813_800kHz
|
||||
case OCTOWS2813: { static COctoWS2811Controller<RGB_ORDER,WS2813_800kHz> controller; return addLeds(&controller, data, nLedsOrOffset, nLedsIfOffset); }
|
||||
#endif
|
||||
}
|
||||
}
|
||||
|
||||
template<OWS2811 CHIPSET>
|
||||
static CLEDController &addLeds(struct CRGB *data, int nLedsOrOffset, int nLedsIfOffset = 0)
|
||||
{
|
||||
return addLeds<CHIPSET,GRB>(data,nLedsOrOffset,nLedsIfOffset);
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
#ifdef USE_WS2812SERIAL
|
||||
template<SWS2812 CHIPSET, int DATA_PIN, EOrder RGB_ORDER>
|
||||
static CLEDController &addLeds(struct CRGB *data, int nLedsOrOffset, int nLedsIfOffset = 0)
|
||||
{
|
||||
static CWS2812SerialController<DATA_PIN,RGB_ORDER> controller;
|
||||
return addLeds(&controller, data, nLedsOrOffset, nLedsIfOffset);
|
||||
}
|
||||
#endif
|
||||
|
||||
#ifdef SmartMatrix_h
|
||||
template<ESM CHIPSET>
|
||||
static CLEDController &addLeds(struct CRGB *data, int nLedsOrOffset, int nLedsIfOffset = 0)
|
||||
{
|
||||
switch(CHIPSET) {
|
||||
case SMART_MATRIX: { static CSmartMatrixController controller; return addLeds(&controller, data, nLedsOrOffset, nLedsIfOffset); }
|
||||
}
|
||||
}
|
||||
#endif
|
||||
//@}
|
||||
|
||||
|
||||
#ifdef FASTLED_HAS_BLOCKLESS
|
||||
|
||||
/// @name adding parallel output controllers
|
||||
//@{
|
||||
/// Add a block based CLEDController instance to the world.
|
||||
/// There are two ways to call this method (as well as the other addLeds)
|
||||
/// variations. The first is with 2 arguments, in which case the arguments are a pointer to
|
||||
/// led data, and the number of leds used by this controller. The second is with 3 arguments, in which case
|
||||
/// the first argument is the same, the second argument is an offset into the CRGB data where this controller's
|
||||
/// CRGB data begins, and the third argument is the number of leds for this controller object.
|
||||
///
|
||||
/// This method also takes a 2 to 3 template parameters for identifying the specific chipset and rgb ordering
|
||||
/// RGB ordering, and SPI data rate
|
||||
/// @param data - base point to an array of CRGB data structures
|
||||
/// @param nLedsOrOffset - number of leds (3 argument version) or offset into the data array
|
||||
/// @param nLedsIfOffset - number of leds (4 argument version)
|
||||
/// @tparam CHIPSET - the chipset/port type (required)
|
||||
/// @tparam NUM_LANES - how many parallel lanes of output to write
|
||||
/// @tparam RGB_ORDER - the rgb ordering for the leds (e.g. what order red, green, and blue data is written out in)
|
||||
/// @returns a reference to the added controller
|
||||
template<EBlockChipsets CHIPSET, int NUM_LANES, EOrder RGB_ORDER>
|
||||
static CLEDController &addLeds(struct CRGB *data, int nLedsOrOffset, int nLedsIfOffset = 0) {
|
||||
switch(CHIPSET) {
|
||||
#ifdef PORTA_FIRST_PIN
|
||||
case WS2811_PORTA: return addLeds(new InlineBlockClocklessController<NUM_LANES, PORTA_FIRST_PIN, NS(320), NS(320), NS(640), RGB_ORDER>(), data, nLedsOrOffset, nLedsIfOffset);
|
||||
case WS2811_400_PORTA: return addLeds(new InlineBlockClocklessController<NUM_LANES, PORTA_FIRST_PIN, NS(800), NS(800), NS(900), RGB_ORDER>(), data, nLedsOrOffset, nLedsIfOffset);
|
||||
case WS2813_PORTA: return addLeds(new InlineBlockClocklessController<NUM_LANES, PORTA_FIRST_PIN, NS(320), NS(320), NS(640), RGB_ORDER, 0, false, 300>(), data, nLedsOrOffset, nLedsIfOffset);
|
||||
case TM1803_PORTA: return addLeds(new InlineBlockClocklessController<NUM_LANES, PORTA_FIRST_PIN, NS(700), NS(1100), NS(700), RGB_ORDER>(), data, nLedsOrOffset, nLedsIfOffset);
|
||||
case UCS1903_PORTA: return addLeds(new InlineBlockClocklessController<NUM_LANES, PORTA_FIRST_PIN, NS(500), NS(1500), NS(500), RGB_ORDER>(), data, nLedsOrOffset, nLedsIfOffset);
|
||||
#endif
|
||||
#ifdef PORTB_FIRST_PIN
|
||||
case WS2811_PORTB: return addLeds(new InlineBlockClocklessController<NUM_LANES, PORTB_FIRST_PIN, NS(320), NS(320), NS(640), RGB_ORDER>(), data, nLedsOrOffset, nLedsIfOffset);
|
||||
case WS2811_400_PORTB: return addLeds(new InlineBlockClocklessController<NUM_LANES, PORTB_FIRST_PIN, NS(800), NS(800), NS(900), RGB_ORDER>(), data, nLedsOrOffset, nLedsIfOffset);
|
||||
case WS2813_PORTB: return addLeds(new InlineBlockClocklessController<NUM_LANES, PORTB_FIRST_PIN, NS(320), NS(320), NS(640), RGB_ORDER, 0, false, 300>(), data, nLedsOrOffset, nLedsIfOffset);
|
||||
case TM1803_PORTB: return addLeds(new InlineBlockClocklessController<NUM_LANES, PORTB_FIRST_PIN, NS(700), NS(1100), NS(700), RGB_ORDER>(), data, nLedsOrOffset, nLedsIfOffset);
|
||||
case UCS1903_PORTB: return addLeds(new InlineBlockClocklessController<NUM_LANES, PORTB_FIRST_PIN, NS(500), NS(1500), NS(500), RGB_ORDER>(), data, nLedsOrOffset, nLedsIfOffset);
|
||||
#endif
|
||||
#ifdef PORTC_FIRST_PIN
|
||||
case WS2811_PORTC: return addLeds(new InlineBlockClocklessController<NUM_LANES, PORTC_FIRST_PIN, NS(320), NS(320), NS(640), RGB_ORDER>(), data, nLedsOrOffset, nLedsIfOffset);
|
||||
case WS2811_400_PORTC: return addLeds(new InlineBlockClocklessController<NUM_LANES, PORTC_FIRST_PIN, NS(800), NS(800), NS(900), RGB_ORDER>(), data, nLedsOrOffset, nLedsIfOffset);
|
||||
case WS2813_PORTC: return addLeds(new InlineBlockClocklessController<NUM_LANES, PORTC_FIRST_PIN, NS(320), NS(320), NS(640), RGB_ORDER, 0, false, 300>(), data, nLedsOrOffset, nLedsIfOffset);
|
||||
case TM1803_PORTC: return addLeds(new InlineBlockClocklessController<NUM_LANES, PORTC_FIRST_PIN, NS(700), NS(1100), NS(700), RGB_ORDER>(), data, nLedsOrOffset, nLedsIfOffset);
|
||||
case UCS1903_PORTC: return addLeds(new InlineBlockClocklessController<NUM_LANES, PORTC_FIRST_PIN, NS(500), NS(1500), NS(500), RGB_ORDER>(), data, nLedsOrOffset, nLedsIfOffset);
|
||||
#endif
|
||||
#ifdef PORTD_FIRST_PIN
|
||||
case WS2811_PORTD: return addLeds(new InlineBlockClocklessController<NUM_LANES, PORTD_FIRST_PIN, NS(320), NS(320), NS(640), RGB_ORDER>(), data, nLedsOrOffset, nLedsIfOffset);
|
||||
case WS2811_400_PORTD: return addLeds(new InlineBlockClocklessController<NUM_LANES, PORTD_FIRST_PIN, NS(800), NS(800), NS(900), RGB_ORDER>(), data, nLedsOrOffset, nLedsIfOffset);
|
||||
case WS2813_PORTD: return addLeds(new InlineBlockClocklessController<NUM_LANES, PORTD_FIRST_PIN, NS(320), NS(320), NS(640), RGB_ORDER, 0, false, 300>(), data, nLedsOrOffset, nLedsIfOffset);
|
||||
case TM1803_PORTD: return addLeds(new InlineBlockClocklessController<NUM_LANES, PORTD_FIRST_PIN, NS(700), NS(1100), NS(700), RGB_ORDER>(), data, nLedsOrOffset, nLedsIfOffset);
|
||||
case UCS1903_PORTD: return addLeds(new InlineBlockClocklessController<NUM_LANES, PORTD_FIRST_PIN, NS(500), NS(1500), NS(500), RGB_ORDER>(), data, nLedsOrOffset, nLedsIfOffset);
|
||||
#endif
|
||||
#ifdef HAS_PORTDC
|
||||
case WS2811_PORTDC: return addLeds(new SixteenWayInlineBlockClocklessController<NUM_LANES,NS(320), NS(320), NS(640), RGB_ORDER>(), data, nLedsOrOffset, nLedsIfOffset);
|
||||
case WS2811_400_PORTDC: return addLeds(new SixteenWayInlineBlockClocklessController<NUM_LANES,NS(800), NS(800), NS(900), RGB_ORDER>(), data, nLedsOrOffset, nLedsIfOffset);
|
||||
case WS2813_PORTDC: return addLeds(new SixteenWayInlineBlockClocklessController<NUM_LANES, NS(320), NS(320), NS(640), RGB_ORDER, 0, false, 300>(), data, nLedsOrOffset, nLedsIfOffset);
|
||||
case TM1803_PORTDC: return addLeds(new SixteenWayInlineBlockClocklessController<NUM_LANES, NS(700), NS(1100), NS(700), RGB_ORDER>(), data, nLedsOrOffset, nLedsIfOffset);
|
||||
case UCS1903_PORTDC: return addLeds(new SixteenWayInlineBlockClocklessController<NUM_LANES, NS(500), NS(1500), NS(500), RGB_ORDER>(), data, nLedsOrOffset, nLedsIfOffset);
|
||||
#endif
|
||||
}
|
||||
}
|
||||
|
||||
template<EBlockChipsets CHIPSET, int NUM_LANES>
|
||||
static CLEDController &addLeds(struct CRGB *data, int nLedsOrOffset, int nLedsIfOffset = 0) {
|
||||
return addLeds<CHIPSET,NUM_LANES,GRB>(data,nLedsOrOffset,nLedsIfOffset);
|
||||
}
|
||||
//@}
|
||||
#endif
|
||||
|
||||
/// Set the global brightness scaling
|
||||
/// @param scale a 0-255 value for how much to scale all leds before writing them out
|
||||
void setBrightness(uint8_t scale) { m_Scale = scale; }
|
||||
|
||||
/// Get the current global brightness setting
|
||||
/// @returns the current global brightness value
|
||||
uint8_t getBrightness() { return m_Scale; }
|
||||
|
||||
/// Set the maximum power to be used, given in volts and milliamps.
|
||||
/// @param volts - how many volts the leds are being driven at (usually 5)
|
||||
/// @param milliamps - the maximum milliamps of power draw you want
|
||||
inline void setMaxPowerInVoltsAndMilliamps(uint8_t volts, uint32_t milliamps) { setMaxPowerInMilliWatts(volts * milliamps); }
|
||||
|
||||
/// Set the maximum power to be used, given in milliwatts
|
||||
/// @param milliwatts - the max power draw desired, in milliwatts
|
||||
inline void setMaxPowerInMilliWatts(uint32_t milliwatts) { m_pPowerFunc = &calculate_max_brightness_for_power_mW; m_nPowerData = milliwatts; }
|
||||
|
||||
/// Update all our controllers with the current led colors, using the passed in brightness
|
||||
/// @param scale temporarily override the scale
|
||||
void show(uint8_t scale);
|
||||
|
||||
/// Update all our controllers with the current led colors
|
||||
void show() { show(m_Scale); }
|
||||
|
||||
/// clear the leds, wiping the local array of data, optionally black out the leds as well
|
||||
/// @param writeData whether or not to write out to the leds as well
|
||||
void clear(bool writeData = false);
|
||||
|
||||
/// clear out the local data array
|
||||
void clearData();
|
||||
|
||||
/// Set all leds on all controllers to the given color/scale
|
||||
/// @param color what color to set the leds to
|
||||
/// @param scale what brightness scale to show at
|
||||
void showColor(const struct CRGB & color, uint8_t scale);
|
||||
|
||||
/// Set all leds on all controllers to the given color
|
||||
/// @param color what color to set the leds to
|
||||
void showColor(const struct CRGB & color) { showColor(color, m_Scale); }
|
||||
|
||||
/// Delay for the given number of milliseconds. Provided to allow the library to be used on platforms
|
||||
/// that don't have a delay function (to allow code to be more portable). Note: this will call show
|
||||
/// constantly to drive the dithering engine (and will call show at least once).
|
||||
/// @param ms the number of milliseconds to pause for
|
||||
void delay(unsigned long ms);
|
||||
|
||||
/// Set a global color temperature. Sets the color temperature for all added led strips, overriding whatever
|
||||
/// previous color temperature those controllers may have had
|
||||
/// @param temp A CRGB structure describing the color temperature
|
||||
void setTemperature(const struct CRGB & temp);
|
||||
|
||||
/// Set a global color correction. Sets the color correction for all added led strips,
|
||||
/// overriding whatever previous color correction those controllers may have had.
|
||||
/// @param correction A CRGB structure describin the color correction.
|
||||
void setCorrection(const struct CRGB & correction);
|
||||
|
||||
/// Set the dithering mode. Sets the dithering mode for all added led strips, overriding
|
||||
/// whatever previous dithering option those controllers may have had.
|
||||
/// @param ditherMode - what type of dithering to use, either BINARY_DITHER or DISABLE_DITHER
|
||||
void setDither(uint8_t ditherMode = BINARY_DITHER);
|
||||
|
||||
/// Set the maximum refresh rate. This is global for all leds. Attempts to
|
||||
/// call show faster than this rate will simply wait. Note that the refresh rate
|
||||
/// defaults to the slowest refresh rate of all the leds added through addLeds. If
|
||||
/// you wish to set/override this rate, be sure to call setMaxRefreshRate _after_
|
||||
/// adding all of your leds.
|
||||
/// @param refresh - maximum refresh rate in hz
|
||||
/// @param constrain - constrain refresh rate to the slowest speed yet set
|
||||
void setMaxRefreshRate(uint16_t refresh, bool constrain=false);
|
||||
|
||||
/// for debugging, will keep track of time between calls to countFPS, and every
|
||||
/// nFrames calls, it will update an internal counter for the current FPS.
|
||||
/// @todo make this a rolling counter
|
||||
/// @param nFrames - how many frames to time for determining FPS
|
||||
void countFPS(int nFrames=25);
|
||||
|
||||
/// Get the number of frames/second being written out
|
||||
/// @returns the most recently computed FPS value
|
||||
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
|
||||
int count();
|
||||
|
||||
/// Get a reference to a registered 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
|
||||
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
|
||||
CRGB *leds() { return (*this)[0].leds(); }
|
||||
};
|
||||
|
||||
#define FastSPI_LED FastLED
|
||||
#define FastSPI_LED2 FastLED
|
||||
#ifndef LEDS
|
||||
#define LEDS FastLED
|
||||
#endif
|
||||
|
||||
extern CFastLED FastLED;
|
||||
|
||||
// Warnings for undefined things
|
||||
#ifndef HAS_HARDWARE_PIN_SUPPORT
|
||||
#warning "No pin/port mappings found, pin access will be slightly slower. See fastpin.h for info."
|
||||
#define NO_HARDWARE_PIN_SUPPORT
|
||||
#endif
|
||||
|
||||
|
||||
FASTLED_NAMESPACE_END
|
||||
|
||||
#endif
|
||||
20
components/FastLED-idf/LICENSE
Normal file
20
components/FastLED-idf/LICENSE
Normal file
@ -0,0 +1,20 @@
|
||||
The MIT License (MIT)
|
||||
|
||||
Copyright (c) 2013 FastLED
|
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining a copy of
|
||||
this software and associated documentation files (the "Software"), to deal in
|
||||
the Software without restriction, including without limitation the rights to
|
||||
use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
|
||||
the Software, and to permit persons to whom the Software is furnished to do so,
|
||||
subject to the following conditions:
|
||||
|
||||
The above copyright notice and this permission notice shall be included in all
|
||||
copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
|
||||
FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
|
||||
COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
|
||||
IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
55
components/FastLED-idf/PORTING.md
Normal file
55
components/FastLED-idf/PORTING.md
Normal file
@ -0,0 +1,55 @@
|
||||
=New platform porting guide=
|
||||
|
||||
== 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:
|
||||
|
||||
```
|
||||
#elif defined(__AVR_ATmega1284P__) || defined(__AVR_ATmega644P__)
|
||||
|
||||
_FL_IO(A); _FL_IO(B); _FL_IO(C); _FL_IO(D);
|
||||
|
||||
#define MAX_PIN 31
|
||||
_FL_DEFPIN(0, 0, B); _FL_DEFPIN(1, 1, B); _FL_DEFPIN(2, 2, B); _FL_DEFPIN(3, 3, B);
|
||||
_FL_DEFPIN(4, 4, B); _FL_DEFPIN(5, 5, B); _FL_DEFPIN(6, 6, B); _FL_DEFPIN(7, 7, B);
|
||||
_FL_DEFPIN(8, 0, D); _FL_DEFPIN(9, 1, D); _FL_DEFPIN(10, 2, D); _FL_DEFPIN(11, 3, D);
|
||||
_FL_DEFPIN(12, 4, D); _FL_DEFPIN(13, 5, D); _FL_DEFPIN(14, 6, D); _FL_DEFPIN(15, 7, D);
|
||||
_FL_DEFPIN(16, 0, C); _FL_DEFPIN(17, 1, C); _FL_DEFPIN(18, 2, C); _FL_DEFPIN(19, 3, C);
|
||||
_FL_DEFPIN(20, 4, C); _FL_DEFPIN(21, 5, C); _FL_DEFPIN(22, 6, C); _FL_DEFPIN(23, 7, C);
|
||||
_FL_DEFPIN(24, 0, A); _FL_DEFPIN(25, 1, A); _FL_DEFPIN(26, 2, A); _FL_DEFPIN(27, 3, A);
|
||||
_FL_DEFPIN(28, 4, A); _FL_DEFPIN(29, 5, A); _FL_DEFPIN(30, 6, A); _FL_DEFPIN(31, 7, A);
|
||||
|
||||
#define HAS_HARDWARE_PIN_SUPPORT 1
|
||||
```
|
||||
|
||||
The ```_FL_IO``` macro is used to define the port registers for the platform while the ```_FL_DEFPIN``` macro is used to define pins. The parameters to the macro are the pin number, the bit on the port that represents that pin, and the port identifier itself. On some platforms, like the AVR, ports are identified by letter. On other platforms, like arm, ports are identified by number.
|
||||
|
||||
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 ==
|
||||
|
||||
* Create platform directory (e.g. platforms/arm/kl26)
|
||||
* Create configuration header led_sysdefs_arm_kl26.h:
|
||||
* Define platform flags (like FASTLED_ARM/FASTLED_TEENSY)
|
||||
* Define configuration parameters re: interrupts, or clock doubling
|
||||
* Include extar system header files if needed
|
||||
* Create main platform include, fastled_arm_kl26.h
|
||||
* Include the various other header files as needed
|
||||
* Modify led_sysdefs.h to conditionally include platform sysdefs header file
|
||||
* Modify platforms.h to conditionally include platform fastled header
|
||||
|
||||
== 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 ==
|
||||
|
||||
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 ==
|
||||
|
||||
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.
|
||||
95
components/FastLED-idf/README.md
Normal file
95
components/FastLED-idf/README.md
Normal file
@ -0,0 +1,95 @@
|
||||
|
||||
IMPORTANT NOTE: For AVR based systems, avr-gcc 4.8.x is supported and tested. This means Arduino 1.6.5 and later.
|
||||
|
||||
Port to ESP-IDF
|
||||
===============
|
||||
|
||||
Please see the ESP-IDF.md file which describes the general work
|
||||
that had to be done to port to the FreeRTOS environment, from
|
||||
Ardunio.
|
||||
|
||||
FastLED 3.3
|
||||
===========
|
||||
|
||||
This is a library for easily & efficiently controlling a wide variety of LED chipsets, like the ones
|
||||
sold by adafruit (Neopixel, DotStar, LPD8806), Sparkfun (WS2801), and aliexpress. In addition to writing to the
|
||||
leds, this library also includes a number of functions for high-performing 8bit math for manipulating
|
||||
your RGB values, as well as low level classes for abstracting out access to pins and SPI hardware, while
|
||||
still keeping things as fast as possible. Tested with Arduino up to 1.6.5 from arduino.cc.
|
||||
|
||||
Quick note for people installing from GitHub repo zips, rename the folder FastLED before copying it to your Arduino/libraries folder. Github likes putting -branchname into the name of the folder, which unfortunately, makes Arduino cranky!
|
||||
|
||||
We have multiple goals with this library:
|
||||
|
||||
* Quick start for new developers - hook up your leds and go, no need to think about specifics of the led chipsets being used
|
||||
* Zero pain switching LED chipsets - you get some new leds that the library supports, just change the definition of LEDs you're using, et. voila! Your code is running with the new leds.
|
||||
* High performance - with features like zero cost global brightness scaling, high performance 8-bit math for RGB manipulation, and some of the fastest bit-bang'd SPI support around, FastLED wants to keep as many CPU cycles available for your led patterns as possible
|
||||
|
||||
## Getting help
|
||||
|
||||
If you need help with using the library, please consider going to the reddit community first, which is at http://fastled.io/r (or https://reddit.com/r/FastLED) - there are hundreds of people in that group and many times you will get a quicker answer to your question there, as you will be likely to run into other people who have had the same issue. If you run into bugs with the library (compilation failures, the library doing the wrong thing), or if you'd like to request that we support a particular platform or LED chipset, then please open an issue at http://fastled.io/issues and we will try to figure out what is going wrong.
|
||||
|
||||
## Simple example
|
||||
|
||||
How quickly can you get up and running with the library? Here's a simple blink program:
|
||||
|
||||
#include "FastLED.h"
|
||||
#define NUM_LEDS 60
|
||||
CRGB leds[NUM_LEDS];
|
||||
void setup() { FastLED.addLeds<NEOPIXEL, 6>(leds, NUM_LEDS); }
|
||||
void loop() {
|
||||
leds[0] = CRGB::White; FastLED.show(); delay(30);
|
||||
leds[0] = CRGB::Black; FastLED.show(); delay(30);
|
||||
}
|
||||
|
||||
## Supported LED chipsets
|
||||
|
||||
Here's a list of all the LED chipsets are supported. More details on the led chipsets are included *TODO: Link to wiki page*
|
||||
|
||||
* Adafruit's DotStars - AKA the APA102
|
||||
* Adafruit's Neopixel - aka the WS2812B (also WS2811/WS2812/WS2813, also supported in lo-speed mode) - a 3 wire addressable led chipset
|
||||
* TM1809/4 - 3 wire chipset, cheaply available on aliexpress.com
|
||||
* TM1803 - 3 wire chipset, sold by radio shack
|
||||
* UCS1903 - another 3 wire led chipset, cheap
|
||||
* GW6205 - another 3 wire led chipset
|
||||
* LPD8806 - SPI based chpiset, very high speed
|
||||
* WS2801 - SPI based chipset, cheap and widely available
|
||||
* SM16716 - SPI based chipset
|
||||
* APA102 - SPI based chipset
|
||||
* P9813 - aka Cool Neon's Total Control Lighting
|
||||
* DMX - send rgb data out over DMX using arduino DMX libraries
|
||||
* SmartMatrix panels - needs the SmartMatrix library - https://github.com/pixelmatix/SmartMatrix
|
||||
* LPD6803 - SPI based chpiset, chip CMODE pin must be set to 1 (inside oscillator mode)
|
||||
|
||||
|
||||
HL1606, and "595"-style shift registers are no longer supported by the library. The older Version 1 of the library ("FastSPI_LED") has support for these, but is missing many of the advanced features of current versions and is no longer being maintained.
|
||||
|
||||
|
||||
## Supported platforms
|
||||
|
||||
Right now the library is supported on a variety of arduino compatable platforms. If it's ARM or AVR and uses the arduino software (or a modified version of it to build) then it is likely supported. Note that we have a long list of upcoming platforms to support, so if you don't see what you're looking for here, ask, it may be on the roadmap (or may already be supported). N.B. at the moment we are only supporting the stock compilers that ship with the arduino software. Support for upgraded compilers, as well as using AVR studio and skipping the arduino entirely, should be coming in a near future release.
|
||||
|
||||
* Arduino & compatibles - straight up arduino devices, uno, duo, leonardo, mega, nano, etc...
|
||||
* Arduino Yún
|
||||
* Adafruit Trinket & Gemma - Trinket Pro may be supported, but haven't tested to confirm yet
|
||||
* Teensy 2, Teensy++ 2, Teensy 3.0, Teensy 3.1/3.2, Teensy LC, Teensy 3.5, Teensy 3.6, and Teensy 4.0 - arduino compataible from pjrc.com with some extra goodies (note the teensy 3, 3.1, and LC are ARM, not AVR!)
|
||||
* Arduino Due and the digistump DigiX
|
||||
* RFDuino
|
||||
* SparkCore
|
||||
* Arduino Zero
|
||||
* ESP8266 using the arduino board definitions from http://arduino.esp8266.com/stable/package_esp8266com_index.json - please be sure to also read https://github.com/FastLED/FastLED/wiki/ESP8266-notes for information specific to the 8266.
|
||||
* The wino board - http://wino-board.com
|
||||
* ESP32 based boards
|
||||
|
||||
What types of platforms are we thinking about supporting in the future? Here's a short list: ChipKit32, Maple, Beagleboard
|
||||
|
||||
## What about that name?
|
||||
|
||||
Wait, what happend to FastSPI_LED and FastSPI_LED2? The library was initially named FastSPI_LED because it was focused on very fast and efficient SPI access. However, since then, the library has expanded to support a number of LED chipsets that don't use SPI, as well as a number of math and utility functions for LED processing across the board. We decided that the name FastLED more accurately represents the totality of what the library provides, everything fast, for LEDs.
|
||||
|
||||
## For more information
|
||||
|
||||
Check out the official site http://fastled.io for links to documentation, issues, and news
|
||||
|
||||
|
||||
*TODO* - get candy
|
||||
28
components/FastLED-idf/bitswap.cpp
Normal file
28
components/FastLED-idf/bitswap.cpp
Normal file
@ -0,0 +1,28 @@
|
||||
#define FASTLED_INTERNAL
|
||||
#include "FastLED.h"
|
||||
|
||||
/// 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;
|
||||
|
||||
// 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 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;
|
||||
|
||||
*((uint32_t*)B) = y;
|
||||
*((uint32_t*)(B+4)) = x;
|
||||
}
|
||||
276
components/FastLED-idf/bitswap.h
Normal file
276
components/FastLED-idf/bitswap.h
Normal file
@ -0,0 +1,276 @@
|
||||
#ifndef __INC_BITSWAP_H
|
||||
#define __INC_BITSWAP_H
|
||||
|
||||
#include "FastLED.h"
|
||||
|
||||
FASTLED_NAMESPACE_BEGIN
|
||||
|
||||
///@file bitswap.h
|
||||
///Functions for rotating bits/bytes
|
||||
|
||||
///@defgroup Bitswap Bit swapping/rotate
|
||||
///Functions for doing a rotation of bits/bytes used by parallel output
|
||||
///@{
|
||||
#if defined(FASTLED_ARM) || defined(FASTLED_ESP8266)
|
||||
/// structure representing 8 bits of access
|
||||
typedef union {
|
||||
uint8_t raw;
|
||||
struct {
|
||||
uint32_t a0:1;
|
||||
uint32_t a1:1;
|
||||
uint32_t a2:1;
|
||||
uint32_t a3:1;
|
||||
uint32_t a4:1;
|
||||
uint32_t a5:1;
|
||||
uint32_t a6:1;
|
||||
uint32_t a7:1;
|
||||
};
|
||||
} just8bits;
|
||||
|
||||
/// structure representing 32 bits of access
|
||||
typedef struct {
|
||||
uint32_t a0:1;
|
||||
uint32_t a1:1;
|
||||
uint32_t a2:1;
|
||||
uint32_t a3:1;
|
||||
uint32_t a4:1;
|
||||
uint32_t a5:1;
|
||||
uint32_t a6:1;
|
||||
uint32_t a7:1;
|
||||
uint32_t b0:1;
|
||||
uint32_t b1:1;
|
||||
uint32_t b2:1;
|
||||
uint32_t b3:1;
|
||||
uint32_t b4:1;
|
||||
uint32_t b5:1;
|
||||
uint32_t b6:1;
|
||||
uint32_t b7:1;
|
||||
uint32_t c0:1;
|
||||
uint32_t c1:1;
|
||||
uint32_t c2:1;
|
||||
uint32_t c3:1;
|
||||
uint32_t c4:1;
|
||||
uint32_t c5:1;
|
||||
uint32_t c6:1;
|
||||
uint32_t c7:1;
|
||||
uint32_t d0:1;
|
||||
uint32_t d1:1;
|
||||
uint32_t d2:1;
|
||||
uint32_t d3:1;
|
||||
uint32_t d4:1;
|
||||
uint32_t d5:1;
|
||||
uint32_t d6:1;
|
||||
uint32_t d7:1;
|
||||
} sub4;
|
||||
|
||||
/// union containing a full 8 bytes to swap the bit orientation on
|
||||
typedef union {
|
||||
uint32_t word[2];
|
||||
uint8_t bytes[8];
|
||||
struct {
|
||||
sub4 a;
|
||||
sub4 b;
|
||||
};
|
||||
} bitswap_type;
|
||||
|
||||
|
||||
#define SWAPSA(X,N) out. X ## 0 = in.a.a ## N; \
|
||||
out. X ## 1 = in.a.b ## N; \
|
||||
out. X ## 2 = in.a.c ## N; \
|
||||
out. X ## 3 = in.a.d ## N;
|
||||
|
||||
#define SWAPSB(X,N) out. X ## 0 = in.b.a ## N; \
|
||||
out. X ## 1 = in.b.b ## N; \
|
||||
out. X ## 2 = in.b.c ## N; \
|
||||
out. X ## 3 = in.b.d ## N;
|
||||
|
||||
#define SWAPS(X,N) out. X ## 0 = in.a.a ## N; \
|
||||
out. X ## 1 = in.a.b ## N; \
|
||||
out. X ## 2 = in.a.c ## N; \
|
||||
out. X ## 3 = in.a.d ## N; \
|
||||
out. X ## 4 = in.b.a ## N; \
|
||||
out. X ## 5 = in.b.b ## N; \
|
||||
out. X ## 6 = in.b.c ## N; \
|
||||
out. X ## 7 = in.b.d ## N;
|
||||
|
||||
|
||||
/// Do an 8byte by 8bit rotation
|
||||
__attribute__((always_inline)) inline void swapbits8(bitswap_type in, bitswap_type & out) {
|
||||
|
||||
// SWAPS(a.a,7);
|
||||
// SWAPS(a.b,6);
|
||||
// SWAPS(a.c,5);
|
||||
// SWAPS(a.d,4);
|
||||
// SWAPS(b.a,3);
|
||||
// SWAPS(b.b,2);
|
||||
// SWAPS(b.c,1);
|
||||
// SWAPS(b.d,0);
|
||||
|
||||
// SWAPSA(a.a,7);
|
||||
// SWAPSA(a.b,6);
|
||||
// SWAPSA(a.c,5);
|
||||
// SWAPSA(a.d,4);
|
||||
//
|
||||
// SWAPSB(a.a,7);
|
||||
// SWAPSB(a.b,6);
|
||||
// SWAPSB(a.c,5);
|
||||
// SWAPSB(a.d,4);
|
||||
//
|
||||
// SWAPSA(b.a,3);
|
||||
// SWAPSA(b.b,2);
|
||||
// SWAPSA(b.c,1);
|
||||
// SWAPSA(b.d,0);
|
||||
// //
|
||||
// SWAPSB(b.a,3);
|
||||
// SWAPSB(b.b,2);
|
||||
// SWAPSB(b.c,1);
|
||||
// SWAPSB(b.d,0);
|
||||
|
||||
for(int i = 0; i < 8; i++) {
|
||||
just8bits work;
|
||||
work.a3 = in.word[0] >> 31;
|
||||
work.a2 = in.word[0] >> 23;
|
||||
work.a1 = in.word[0] >> 15;
|
||||
work.a0 = in.word[0] >> 7;
|
||||
in.word[0] <<= 1;
|
||||
work.a7 = in.word[1] >> 31;
|
||||
work.a6 = in.word[1] >> 23;
|
||||
work.a5 = in.word[1] >> 15;
|
||||
work.a4 = in.word[1] >> 7;
|
||||
in.word[1] <<= 1;
|
||||
out.bytes[i] = work.raw;
|
||||
}
|
||||
}
|
||||
|
||||
/// 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++) {
|
||||
uint8_t x = A[row];
|
||||
|
||||
uint8_t bit = (1<<row);
|
||||
unsigned char *p = B;
|
||||
for(uint32_t mask = 1<<7 ; mask ; mask >>= 1) {
|
||||
if(x & mask) {
|
||||
*p++ |= bit;
|
||||
} else {
|
||||
*p++ &= ~bit;
|
||||
}
|
||||
}
|
||||
// B[7] |= (x & 0x01) << row; x >>= 1;
|
||||
// B[6] |= (x & 0x01) << row; x >>= 1;
|
||||
// B[5] |= (x & 0x01) << row; x >>= 1;
|
||||
// B[4] |= (x & 0x01) << row; x >>= 1;
|
||||
// B[3] |= (x & 0x01) << row; x >>= 1;
|
||||
// B[2] |= (x & 0x01) << row; x >>= 1;
|
||||
// B[1] |= (x & 0x01) << row; x >>= 1;
|
||||
// B[0] |= (x & 0x01) << row; x >>= 1;
|
||||
}
|
||||
}
|
||||
|
||||
void transpose8x1_noinline(unsigned char *A, unsigned char *B);
|
||||
|
||||
/// 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)
|
||||
__attribute__((always_inline)) inline void transpose8x1(unsigned char *A, unsigned char *B) {
|
||||
uint32_t x, y, t;
|
||||
|
||||
// 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 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;
|
||||
|
||||
*((uint32_t*)B) = y;
|
||||
*((uint32_t*)(B+4)) = x;
|
||||
}
|
||||
|
||||
/// Simplified form of bits rotating function. Based on code found here - http://www.hackersdelight.org/hdcodetxt/transpose8.c.txt
|
||||
__attribute__((always_inline)) inline void transpose8x1_MSB(unsigned char *A, unsigned char *B) {
|
||||
uint32_t x, y, t;
|
||||
|
||||
// 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 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;
|
||||
|
||||
B[7] = y; y >>= 8;
|
||||
B[6] = y; y >>= 8;
|
||||
B[5] = y; y >>= 8;
|
||||
B[4] = y;
|
||||
|
||||
B[3] = x; x >>= 8;
|
||||
B[2] = x; x >>= 8;
|
||||
B[1] = x; x >>= 8;
|
||||
B[0] = x; /* */
|
||||
}
|
||||
|
||||
/// templated bit-rotating function. Based on code found here - http://www.hackersdelight.org/hdcodetxt/transpose8.c.txt
|
||||
template<int m, int n>
|
||||
__attribute__((always_inline)) inline void transpose8(unsigned char *A, unsigned char *B) {
|
||||
uint32_t x, y, t;
|
||||
|
||||
// Load the array and pack it into x and y.
|
||||
if(m == 1) {
|
||||
y = *(unsigned int*)(A);
|
||||
x = *(unsigned int*)(A+4);
|
||||
} else {
|
||||
x = (A[0]<<24) | (A[m]<<16) | (A[2*m]<<8) | A[3*m];
|
||||
y = (A[4*m]<<24) | (A[5*m]<<16) | (A[6*m]<<8) | A[7*m];
|
||||
}
|
||||
|
||||
// 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);
|
||||
|
||||
// final transform
|
||||
t = (x & 0xF0F0F0F0) | ((y >> 4) & 0x0F0F0F0F);
|
||||
y = ((x << 4) & 0xF0F0F0F0) | (y & 0x0F0F0F0F);
|
||||
x = t;
|
||||
|
||||
B[7*n] = y; y >>= 8;
|
||||
B[6*n] = y; y >>= 8;
|
||||
B[5*n] = y; y >>= 8;
|
||||
B[4*n] = y;
|
||||
|
||||
B[3*n] = x; x >>= 8;
|
||||
B[2*n] = x; x >>= 8;
|
||||
B[n] = x; x >>= 8;
|
||||
B[0] = x;
|
||||
// B[0]=x>>24; B[n]=x>>16; B[2*n]=x>>8; B[3*n]=x>>0;
|
||||
// B[4*n]=y>>24; B[5*n]=y>>16; B[6*n]=y>>8; B[7*n]=y>>0;
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
FASTLED_NAMESPACE_END
|
||||
|
||||
///@}
|
||||
#endif
|
||||
623
components/FastLED-idf/chipsets.h
Normal file
623
components/FastLED-idf/chipsets.h
Normal file
@ -0,0 +1,623 @@
|
||||
#ifndef __INC_CHIPSETS_H
|
||||
#define __INC_CHIPSETS_H
|
||||
|
||||
#include "FastLED.h"
|
||||
#include "pixeltypes.h"
|
||||
|
||||
///@file chipsets.h
|
||||
/// contains the bulk of the definitions for the various LED chipsets supported.
|
||||
|
||||
FASTLED_NAMESPACE_BEGIN
|
||||
///@defgroup chipsets
|
||||
/// Implementations of CLEDController classes for various led chipsets.
|
||||
///
|
||||
///@{
|
||||
|
||||
#if defined(ARDUINO) //&& defined(SoftwareSerial_h)
|
||||
|
||||
|
||||
#if defined(SoftwareSerial_h)
|
||||
#include <SoftwareSerial.h>
|
||||
|
||||
#define HAS_PIXIE
|
||||
|
||||
/// Adafruit Pixie controller class
|
||||
/// @tparam DATAPIN the pin to write data out on
|
||||
/// @tparam RGB_ORDER the RGB ordering for the led data
|
||||
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) {}
|
||||
|
||||
protected:
|
||||
virtual void init() {
|
||||
Serial.begin(115200);
|
||||
mWait.mark();
|
||||
}
|
||||
|
||||
virtual void showPixels(PixelController<RGB_ORDER> & pixels) {
|
||||
mWait.wait();
|
||||
while(pixels.has(1)) {
|
||||
uint8_t r = pixels.loadAndScale0();
|
||||
Serial.write(r);
|
||||
uint8_t g = pixels.loadAndScale1();
|
||||
Serial.write(g);
|
||||
uint8_t b = pixels.loadAndScale2();
|
||||
Serial.write(b);
|
||||
pixels.advanceData();
|
||||
pixels.stepDithering();
|
||||
}
|
||||
mWait.mark();
|
||||
}
|
||||
|
||||
};
|
||||
|
||||
// template<SoftwareSerial & STREAM, EOrder RGB_ORDER = RGB>
|
||||
// class PixieController : public PixieBaseController<STREAM, RGB_ORDER> {
|
||||
// public:
|
||||
// virtual void init() {
|
||||
// STREAM.begin(115200);
|
||||
// }
|
||||
// };
|
||||
#endif
|
||||
#endif
|
||||
|
||||
///@name Clocked chipsets - nominally SPI based these chipsets have a data and a clock line.
|
||||
///@{
|
||||
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// LPD8806 controller class - takes data/clock/select pin values (N.B. should take an SPI definition?)
|
||||
//
|
||||
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
/// LPD8806 controller class.
|
||||
/// @tparam DATA_PIN the data pin for these leds
|
||||
/// @tparam CLOCK_PIN the clock pin for these leds
|
||||
/// @tparam RGB_ORDER the RGB ordering for these leds
|
||||
/// @tparam SPI_SPEED the clock divider used for these leds. Set using the DATA_RATE_MHZ/DATA_RATE_KHZ macros. Defaults to DATA_RATE_MHZ(12)
|
||||
template <uint8_t DATA_PIN, uint8_t CLOCK_PIN, EOrder RGB_ORDER = RGB, uint32_t SPI_SPEED = DATA_RATE_MHZ(12) >
|
||||
class LPD8806Controller : public CPixelLEDController<RGB_ORDER> {
|
||||
typedef SPIOutput<DATA_PIN, CLOCK_PIN, SPI_SPEED> SPI;
|
||||
|
||||
class LPD8806_ADJUST {
|
||||
public:
|
||||
// LPD8806 spec wants the high bit of every rgb data byte sent out to be set.
|
||||
__attribute__((always_inline)) inline static uint8_t adjust(register uint8_t data) { return ((data>>1) | 0x80) + ((data && (data<254)) & 0x01); }
|
||||
__attribute__((always_inline)) inline static void postBlock(int len) {
|
||||
SPI::writeBytesValueRaw(0, ((len*3+63)>>6));
|
||||
}
|
||||
|
||||
};
|
||||
|
||||
SPI mSPI;
|
||||
public:
|
||||
|
||||
LPD8806Controller() {}
|
||||
virtual void init() {
|
||||
mSPI.init();
|
||||
}
|
||||
|
||||
protected:
|
||||
|
||||
virtual void showPixels(PixelController<RGB_ORDER> & pixels) {
|
||||
mSPI.template writePixels<0, LPD8806_ADJUST, RGB_ORDER>(pixels);
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// WS2801 definition - takes data/clock/select pin values (N.B. should take an SPI definition?)
|
||||
//
|
||||
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
/// WS2801 controller class.
|
||||
/// @tparam DATA_PIN the data pin for these leds
|
||||
/// @tparam CLOCK_PIN the clock pin for these leds
|
||||
/// @tparam RGB_ORDER the RGB ordering for these leds
|
||||
/// @tparam SPI_SPEED the clock divider used for these leds. Set using the DATA_RATE_MHZ/DATA_RATE_KHZ macros. Defaults to DATA_RATE_MHZ(1)
|
||||
template <uint8_t DATA_PIN, uint8_t CLOCK_PIN, EOrder RGB_ORDER = RGB, uint32_t SPI_SPEED = DATA_RATE_MHZ(1)>
|
||||
class WS2801Controller : public CPixelLEDController<RGB_ORDER> {
|
||||
typedef SPIOutput<DATA_PIN, CLOCK_PIN, SPI_SPEED> SPI;
|
||||
SPI mSPI;
|
||||
CMinWait<1000> mWaitDelay;
|
||||
public:
|
||||
WS2801Controller() {}
|
||||
|
||||
virtual void init() {
|
||||
mSPI.init();
|
||||
mWaitDelay.mark();
|
||||
}
|
||||
|
||||
protected:
|
||||
|
||||
virtual void showPixels(PixelController<RGB_ORDER> & pixels) {
|
||||
mWaitDelay.wait();
|
||||
mSPI.template writePixels<0, DATA_NOP, RGB_ORDER>(pixels);
|
||||
mWaitDelay.mark();
|
||||
}
|
||||
};
|
||||
|
||||
template <uint8_t DATA_PIN, uint8_t CLOCK_PIN, EOrder RGB_ORDER = RGB, uint32_t SPI_SPEED = DATA_RATE_MHZ(25)>
|
||||
class WS2803Controller : public WS2801Controller<DATA_PIN, CLOCK_PIN, RGB_ORDER, SPI_SPEED> {};
|
||||
|
||||
/// LPD6803 controller class (LPD1101).
|
||||
/// 16 bit (1 bit - const "1", 5 bit - red, 5 bit - green, 5 bit blue).
|
||||
/// In chip CMODE pin must be set to 1 (inside oscillator mode).
|
||||
/// Datasheet: https://cdn-shop.adafruit.com/datasheets/LPD6803.pdf
|
||||
/// @tparam DATA_PIN the data pin for these leds
|
||||
/// @tparam CLOCK_PIN the clock pin for these leds
|
||||
/// @tparam RGB_ORDER the RGB ordering for these leds
|
||||
/// @tparam SPI_SPEED the clock divider used for these leds. Set using the DATA_RATE_MHZ/DATA_RATE_KHZ macros. Defaults to DATA_RATE_MHZ(12)
|
||||
template <uint8_t DATA_PIN, uint8_t CLOCK_PIN, EOrder RGB_ORDER = RGB, uint32_t SPI_SPEED = DATA_RATE_MHZ(12)>
|
||||
class LPD6803Controller : public CPixelLEDController<RGB_ORDER> {
|
||||
typedef SPIOutput<DATA_PIN, CLOCK_PIN, SPI_SPEED> SPI;
|
||||
SPI mSPI;
|
||||
|
||||
void startBoundary() { mSPI.writeByte(0); mSPI.writeByte(0); mSPI.writeByte(0); mSPI.writeByte(0); }
|
||||
|
||||
public:
|
||||
LPD6803Controller() {}
|
||||
|
||||
virtual void init() {
|
||||
mSPI.init();
|
||||
}
|
||||
|
||||
protected:
|
||||
|
||||
virtual void showPixels(PixelController<RGB_ORDER> & pixels) {
|
||||
mSPI.select();
|
||||
|
||||
startBoundary();
|
||||
while(pixels.has(1)) {
|
||||
register uint16_t command;
|
||||
command = 0x8000;
|
||||
command |= (pixels.loadAndScale0() & 0xF8) << 7; // red is the high 5 bits
|
||||
command |= (pixels.loadAndScale1() & 0xF8) << 2; // green is the middle 5 bits
|
||||
mSPI.writeByte((command >> 8) & 0xFF);
|
||||
command |= pixels.loadAndScale2() >> 3 ; // blue is the low 5 bits
|
||||
mSPI.writeByte(command & 0xFF);
|
||||
|
||||
pixels.stepDithering();
|
||||
pixels.advanceData();
|
||||
}
|
||||
//endBoundary(pixels.size());
|
||||
mSPI.waitFully();
|
||||
mSPI.release();
|
||||
}
|
||||
|
||||
};
|
||||
|
||||
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// APA102 definition - takes data/clock/select pin values (N.B. should take an SPI definition?)
|
||||
//
|
||||
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
/// APA102 controller class.
|
||||
/// @tparam DATA_PIN the data pin for these leds
|
||||
/// @tparam CLOCK_PIN the clock pin for these leds
|
||||
/// @tparam RGB_ORDER the RGB ordering for these leds
|
||||
/// @tparam SPI_SPEED the clock divider used for these leds. Set using the DATA_RATE_MHZ/DATA_RATE_KHZ macros. Defaults to DATA_RATE_MHZ(12)
|
||||
template <uint8_t DATA_PIN, uint8_t CLOCK_PIN, EOrder RGB_ORDER = RGB, uint32_t SPI_SPEED = DATA_RATE_MHZ(12)>
|
||||
class APA102Controller : public CPixelLEDController<RGB_ORDER> {
|
||||
typedef SPIOutput<DATA_PIN, CLOCK_PIN, SPI_SPEED> SPI;
|
||||
SPI mSPI;
|
||||
|
||||
void startBoundary() { mSPI.writeWord(0); mSPI.writeWord(0); }
|
||||
void endBoundary(int nLeds) { int nDWords = (nLeds/32); do { mSPI.writeByte(0xFF); mSPI.writeByte(0x00); mSPI.writeByte(0x00); mSPI.writeByte(0x00); } while(nDWords--); }
|
||||
|
||||
inline void writeLed(uint8_t brightness, uint8_t b0, uint8_t b1, uint8_t b2) __attribute__((always_inline)) {
|
||||
#ifdef FASTLED_SPI_BYTE_ONLY
|
||||
mSPI.writeByte(0xE0 | brightness);
|
||||
mSPI.writeByte(b0);
|
||||
mSPI.writeByte(b1);
|
||||
mSPI.writeByte(b2);
|
||||
#else
|
||||
uint16_t b = 0xE000 | (brightness << 8) | (uint16_t)b0;
|
||||
mSPI.writeWord(b);
|
||||
uint16_t w = b1 << 8;
|
||||
w |= b2;
|
||||
mSPI.writeWord(w);
|
||||
#endif
|
||||
}
|
||||
|
||||
public:
|
||||
APA102Controller() {}
|
||||
|
||||
virtual void init() {
|
||||
mSPI.init();
|
||||
}
|
||||
|
||||
protected:
|
||||
|
||||
virtual void showPixels(PixelController<RGB_ORDER> & pixels) {
|
||||
mSPI.select();
|
||||
|
||||
uint8_t s0 = pixels.getScale0(), s1 = pixels.getScale1(), s2 = pixels.getScale2();
|
||||
#if FASTLED_USE_GLOBAL_BRIGHTNESS == 1
|
||||
const uint16_t maxBrightness = 0x1F;
|
||||
uint16_t brightness = ((((uint16_t)max(max(s0, s1), s2) + 1) * maxBrightness - 1) >> 8) + 1;
|
||||
s0 = (maxBrightness * s0 + (brightness >> 1)) / brightness;
|
||||
s1 = (maxBrightness * s1 + (brightness >> 1)) / brightness;
|
||||
s2 = (maxBrightness * s2 + (brightness >> 1)) / brightness;
|
||||
#else
|
||||
const uint8_t brightness = 0x1F;
|
||||
#endif
|
||||
|
||||
startBoundary();
|
||||
while (pixels.has(1)) {
|
||||
writeLed(brightness, pixels.loadAndScale0(0, s0), pixels.loadAndScale1(0, s1), pixels.loadAndScale2(0, s2));
|
||||
pixels.stepDithering();
|
||||
pixels.advanceData();
|
||||
}
|
||||
endBoundary(pixels.size());
|
||||
|
||||
mSPI.waitFully();
|
||||
mSPI.release();
|
||||
}
|
||||
|
||||
};
|
||||
|
||||
/// SK9822 controller class.
|
||||
/// @tparam DATA_PIN the data pin for these leds
|
||||
/// @tparam CLOCK_PIN the clock pin for these leds
|
||||
/// @tparam RGB_ORDER the RGB ordering for these leds
|
||||
/// @tparam SPI_SPEED the clock divider used for these leds. Set using the DATA_RATE_MHZ/DATA_RATE_KHZ macros. Defaults to DATA_RATE_MHZ(24)
|
||||
template <uint8_t DATA_PIN, uint8_t CLOCK_PIN, EOrder RGB_ORDER = RGB, uint32_t SPI_SPEED = DATA_RATE_MHZ(24)>
|
||||
class SK9822Controller : public CPixelLEDController<RGB_ORDER> {
|
||||
typedef SPIOutput<DATA_PIN, CLOCK_PIN, SPI_SPEED> SPI;
|
||||
SPI mSPI;
|
||||
|
||||
void startBoundary() { mSPI.writeWord(0); mSPI.writeWord(0); }
|
||||
void endBoundary(int nLeds) { int nLongWords = (nLeds/32); do { mSPI.writeByte(0x00); mSPI.writeByte(0x00); mSPI.writeByte(0x00); mSPI.writeByte(0x00); } while(nLongWords--); }
|
||||
|
||||
inline void writeLed(uint8_t brightness, uint8_t b0, uint8_t b1, uint8_t b2) __attribute__((always_inline)) {
|
||||
#ifdef FASTLED_SPI_BYTE_ONLY
|
||||
mSPI.writeByte(0xE0 | brightness);
|
||||
mSPI.writeByte(b0);
|
||||
mSPI.writeByte(b1);
|
||||
mSPI.writeByte(b2);
|
||||
#else
|
||||
uint16_t b = 0xE000 | (brightness << 8) | (uint16_t)b0;
|
||||
mSPI.writeWord(b);
|
||||
uint16_t w = b1 << 8;
|
||||
w |= b2;
|
||||
mSPI.writeWord(w);
|
||||
#endif
|
||||
}
|
||||
|
||||
public:
|
||||
SK9822Controller() {}
|
||||
|
||||
virtual void init() {
|
||||
mSPI.init();
|
||||
}
|
||||
|
||||
protected:
|
||||
|
||||
virtual void showPixels(PixelController<RGB_ORDER> & pixels) {
|
||||
mSPI.select();
|
||||
|
||||
uint8_t s0 = pixels.getScale0(), s1 = pixels.getScale1(), s2 = pixels.getScale2();
|
||||
#if FASTLED_USE_GLOBAL_BRIGHTNESS == 1
|
||||
const uint16_t maxBrightness = 0x1F;
|
||||
uint16_t brightness = ((((uint16_t)max(max(s0, s1), s2) + 1) * maxBrightness - 1) >> 8) + 1;
|
||||
s0 = (maxBrightness * s0 + (brightness >> 1)) / brightness;
|
||||
s1 = (maxBrightness * s1 + (brightness >> 1)) / brightness;
|
||||
s2 = (maxBrightness * s2 + (brightness >> 1)) / brightness;
|
||||
#else
|
||||
const uint8_t brightness = 0x1F;
|
||||
#endif
|
||||
|
||||
startBoundary();
|
||||
while (pixels.has(1)) {
|
||||
writeLed(brightness, pixels.loadAndScale0(0, s0), pixels.loadAndScale1(0, s1), pixels.loadAndScale2(0, s2));
|
||||
pixels.stepDithering();
|
||||
pixels.advanceData();
|
||||
}
|
||||
|
||||
endBoundary(pixels.size());
|
||||
|
||||
mSPI.waitFully();
|
||||
mSPI.release();
|
||||
}
|
||||
|
||||
};
|
||||
|
||||
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// P9813 definition - takes data/clock/select pin values (N.B. should take an SPI definition?)
|
||||
//
|
||||
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
/// P9813 controller class.
|
||||
/// @tparam DATA_PIN the data pin for these leds
|
||||
/// @tparam CLOCK_PIN the clock pin for these leds
|
||||
/// @tparam RGB_ORDER the RGB ordering for these leds
|
||||
/// @tparam SPI_SPEED the clock divider used for these leds. Set using the DATA_RATE_MHZ/DATA_RATE_KHZ macros. Defaults to DATA_RATE_MHZ(10)
|
||||
template <uint8_t DATA_PIN, uint8_t CLOCK_PIN, EOrder RGB_ORDER = RGB, uint32_t SPI_SPEED = DATA_RATE_MHZ(10)>
|
||||
class P9813Controller : public CPixelLEDController<RGB_ORDER> {
|
||||
typedef SPIOutput<DATA_PIN, CLOCK_PIN, SPI_SPEED> SPI;
|
||||
SPI mSPI;
|
||||
|
||||
void writeBoundary() { mSPI.writeWord(0); mSPI.writeWord(0); }
|
||||
|
||||
inline void writeLed(uint8_t r, uint8_t g, uint8_t b) __attribute__((always_inline)) {
|
||||
register uint8_t top = 0xC0 | ((~b & 0xC0) >> 2) | ((~g & 0xC0) >> 4) | ((~r & 0xC0) >> 6);
|
||||
mSPI.writeByte(top); mSPI.writeByte(b); mSPI.writeByte(g); mSPI.writeByte(r);
|
||||
}
|
||||
|
||||
public:
|
||||
P9813Controller() {}
|
||||
|
||||
virtual void init() {
|
||||
mSPI.init();
|
||||
}
|
||||
|
||||
protected:
|
||||
|
||||
virtual void showPixels(PixelController<RGB_ORDER> & pixels) {
|
||||
mSPI.select();
|
||||
|
||||
writeBoundary();
|
||||
while(pixels.has(1)) {
|
||||
writeLed(pixels.loadAndScale0(), pixels.loadAndScale1(), pixels.loadAndScale2());
|
||||
pixels.advanceData();
|
||||
pixels.stepDithering();
|
||||
}
|
||||
writeBoundary();
|
||||
mSPI.waitFully();
|
||||
|
||||
mSPI.release();
|
||||
}
|
||||
|
||||
};
|
||||
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// SM16716 definition - takes data/clock/select pin values (N.B. should take an SPI definition?)
|
||||
//
|
||||
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
/// SM16716 controller class.
|
||||
/// @tparam DATA_PIN the data pin for these leds
|
||||
/// @tparam CLOCK_PIN the clock pin for these leds
|
||||
/// @tparam RGB_ORDER the RGB ordering for these leds
|
||||
/// @tparam SPI_SPEED the clock divider used for these leds. Set using the DATA_RATE_MHZ/DATA_RATE_KHZ macros. Defaults to DATA_RATE_MHZ(16)
|
||||
template <uint8_t DATA_PIN, uint8_t CLOCK_PIN, EOrder RGB_ORDER = RGB, uint32_t SPI_SPEED = DATA_RATE_MHZ(16)>
|
||||
class SM16716Controller : public CPixelLEDController<RGB_ORDER> {
|
||||
typedef SPIOutput<DATA_PIN, CLOCK_PIN, SPI_SPEED> SPI;
|
||||
SPI mSPI;
|
||||
|
||||
void writeHeader() {
|
||||
// Write out 50 zeros to the spi line (6 blocks of 8 followed by two single bit writes)
|
||||
mSPI.select();
|
||||
mSPI.template writeBit<0>(0);
|
||||
mSPI.writeByte(0);
|
||||
mSPI.writeByte(0);
|
||||
mSPI.writeByte(0);
|
||||
mSPI.template writeBit<0>(0);
|
||||
mSPI.writeByte(0);
|
||||
mSPI.writeByte(0);
|
||||
mSPI.writeByte(0);
|
||||
mSPI.waitFully();
|
||||
mSPI.release();
|
||||
}
|
||||
|
||||
public:
|
||||
SM16716Controller() {}
|
||||
|
||||
virtual void init() {
|
||||
mSPI.init();
|
||||
}
|
||||
|
||||
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
|
||||
// writeHeader();
|
||||
mSPI.template writePixels<FLAG_START_BIT, DATA_NOP, RGB_ORDER>( pixels );
|
||||
writeHeader();
|
||||
}
|
||||
|
||||
};
|
||||
/// @}
|
||||
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// Clockless template instantiations - see clockless.h for how the timing values are used
|
||||
//
|
||||
// Base template for clockless controllers. These controllers have 3 control points in their cycle for each bit.
|
||||
// At T=0 : the line is raised hi to start a bit
|
||||
// At T=T1 : the line is dropped low to transmit a zero bit
|
||||
// At T=T1+T2 : the line is dropped low to transmit a one bit
|
||||
// At T=T1+T2+T3 : the cycle is concluded (next bit can be sent)
|
||||
//
|
||||
// The units used for T1, T2, and T3 is nanoseconds.
|
||||
// For 8MHz/16MHz/24MHz frequencies, these values are also guaranteed
|
||||
// to be integral multiples of an 8MHz clock (125ns increments).
|
||||
//
|
||||
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#ifdef FASTLED_HAS_CLOCKLESS
|
||||
/// @name clockless controllers
|
||||
/// Provides timing definitions for the variety of clockless controllers supplied by the library.
|
||||
/// @{
|
||||
|
||||
// Allow clock that clockless controller is based on to have different
|
||||
// frequency than the CPU.
|
||||
#if !defined(CLOCKLESS_FREQUENCY)
|
||||
#define CLOCKLESS_FREQUENCY F_CPU
|
||||
#endif
|
||||
|
||||
// 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
|
||||
#define FMUL (CLOCKLESS_FREQUENCY/8000000)
|
||||
|
||||
// GE8822
|
||||
template <uint8_t DATA_PIN, EOrder RGB_ORDER = RGB>
|
||||
class GE8822Controller800Khz : public ClocklessController<DATA_PIN, 3 * FMUL, 5 * FMUL, 3 * FMUL, RGB_ORDER, 4> {};
|
||||
|
||||
// LPD1886
|
||||
template <uint8_t DATA_PIN, EOrder RGB_ORDER = RGB>
|
||||
class LPD1886Controller1250Khz : public ClocklessController<DATA_PIN, 2 * FMUL, 3 * FMUL, 2 * FMUL, RGB_ORDER, 4> {};
|
||||
|
||||
// LPD1886
|
||||
template <uint8_t DATA_PIN, EOrder RGB_ORDER = RGB>
|
||||
class LPD1886Controller1250Khz_8bit : public ClocklessController<DATA_PIN, 2 * FMUL, 3 * FMUL, 2 * FMUL, RGB_ORDER> {};
|
||||
|
||||
// WS2811@800khz 2 clocks, 5 clocks, 3 clocks
|
||||
template <uint8_t DATA_PIN, EOrder RGB_ORDER = RGB>
|
||||
class WS2812Controller800Khz : public ClocklessController<DATA_PIN, 2 * FMUL, 5 * FMUL, 3 * FMUL, RGB_ORDER> {};
|
||||
|
||||
template <uint8_t DATA_PIN, EOrder RGB_ORDER = RGB>
|
||||
class WS2811Controller800Khz : public ClocklessController<DATA_PIN, 3 * FMUL, 4 * FMUL, 3 * FMUL, RGB_ORDER> {};
|
||||
|
||||
template <uint8_t DATA_PIN, EOrder RGB_ORDER = RGB> //not tested
|
||||
class WS2813Controller : public ClocklessController<DATA_PIN, 3 * FMUL, 4 * FMUL, 3 * FMUL, RGB_ORDER> {};
|
||||
|
||||
template <uint8_t DATA_PIN, EOrder RGB_ORDER = RGB>
|
||||
class WS2811Controller400Khz : public ClocklessController<DATA_PIN, 4 * FMUL, 10 * FMUL, 6 * FMUL, RGB_ORDER> {};
|
||||
|
||||
template <uint8_t DATA_PIN, EOrder RGB_ORDER = RGB>
|
||||
class SK6822Controller : public ClocklessController<DATA_PIN, 3 * FMUL, 8 * FMUL, 3 * FMUL, RGB_ORDER> {};
|
||||
|
||||
template <uint8_t DATA_PIN, EOrder RGB_ORDER = RGB>
|
||||
class SM16703Controller : public ClocklessController<DATA_PIN, 3 * FMUL, 4 * FMUL, 3 * FMUL, RGB_ORDER> {};
|
||||
|
||||
template <uint8_t DATA_PIN, EOrder RGB_ORDER = RGB>
|
||||
class SK6812Controller : public ClocklessController<DATA_PIN, 3 * FMUL, 3 * FMUL, 4 * FMUL, RGB_ORDER> {};
|
||||
|
||||
template <uint8_t DATA_PIN, EOrder RGB_ORDER = RGB>
|
||||
class UCS1903Controller400Khz : public ClocklessController<DATA_PIN, 4 * FMUL, 12 * FMUL, 4 * FMUL, RGB_ORDER> {};
|
||||
|
||||
template <uint8_t DATA_PIN, EOrder RGB_ORDER = RGB>
|
||||
class UCS1903BController800Khz : public ClocklessController<DATA_PIN, 2 * FMUL, 4 * FMUL, 4 * FMUL, RGB_ORDER> {};
|
||||
|
||||
template <uint8_t DATA_PIN, EOrder RGB_ORDER = RGB>
|
||||
class UCS1904Controller800Khz : public ClocklessController<DATA_PIN, 3 * FMUL, 3 * FMUL, 4 * FMUL, RGB_ORDER> {};
|
||||
|
||||
template <uint8_t DATA_PIN, EOrder RGB_ORDER = RGB>
|
||||
class UCS2903Controller : public ClocklessController<DATA_PIN, 2 * FMUL, 6 * FMUL, 2 * FMUL, RGB_ORDER> {};
|
||||
|
||||
template <uint8_t DATA_PIN, EOrder RGB_ORDER = RGB>
|
||||
class TM1809Controller800Khz : public ClocklessController<DATA_PIN, 2 * FMUL, 5 * FMUL, 3 * FMUL, RGB_ORDER> {};
|
||||
|
||||
template <uint8_t DATA_PIN, EOrder RGB_ORDER = RGB>
|
||||
class TM1803Controller400Khz : public ClocklessController<DATA_PIN, 6 * FMUL, 9 * FMUL, 6 * FMUL, RGB_ORDER> {};
|
||||
|
||||
template <uint8_t DATA_PIN, EOrder RGB_ORDER = RGB>
|
||||
class TM1829Controller800Khz : public ClocklessController<DATA_PIN, 2 * FMUL, 5 * FMUL, 3 * FMUL, RGB_ORDER, 0, true, 500> {};
|
||||
|
||||
template <uint8_t DATA_PIN, EOrder RGB_ORDER = RGB>
|
||||
class GW6205Controller400Khz : public ClocklessController<DATA_PIN, 6 * FMUL, 7 * FMUL, 6 * FMUL, RGB_ORDER, 4> {};
|
||||
|
||||
template <uint8_t DATA_PIN, EOrder RGB_ORDER = RGB>
|
||||
class GW6205Controller800Khz : public ClocklessController<DATA_PIN, 2 * FMUL, 4 * FMUL, 4 * FMUL, RGB_ORDER, 4> {};
|
||||
|
||||
template <uint8_t DATA_PIN, EOrder RGB_ORDER = RGB>
|
||||
class PL9823Controller : public ClocklessController<DATA_PIN, 3 * FMUL, 8 * FMUL, 3 * FMUL, RGB_ORDER> {};
|
||||
|
||||
#else
|
||||
|
||||
// Similar to NS() macro, this calculates the number of cycles for
|
||||
// the clockless chipset (which may differ from CPU cycles)
|
||||
|
||||
#ifdef FASTLED_TEENSY4
|
||||
// just use raw nanosecond values for the teensy4
|
||||
#define C_NS(_NS) _NS
|
||||
#else
|
||||
#define C_NS(_NS) (((_NS * ((CLOCKLESS_FREQUENCY / 1000000L)) + 999)) / 1000)
|
||||
#endif
|
||||
|
||||
// GE8822 - 350ns 660ns 350ns
|
||||
template <uint8_t DATA_PIN, EOrder RGB_ORDER = RGB>
|
||||
class GE8822Controller800Khz : public ClocklessController<DATA_PIN, C_NS(350), C_NS(660), C_NS(350), RGB_ORDER, 4> {};
|
||||
|
||||
// GW6205@400khz - 800ns, 800ns, 800ns
|
||||
template <uint8_t DATA_PIN, EOrder RGB_ORDER = RGB>
|
||||
class GW6205Controller400Khz : public ClocklessController<DATA_PIN, C_NS(800), C_NS(800), C_NS(800), RGB_ORDER, 4> {};
|
||||
|
||||
// GW6205@400khz - 400ns, 400ns, 400ns
|
||||
template <uint8_t DATA_PIN, EOrder RGB_ORDER = RGB>
|
||||
class GW6205Controller800Khz : public ClocklessController<DATA_PIN, C_NS(400), C_NS(400), C_NS(400), RGB_ORDER, 4> {};
|
||||
|
||||
// UCS1903 - 500ns, 1500ns, 500ns
|
||||
template <uint8_t DATA_PIN, EOrder RGB_ORDER = RGB>
|
||||
class UCS1903Controller400Khz : public ClocklessController<DATA_PIN, C_NS(500), C_NS(1500), C_NS(500), RGB_ORDER> {};
|
||||
|
||||
// UCS1903B - 400ns, 450ns, 450ns
|
||||
template <uint8_t DATA_PIN, EOrder RGB_ORDER = RGB>
|
||||
class UCS1903BController800Khz : public ClocklessController<DATA_PIN, C_NS(400), C_NS(450), C_NS(450), RGB_ORDER> {};
|
||||
|
||||
// UCS1904 - 400ns, 400ns, 450ns
|
||||
template <uint8_t DATA_PIN, EOrder RGB_ORDER = RGB>
|
||||
class UCS1904Controller800Khz : public ClocklessController<DATA_PIN, C_NS(400), C_NS(400), C_NS(450), RGB_ORDER> {};
|
||||
|
||||
// UCS2903 - 250ns, 750ns, 250ns
|
||||
template <uint8_t DATA_PIN, EOrder RGB_ORDER = RGB>
|
||||
class UCS2903Controller : public ClocklessController<DATA_PIN, C_NS(250), C_NS(750), C_NS(250), RGB_ORDER> {};
|
||||
|
||||
// TM1809 - 350ns, 350ns, 550ns
|
||||
template <uint8_t DATA_PIN, EOrder RGB_ORDER = RGB>
|
||||
class TM1809Controller800Khz : public ClocklessController<DATA_PIN, C_NS(350), C_NS(350), C_NS(450), RGB_ORDER> {};
|
||||
|
||||
// WS2811 - 320ns, 320ns, 640ns
|
||||
template <uint8_t DATA_PIN, EOrder RGB_ORDER = RGB>
|
||||
class WS2811Controller800Khz : public ClocklessController<DATA_PIN, C_NS(320), C_NS(320), C_NS(640), RGB_ORDER> {};
|
||||
|
||||
// WS2813 - 320ns, 320ns, 640ns
|
||||
template <uint8_t DATA_PIN, EOrder RGB_ORDER = RGB>
|
||||
class WS2813Controller : public ClocklessController<DATA_PIN, C_NS(320), C_NS(320), C_NS(640), RGB_ORDER> {};
|
||||
|
||||
// WS2812 - 250ns, 625ns, 375ns
|
||||
template <uint8_t DATA_PIN, EOrder RGB_ORDER = RGB>
|
||||
class WS2812Controller800Khz : public ClocklessController<DATA_PIN, C_NS(250), C_NS(625), C_NS(375), RGB_ORDER> {};
|
||||
|
||||
// WS2811@400khz - 800ns, 800ns, 900ns
|
||||
template <uint8_t DATA_PIN, EOrder RGB_ORDER = RGB>
|
||||
class WS2811Controller400Khz : public ClocklessController<DATA_PIN, C_NS(800), C_NS(800), C_NS(900), RGB_ORDER> {};
|
||||
|
||||
// 750NS, 750NS, 750NS
|
||||
template <uint8_t DATA_PIN, EOrder RGB_ORDER = RGB>
|
||||
class TM1803Controller400Khz : public ClocklessController<DATA_PIN, C_NS(700), C_NS(1100), C_NS(700), RGB_ORDER> {};
|
||||
|
||||
template <uint8_t DATA_PIN, EOrder RGB_ORDER = RGB>
|
||||
class TM1829Controller800Khz : public ClocklessController<DATA_PIN, C_NS(340), C_NS(340), C_NS(550), RGB_ORDER, 0, true, 500> {};
|
||||
|
||||
template <uint8_t DATA_PIN, EOrder RGB_ORDER = RGB>
|
||||
class TM1829Controller1600Khz : public ClocklessController<DATA_PIN, C_NS(100), C_NS(300), C_NS(200), RGB_ORDER, 0, true, 500> {};
|
||||
|
||||
template <uint8_t DATA_PIN, EOrder RGB_ORDER = RGB>
|
||||
class LPD1886Controller1250Khz : public ClocklessController<DATA_PIN, C_NS(200), C_NS(400), C_NS(200), RGB_ORDER, 4> {};
|
||||
|
||||
template <uint8_t DATA_PIN, EOrder RGB_ORDER = RGB>
|
||||
class LPD1886Controller1250Khz_8bit : public ClocklessController<DATA_PIN, C_NS(200), C_NS(400), C_NS(200), RGB_ORDER> {};
|
||||
|
||||
|
||||
template <uint8_t DATA_PIN, EOrder RGB_ORDER = RGB>
|
||||
class SK6822Controller : public ClocklessController<DATA_PIN, C_NS(375), C_NS(1000), C_NS(375), RGB_ORDER> {};
|
||||
|
||||
template <uint8_t DATA_PIN, EOrder RGB_ORDER = RGB>
|
||||
class SK6812Controller : public ClocklessController<DATA_PIN, C_NS(300), C_NS(300), C_NS(600), RGB_ORDER> {};
|
||||
|
||||
template <uint8_t DATA_PIN, EOrder RGB_ORDER = RGB>
|
||||
class SM16703Controller : public ClocklessController<DATA_PIN, C_NS(300), C_NS(600), C_NS(300), RGB_ORDER> {};
|
||||
|
||||
template <uint8_t DATA_PIN, EOrder RGB_ORDER = RGB>
|
||||
class PL9823Controller : public ClocklessController<DATA_PIN, C_NS(350), C_NS(1010), C_NS(350), RGB_ORDER> {};
|
||||
#endif
|
||||
///@}
|
||||
|
||||
#endif
|
||||
///@}
|
||||
FASTLED_NAMESPACE_END
|
||||
|
||||
#endif
|
||||
84
components/FastLED-idf/color.h
Normal file
84
components/FastLED-idf/color.h
Normal file
@ -0,0 +1,84 @@
|
||||
#ifndef __INC_COLOR_H
|
||||
#define __INC_COLOR_H
|
||||
|
||||
#include "FastLED.h"
|
||||
|
||||
FASTLED_NAMESPACE_BEGIN
|
||||
|
||||
///@file color.h
|
||||
/// contains definitions for color correction and temperature
|
||||
///@defgroup ColorEnums Color correction/temperature
|
||||
/// definitions for color correction and light temperatures
|
||||
///@{
|
||||
typedef enum {
|
||||
// Color correction starting points
|
||||
|
||||
/// typical values for SMD5050 LEDs
|
||||
///@{
|
||||
TypicalSMD5050=0xFFB0F0 /* 255, 176, 240 */,
|
||||
TypicalLEDStrip=0xFFB0F0 /* 255, 176, 240 */,
|
||||
///@}
|
||||
|
||||
/// typical values for 8mm "pixels on a string"
|
||||
/// also for many through-hole 'T' package LEDs
|
||||
///@{
|
||||
Typical8mmPixel=0xFFE08C /* 255, 224, 140 */,
|
||||
TypicalPixelString=0xFFE08C /* 255, 224, 140 */,
|
||||
///@}
|
||||
|
||||
/// uncorrected color
|
||||
UncorrectedColor=0xFFFFFF
|
||||
|
||||
} LEDColorCorrection;
|
||||
|
||||
|
||||
typedef enum {
|
||||
/// @name Black-body radiation light sources
|
||||
/// Black-body radiation light sources emit a (relatively) continuous
|
||||
/// spectrum, and can be described as having a Kelvin 'temperature'
|
||||
///@{
|
||||
/// 1900 Kelvin
|
||||
Candle=0xFF9329 /* 1900 K, 255, 147, 41 */,
|
||||
/// 2600 Kelvin
|
||||
Tungsten40W=0xFFC58F /* 2600 K, 255, 197, 143 */,
|
||||
/// 2850 Kelvin
|
||||
Tungsten100W=0xFFD6AA /* 2850 K, 255, 214, 170 */,
|
||||
/// 3200 Kelvin
|
||||
Halogen=0xFFF1E0 /* 3200 K, 255, 241, 224 */,
|
||||
/// 5200 Kelvin
|
||||
CarbonArc=0xFFFAF4 /* 5200 K, 255, 250, 244 */,
|
||||
/// 5400 Kelvin
|
||||
HighNoonSun=0xFFFFFB /* 5400 K, 255, 255, 251 */,
|
||||
/// 6000 Kelvin
|
||||
DirectSunlight=0xFFFFFF /* 6000 K, 255, 255, 255 */,
|
||||
/// 7000 Kelvin
|
||||
OvercastSky=0xC9E2FF /* 7000 K, 201, 226, 255 */,
|
||||
/// 20000 Kelvin
|
||||
ClearBlueSky=0x409CFF /* 20000 K, 64, 156, 255 */,
|
||||
///@}
|
||||
|
||||
/// @name Gaseous light sources
|
||||
/// Gaseous light sources emit discrete spectral bands, and while we can
|
||||
/// approximate their aggregate hue with RGB values, they don't actually
|
||||
/// have a proper Kelvin temperature.
|
||||
///@{
|
||||
WarmFluorescent=0xFFF4E5 /* 0 K, 255, 244, 229 */,
|
||||
StandardFluorescent=0xF4FFFA /* 0 K, 244, 255, 250 */,
|
||||
CoolWhiteFluorescent=0xD4EBFF /* 0 K, 212, 235, 255 */,
|
||||
FullSpectrumFluorescent=0xFFF4F2 /* 0 K, 255, 244, 242 */,
|
||||
GrowLightFluorescent=0xFFEFF7 /* 0 K, 255, 239, 247 */,
|
||||
BlackLightFluorescent=0xA700FF /* 0 K, 167, 0, 255 */,
|
||||
MercuryVapor=0xD8F7FF /* 0 K, 216, 247, 255 */,
|
||||
SodiumVapor=0xFFD1B2 /* 0 K, 255, 209, 178 */,
|
||||
MetalHalide=0xF2FCFF /* 0 K, 242, 252, 255 */,
|
||||
HighPressureSodium=0xFFB74C /* 0 K, 255, 183, 76 */,
|
||||
///@}
|
||||
|
||||
/// Uncorrected temperature 0xFFFFFF
|
||||
UncorrectedTemperature=0xFFFFFF
|
||||
} ColorTemperature;
|
||||
|
||||
FASTLED_NAMESPACE_END
|
||||
|
||||
///@}
|
||||
#endif
|
||||
174
components/FastLED-idf/colorpalettes.cpp
Normal file
174
components/FastLED-idf/colorpalettes.cpp
Normal file
@ -0,0 +1,174 @@
|
||||
#ifndef __INC_COLORPALETTES_H
|
||||
#define __INC_COLORPALETTES_H
|
||||
#define FASTLED_INTERNAL
|
||||
#include "FastLED.h"
|
||||
#include "colorutils.h"
|
||||
#include "colorpalettes.h"
|
||||
|
||||
FASTLED_USING_NAMESPACE
|
||||
|
||||
|
||||
// Preset color schemes, such as they are.
|
||||
|
||||
// These schemes are all declared as "PROGMEM", meaning
|
||||
// that they won't take up SRAM on AVR chips until used.
|
||||
// Furthermore, the compiler won't even include these
|
||||
// in your PROGMEM (flash) storage unless you specifically
|
||||
// use each one, so you only 'pay for' those you actually use.
|
||||
|
||||
|
||||
extern const TProgmemRGBPalette16 CloudColors_p FL_PROGMEM =
|
||||
{
|
||||
CRGB::Blue,
|
||||
CRGB::DarkBlue,
|
||||
CRGB::DarkBlue,
|
||||
CRGB::DarkBlue,
|
||||
|
||||
CRGB::DarkBlue,
|
||||
CRGB::DarkBlue,
|
||||
CRGB::DarkBlue,
|
||||
CRGB::DarkBlue,
|
||||
|
||||
CRGB::Blue,
|
||||
CRGB::DarkBlue,
|
||||
CRGB::SkyBlue,
|
||||
CRGB::SkyBlue,
|
||||
|
||||
CRGB::LightBlue,
|
||||
CRGB::White,
|
||||
CRGB::LightBlue,
|
||||
CRGB::SkyBlue
|
||||
};
|
||||
|
||||
extern const TProgmemRGBPalette16 LavaColors_p FL_PROGMEM =
|
||||
{
|
||||
CRGB::Black,
|
||||
CRGB::Maroon,
|
||||
CRGB::Black,
|
||||
CRGB::Maroon,
|
||||
|
||||
CRGB::DarkRed,
|
||||
CRGB::Maroon,
|
||||
CRGB::DarkRed,
|
||||
|
||||
CRGB::DarkRed,
|
||||
CRGB::DarkRed,
|
||||
CRGB::Red,
|
||||
CRGB::Orange,
|
||||
|
||||
CRGB::White,
|
||||
CRGB::Orange,
|
||||
CRGB::Red,
|
||||
CRGB::DarkRed
|
||||
};
|
||||
|
||||
|
||||
extern const TProgmemRGBPalette16 OceanColors_p FL_PROGMEM =
|
||||
{
|
||||
CRGB::MidnightBlue,
|
||||
CRGB::DarkBlue,
|
||||
CRGB::MidnightBlue,
|
||||
CRGB::Navy,
|
||||
|
||||
CRGB::DarkBlue,
|
||||
CRGB::MediumBlue,
|
||||
CRGB::SeaGreen,
|
||||
CRGB::Teal,
|
||||
|
||||
CRGB::CadetBlue,
|
||||
CRGB::Blue,
|
||||
CRGB::DarkCyan,
|
||||
CRGB::CornflowerBlue,
|
||||
|
||||
CRGB::Aquamarine,
|
||||
CRGB::SeaGreen,
|
||||
CRGB::Aqua,
|
||||
CRGB::LightSkyBlue
|
||||
};
|
||||
|
||||
extern const TProgmemRGBPalette16 ForestColors_p FL_PROGMEM =
|
||||
{
|
||||
CRGB::DarkGreen,
|
||||
CRGB::DarkGreen,
|
||||
CRGB::DarkOliveGreen,
|
||||
CRGB::DarkGreen,
|
||||
|
||||
CRGB::Green,
|
||||
CRGB::ForestGreen,
|
||||
CRGB::OliveDrab,
|
||||
CRGB::Green,
|
||||
|
||||
CRGB::SeaGreen,
|
||||
CRGB::MediumAquamarine,
|
||||
CRGB::LimeGreen,
|
||||
CRGB::YellowGreen,
|
||||
|
||||
CRGB::LightGreen,
|
||||
CRGB::LawnGreen,
|
||||
CRGB::MediumAquamarine,
|
||||
CRGB::ForestGreen
|
||||
};
|
||||
|
||||
/// HSV Rainbow
|
||||
extern const TProgmemRGBPalette16 RainbowColors_p FL_PROGMEM =
|
||||
{
|
||||
0xFF0000, 0xD52A00, 0xAB5500, 0xAB7F00,
|
||||
0xABAB00, 0x56D500, 0x00FF00, 0x00D52A,
|
||||
0x00AB55, 0x0056AA, 0x0000FF, 0x2A00D5,
|
||||
0x5500AB, 0x7F0081, 0xAB0055, 0xD5002B
|
||||
};
|
||||
|
||||
/// HSV Rainbow colors with alternatating stripes of black
|
||||
#define RainbowStripesColors_p RainbowStripeColors_p
|
||||
extern const TProgmemRGBPalette16 RainbowStripeColors_p FL_PROGMEM =
|
||||
{
|
||||
0xFF0000, 0x000000, 0xAB5500, 0x000000,
|
||||
0xABAB00, 0x000000, 0x00FF00, 0x000000,
|
||||
0x00AB55, 0x000000, 0x0000FF, 0x000000,
|
||||
0x5500AB, 0x000000, 0xAB0055, 0x000000
|
||||
};
|
||||
|
||||
/// HSV color ramp: blue purple ping red orange yellow (and back)
|
||||
/// Basically, everything but the greens, which tend to make
|
||||
/// people's skin look unhealthy. This palette is good for
|
||||
/// lighting at a club or party, where it'll be shining on people.
|
||||
extern const TProgmemRGBPalette16 PartyColors_p FL_PROGMEM =
|
||||
{
|
||||
0x5500AB, 0x84007C, 0xB5004B, 0xE5001B,
|
||||
0xE81700, 0xB84700, 0xAB7700, 0xABAB00,
|
||||
0xAB5500, 0xDD2200, 0xF2000E, 0xC2003E,
|
||||
0x8F0071, 0x5F00A1, 0x2F00D0, 0x0007F9
|
||||
};
|
||||
|
||||
/// Approximate "black body radiation" palette, akin to
|
||||
/// the FastLED 'HeatColor' function.
|
||||
/// Recommend that you use values 0-240 rather than
|
||||
/// the usual 0-255, as the last 15 colors will be
|
||||
/// 'wrapping around' from the hot end to the cold end,
|
||||
/// which looks wrong.
|
||||
extern const TProgmemRGBPalette16 HeatColors_p FL_PROGMEM =
|
||||
{
|
||||
0x000000,
|
||||
0x330000, 0x660000, 0x990000, 0xCC0000, 0xFF0000,
|
||||
0xFF3300, 0xFF6600, 0xFF9900, 0xFFCC00, 0xFFFF00,
|
||||
0xFFFF33, 0xFFFF66, 0xFFFF99, 0xFFFFCC, 0xFFFFFF
|
||||
};
|
||||
|
||||
|
||||
// Gradient palette "Rainbow_gp",
|
||||
// provided for situations where you're going
|
||||
// to use a number of other gradient palettes, AND
|
||||
// you want a 'standard' FastLED rainbow as well.
|
||||
|
||||
DEFINE_GRADIENT_PALETTE( Rainbow_gp ) {
|
||||
0, 255, 0, 0, // Red
|
||||
32, 171, 85, 0, // Orange
|
||||
64, 171,171, 0, // Yellow
|
||||
96, 0,255, 0, // Green
|
||||
128, 0,171, 85, // Aqua
|
||||
160, 0, 0,255, // Blue
|
||||
192, 85, 0,171, // Purple
|
||||
224, 171, 0, 85, // Pink
|
||||
255, 255, 0, 0};// and back to Red
|
||||
|
||||
#endif
|
||||
57
components/FastLED-idf/colorpalettes.h
Normal file
57
components/FastLED-idf/colorpalettes.h
Normal file
@ -0,0 +1,57 @@
|
||||
#ifndef __INC_COLORPALETTES_H
|
||||
#define __INC_COLORPALETTES_H
|
||||
|
||||
#include "FastLED.h"
|
||||
#include "colorutils.h"
|
||||
|
||||
///@file colorpalettes.h
|
||||
/// contains definitions for the predefined color palettes supplied by FastLED.
|
||||
|
||||
FASTLED_NAMESPACE_BEGIN
|
||||
|
||||
///@defgroup Colorpalletes Pre-defined color palletes
|
||||
/// These schemes are all declared as "PROGMEM", meaning
|
||||
/// that they won't take up SRAM on AVR chips until used.
|
||||
/// Furthermore, the compiler won't even include these
|
||||
/// in your PROGMEM (flash) storage unless you specifically
|
||||
/// use each one, so you only 'pay for' those you actually use.
|
||||
|
||||
///@{
|
||||
|
||||
/// Cloudy color pallete
|
||||
extern const TProgmemRGBPalette16 CloudColors_p FL_PROGMEM;
|
||||
/// Lava colors
|
||||
extern const TProgmemRGBPalette16 LavaColors_p FL_PROGMEM;
|
||||
/// Ocean colors, blues and whites
|
||||
extern const TProgmemRGBPalette16 OceanColors_p FL_PROGMEM;
|
||||
/// Forest colors, greens
|
||||
extern const TProgmemRGBPalette16 ForestColors_p FL_PROGMEM;
|
||||
|
||||
/// HSV Rainbow
|
||||
extern const TProgmemRGBPalette16 RainbowColors_p FL_PROGMEM;
|
||||
|
||||
#define RainbowStripesColors_p RainbowStripeColors_p
|
||||
/// HSV Rainbow colors with alternatating stripes of black
|
||||
extern const TProgmemRGBPalette16 RainbowStripeColors_p FL_PROGMEM;
|
||||
|
||||
/// HSV color ramp: blue purple ping red orange yellow (and back)
|
||||
/// Basically, everything but the greens, which tend to make
|
||||
/// people's skin look unhealthy. This palette is good for
|
||||
/// lighting at a club or party, where it'll be shining on people.
|
||||
extern const TProgmemRGBPalette16 PartyColors_p FL_PROGMEM;
|
||||
|
||||
/// Approximate "black body radiation" palette, akin to
|
||||
/// the FastLED 'HeatColor' function.
|
||||
/// Recommend that you use values 0-240 rather than
|
||||
/// the usual 0-255, as the last 15 colors will be
|
||||
/// 'wrapping around' from the hot end to the cold end,
|
||||
/// which looks wrong.
|
||||
extern const TProgmemRGBPalette16 HeatColors_p FL_PROGMEM;
|
||||
|
||||
|
||||
DECLARE_GRADIENT_PALETTE( Rainbow_gp);
|
||||
|
||||
FASTLED_NAMESPACE_END
|
||||
|
||||
///@}
|
||||
#endif
|
||||
1198
components/FastLED-idf/colorutils.cpp
Normal file
1198
components/FastLED-idf/colorutils.cpp
Normal file
File diff suppressed because it is too large
Load Diff
1706
components/FastLED-idf/colorutils.h
Normal file
1706
components/FastLED-idf/colorutils.h
Normal file
File diff suppressed because it is too large
Load Diff
1
components/FastLED-idf/component.mk
Normal file
1
components/FastLED-idf/component.mk
Normal file
@ -0,0 +1 @@
|
||||
COMPONENT_ADD_INCLUDEDIRS := .
|
||||
418
components/FastLED-idf/controller.h
Normal file
418
components/FastLED-idf/controller.h
Normal file
@ -0,0 +1,418 @@
|
||||
#ifndef __INC_CONTROLLER_H
|
||||
#define __INC_CONTROLLER_H
|
||||
|
||||
///@file controller.h
|
||||
/// base definitions used by led controllers for writing out led data
|
||||
|
||||
#include "FastLED.h"
|
||||
#include "led_sysdefs.h"
|
||||
#include "pixeltypes.h"
|
||||
#include "color.h"
|
||||
#include <stddef.h>
|
||||
|
||||
FASTLED_NAMESPACE_BEGIN
|
||||
|
||||
#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_BYTE2(RO) ((RO) & 0x3)
|
||||
|
||||
// operator byte *(struct CRGB[] arr) { return (byte*)arr; }
|
||||
|
||||
#define DISABLE_DITHER 0x00
|
||||
#define BINARY_DITHER 0x01
|
||||
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.
|
||||
/// 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 {
|
||||
protected:
|
||||
friend class CFastLED;
|
||||
CRGB *m_Data;
|
||||
CLEDController *m_pNext;
|
||||
CRGB m_ColorCorrection;
|
||||
CRGB m_ColorTemperature;
|
||||
EDitherMode m_DitherMode;
|
||||
int m_nLeds;
|
||||
static CLEDController *m_pHead;
|
||||
static CLEDController *m_pTail;
|
||||
|
||||
/// set all the leds on the controller to a given color
|
||||
///@param data the crgb color to set the leds to
|
||||
///@param nLeds the numner of leds to set to this color
|
||||
///@param scale the rgb scaling value for outputting color
|
||||
virtual void showColor(const struct CRGB & data, int nLeds, CRGB scale) = 0;
|
||||
|
||||
/// write the passed in rgb data out to the leds managed by this controller
|
||||
///@param data the rgb data to write out to the strip
|
||||
///@param nLeds the number of leds being written out
|
||||
///@param scale the rgb scaling to apply to each led before writing it out
|
||||
virtual void show(const struct CRGB *data, int nLeds, CRGB scale) = 0;
|
||||
|
||||
public:
|
||||
/// create an led controller object, add it to the chain of controllers
|
||||
CLEDController() : m_Data(NULL), m_ColorCorrection(UncorrectedColor), m_ColorTemperature(UncorrectedTemperature), m_DitherMode(BINARY_DITHER), m_nLeds(0) {
|
||||
m_pNext = NULL;
|
||||
if(m_pHead==NULL) { m_pHead = this; }
|
||||
if(m_pTail != NULL) { m_pTail->m_pNext = this; }
|
||||
m_pTail = this;
|
||||
}
|
||||
|
||||
///initialize the LED controller
|
||||
virtual void init() = 0;
|
||||
|
||||
///clear out/zero out the given number of leds.
|
||||
virtual void clearLeds(int nLeds) { showColor(CRGB::Black, nLeds, CRGB::Black); }
|
||||
|
||||
/// show function w/integer brightness, will scale for color correction and temperature
|
||||
void show(const struct CRGB *data, int nLeds, uint8_t brightness) {
|
||||
show(data, nLeds, getAdjustment(brightness));
|
||||
}
|
||||
|
||||
/// show function w/integer brightness, will scale for color correction and temperature
|
||||
void showColor(const struct CRGB &data, int nLeds, uint8_t brightness) {
|
||||
showColor(data, nLeds, getAdjustment(brightness));
|
||||
}
|
||||
|
||||
/// show function using the "attached to this controller" led data
|
||||
void showLeds(uint8_t brightness=255) {
|
||||
show(m_Data, m_nLeds, getAdjustment(brightness));
|
||||
}
|
||||
|
||||
/// show the given color on the led strip
|
||||
void showColor(const struct CRGB & data, uint8_t brightness=255) {
|
||||
showColor(data, m_nLeds, getAdjustment(brightness));
|
||||
}
|
||||
|
||||
/// get the first led controller in the chain of controllers
|
||||
static CLEDController *head() { return m_pHead; }
|
||||
/// get the next controller in the chain after this one. will return NULL at the end of the chain
|
||||
CLEDController *next() { return m_pNext; }
|
||||
|
||||
/// set the default array of leds to be used by this controller
|
||||
CLEDController & setLeds(CRGB *data, int nLeds) {
|
||||
m_Data = data;
|
||||
m_nLeds = nLeds;
|
||||
return *this;
|
||||
}
|
||||
|
||||
/// zero out the led data managed by this controller
|
||||
void clearLedData() {
|
||||
if(m_Data) {
|
||||
memset8((void*)m_Data, 0, sizeof(struct CRGB) * m_nLeds);
|
||||
}
|
||||
}
|
||||
|
||||
/// How many leds does this controller manage?
|
||||
virtual 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]; }
|
||||
|
||||
/// set the dithering mode for this controller to use
|
||||
inline CLEDController & setDither(uint8_t ditherMode = BINARY_DITHER) { m_DitherMode = ditherMode; return *this; }
|
||||
/// get the dithering option currently set for this controller
|
||||
inline uint8_t getDither() { return m_DitherMode; }
|
||||
|
||||
/// the the color corrction to use for this controller, expressed as an rgb object
|
||||
CLEDController & setCorrection(CRGB correction) { m_ColorCorrection = correction; return *this; }
|
||||
/// set the color correction to use for this controller
|
||||
CLEDController & setCorrection(LEDColorCorrection correction) { m_ColorCorrection = correction; return *this; }
|
||||
/// get the correction value used by this controller
|
||||
CRGB getCorrection() { return m_ColorCorrection; }
|
||||
|
||||
/// set the color temperature, aka white point, for this controller
|
||||
CLEDController & setTemperature(CRGB temperature) { m_ColorTemperature = temperature; return *this; }
|
||||
/// set the color temperature, aka white point, for this controller
|
||||
CLEDController & setTemperature(ColorTemperature temperature) { m_ColorTemperature = temperature; return *this; }
|
||||
/// get the color temperature, aka whipe point, for this controller
|
||||
CRGB getTemperature() { return m_ColorTemperature; }
|
||||
|
||||
/// Get the combined brightness/color adjustment for this controller
|
||||
CRGB getAdjustment(uint8_t scale) {
|
||||
return computeAdjustment(scale, m_ColorCorrection, m_ColorTemperature);
|
||||
}
|
||||
|
||||
static CRGB computeAdjustment(uint8_t scale, const CRGB & colorCorrection, const CRGB & colorTemperature) {
|
||||
#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++) {
|
||||
uint8_t cc = colorCorrection.raw[i];
|
||||
uint8_t ct = colorTemperature.raw[i];
|
||||
if(cc > 0 && ct > 0) {
|
||||
uint32_t work = (((uint32_t)cc)+1) * (((uint32_t)ct)+1) * scale;
|
||||
work /= 0x10000L;
|
||||
adj.raw[i] = work & 0xFF;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return adj;
|
||||
#endif
|
||||
}
|
||||
virtual uint16_t getMaxRefreshRate() const { return 0; }
|
||||
};
|
||||
|
||||
// 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
|
||||
// centralize 8/12/16 conversions here as well.
|
||||
template<EOrder RGB_ORDER, int LANES=1, uint32_t MASK=0xFFFFFFFF>
|
||||
struct PixelController {
|
||||
const uint8_t *mData;
|
||||
int mLen,mLenRemaining;
|
||||
uint8_t d[3];
|
||||
uint8_t e[3];
|
||||
CRGB mScale;
|
||||
int8_t mAdvance;
|
||||
int mOffsets[LANES];
|
||||
|
||||
PixelController(const PixelController & other) {
|
||||
d[0] = other.d[0];
|
||||
d[1] = other.d[1];
|
||||
d[2] = other.d[2];
|
||||
e[0] = other.e[0];
|
||||
e[1] = other.e[1];
|
||||
e[2] = other.e[2];
|
||||
mData = other.mData;
|
||||
mScale = other.mScale;
|
||||
mAdvance = other.mAdvance;
|
||||
mLenRemaining = mLen = other.mLen;
|
||||
for(int i = 0; i < LANES; i++) { mOffsets[i] = other.mOffsets[i]; }
|
||||
|
||||
}
|
||||
|
||||
void initOffsets(int len) {
|
||||
int nOffset = 0;
|
||||
for(int i = 0; i < LANES; i++) {
|
||||
mOffsets[i] = nOffset;
|
||||
if((1<<i) & MASK) { nOffset += (len * mAdvance); }
|
||||
}
|
||||
}
|
||||
|
||||
PixelController(const uint8_t *d, int len, CRGB & s, EDitherMode dither = BINARY_DITHER, bool advance=true, uint8_t skip=0) : mData(d), mLen(len), mLenRemaining(len), mScale(s) {
|
||||
enable_dithering(dither);
|
||||
mData += skip;
|
||||
mAdvance = (advance) ? 3+skip : 0;
|
||||
initOffsets(len);
|
||||
}
|
||||
|
||||
PixelController(const CRGB *d, int len, CRGB & s, EDitherMode dither = BINARY_DITHER) : mData((const uint8_t*)d), mLen(len), mLenRemaining(len), mScale(s) {
|
||||
enable_dithering(dither);
|
||||
mAdvance = 3;
|
||||
initOffsets(len);
|
||||
}
|
||||
|
||||
PixelController(const CRGB &d, int len, CRGB & s, EDitherMode dither = BINARY_DITHER) : mData((const uint8_t*)&d), mLen(len), mLenRemaining(len), mScale(s) {
|
||||
enable_dithering(dither);
|
||||
mAdvance = 0;
|
||||
initOffsets(len);
|
||||
}
|
||||
|
||||
void init_binary_dithering() {
|
||||
#if !defined(NO_DITHERING) || (NO_DITHERING != 1)
|
||||
|
||||
// Set 'virtual bits' of dithering to the highest level
|
||||
// that is not likely to cause excessive flickering at
|
||||
// low brightness levels + low update rates.
|
||||
// These pre-set values are a little ambitious, since
|
||||
// a 400Hz update rate for WS2811-family LEDs is only
|
||||
// possible with 85 pixels or fewer.
|
||||
// Once we have a 'number of milliseconds since last update'
|
||||
// value available here, we can quickly calculate the correct
|
||||
// number of 'virtual bits' on the fly with a couple of 'if'
|
||||
// statements -- no division required. At this point,
|
||||
// the division is done at compile time, so there's no runtime
|
||||
// cost, but the values are still hard-coded.
|
||||
#define MAX_LIKELY_UPDATE_RATE_HZ 400
|
||||
#define MIN_ACCEPTABLE_DITHER_RATE_HZ 50
|
||||
#define UPDATES_PER_FULL_DITHER_CYCLE (MAX_LIKELY_UPDATE_RATE_HZ / MIN_ACCEPTABLE_DITHER_RATE_HZ)
|
||||
#define RECOMMENDED_VIRTUAL_BITS ((UPDATES_PER_FULL_DITHER_CYCLE>1) + \
|
||||
(UPDATES_PER_FULL_DITHER_CYCLE>2) + \
|
||||
(UPDATES_PER_FULL_DITHER_CYCLE>4) + \
|
||||
(UPDATES_PER_FULL_DITHER_CYCLE>8) + \
|
||||
(UPDATES_PER_FULL_DITHER_CYCLE>16) + \
|
||||
(UPDATES_PER_FULL_DITHER_CYCLE>32) + \
|
||||
(UPDATES_PER_FULL_DITHER_CYCLE>64) + \
|
||||
(UPDATES_PER_FULL_DITHER_CYCLE>128) )
|
||||
#define VIRTUAL_BITS RECOMMENDED_VIRTUAL_BITS
|
||||
|
||||
// R is the digther signal 'counter'.
|
||||
static uint8_t R = 0;
|
||||
R++;
|
||||
|
||||
// R is wrapped around at 2^ditherBits,
|
||||
// so if ditherBits is 2, R will cycle through (0,1,2,3)
|
||||
uint8_t ditherBits = VIRTUAL_BITS;
|
||||
R &= (0x01 << ditherBits) - 1;
|
||||
|
||||
// Q is the "unscaled dither signal" itself.
|
||||
// It's initialized to the reversed bits of R.
|
||||
// If 'ditherBits' is 2, Q here will cycle through (0,128,64,192)
|
||||
uint8_t Q = 0;
|
||||
|
||||
// Reverse bits in a byte
|
||||
{
|
||||
if(R & 0x01) { Q |= 0x80; }
|
||||
if(R & 0x02) { Q |= 0x40; }
|
||||
if(R & 0x04) { Q |= 0x20; }
|
||||
if(R & 0x08) { Q |= 0x10; }
|
||||
if(R & 0x10) { Q |= 0x08; }
|
||||
if(R & 0x20) { Q |= 0x04; }
|
||||
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++) {
|
||||
uint8_t s = mScale.raw[i];
|
||||
e[i] = s ? (256/s) + 1 : 0;
|
||||
d[i] = scale8(Q, e[i]);
|
||||
#if (FASTLED_SCALE8_FIXED == 1)
|
||||
if(d[i]) (d[i]--);
|
||||
#endif
|
||||
if(e[i]) e[i]--;
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
// Do we have n pixels left to process?
|
||||
__attribute__((always_inline)) inline bool has(int n) {
|
||||
return mLenRemaining >= n;
|
||||
}
|
||||
|
||||
// toggle dithering enable
|
||||
void enable_dithering(EDitherMode dither) {
|
||||
switch(dither) {
|
||||
case BINARY_DITHER: init_binary_dithering(); break;
|
||||
default: d[0]=d[1]=d[2]=e[0]=e[1]=e[2]=0; break;
|
||||
}
|
||||
}
|
||||
|
||||
__attribute__((always_inline)) inline int size() { return mLen; }
|
||||
|
||||
// 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; mLenRemaining--;}
|
||||
|
||||
// step the dithering forward
|
||||
__attribute__((always_inline)) inline void stepDithering() {
|
||||
// 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() {
|
||||
d[RO(0)] = e[RO(0)] - d[RO(0)];
|
||||
}
|
||||
|
||||
template<int SLOT> __attribute__((always_inline)) inline static uint8_t loadByte(PixelController & pc) { return pc.mData[RO(SLOT)]; }
|
||||
template<int SLOT> __attribute__((always_inline)) inline static uint8_t loadByte(PixelController & pc, int lane) { return pc.mData[pc.mOffsets[lane] + RO(SLOT)]; }
|
||||
|
||||
template<int SLOT> __attribute__((always_inline)) inline static uint8_t dither(PixelController & pc, uint8_t b) { return b ? qadd8(b, pc.d[RO(SLOT)]) : 0; }
|
||||
template<int SLOT> __attribute__((always_inline)) inline static uint8_t dither(PixelController & , uint8_t b, uint8_t d) { return b ? qadd8(b,d) : 0; }
|
||||
|
||||
template<int SLOT> __attribute__((always_inline)) inline static uint8_t scale(PixelController & pc, uint8_t b) { return scale8(b, pc.mScale.raw[RO(SLOT)]); }
|
||||
template<int SLOT> __attribute__((always_inline)) inline static uint8_t scale(PixelController & , uint8_t b, uint8_t scale) { return scale8(b, scale); }
|
||||
|
||||
// composite shortcut functions for loading, dithering, and scaling
|
||||
template<int SLOT> __attribute__((always_inline)) inline static uint8_t loadAndScale(PixelController & pc) { return scale<SLOT>(pc, pc.dither<SLOT>(pc, pc.loadByte<SLOT>(pc))); }
|
||||
template<int SLOT> __attribute__((always_inline)) inline static uint8_t loadAndScale(PixelController & pc, int lane) { return scale<SLOT>(pc, pc.dither<SLOT>(pc, pc.loadByte<SLOT>(pc, lane))); }
|
||||
template<int SLOT> __attribute__((always_inline)) inline static uint8_t loadAndScale(PixelController & pc, int lane, uint8_t d, uint8_t scale) { return scale8(pc.dither<SLOT>(pc, pc.loadByte<SLOT>(pc, lane), d), scale); }
|
||||
template<int SLOT> __attribute__((always_inline)) inline static uint8_t loadAndScale(PixelController & pc, int lane, uint8_t scale) { return scale8(pc.loadByte<SLOT>(pc, lane), scale); }
|
||||
|
||||
template<int SLOT> __attribute__((always_inline)) inline static uint8_t advanceAndLoadAndScale(PixelController & pc) { pc.advanceData(); return pc.loadAndScale<SLOT>(pc); }
|
||||
template<int SLOT> __attribute__((always_inline)) inline static uint8_t advanceAndLoadAndScale(PixelController & pc, int lane) { pc.advanceData(); return pc.loadAndScale<SLOT>(pc, lane); }
|
||||
template<int SLOT> __attribute__((always_inline)) inline static uint8_t advanceAndLoadAndScale(PixelController & pc, int lane, uint8_t scale) { pc.advanceData(); return pc.loadAndScale<SLOT>(pc, lane, scale); }
|
||||
|
||||
template<int SLOT> __attribute__((always_inline)) inline static uint8_t getd(PixelController & pc) { return pc.d[RO(SLOT)]; }
|
||||
template<int SLOT> __attribute__((always_inline)) inline static uint8_t getscale(PixelController & pc) { return pc.mScale.raw[RO(SLOT)]; }
|
||||
|
||||
// Helper functions to get around gcc stupidities
|
||||
__attribute__((always_inline)) inline uint8_t loadAndScale0(int lane, uint8_t scale) { return loadAndScale<0>(*this, lane, scale); }
|
||||
__attribute__((always_inline)) inline uint8_t loadAndScale1(int lane, uint8_t scale) { return loadAndScale<1>(*this, lane, scale); }
|
||||
__attribute__((always_inline)) inline uint8_t loadAndScale2(int lane, uint8_t scale) { return loadAndScale<2>(*this, lane, scale); }
|
||||
__attribute__((always_inline)) inline uint8_t advanceAndLoadAndScale0(int lane, uint8_t scale) { return advanceAndLoadAndScale<0>(*this, lane, scale); }
|
||||
__attribute__((always_inline)) inline uint8_t stepAdvanceAndLoadAndScale0(int lane, uint8_t scale) { stepDithering(); return advanceAndLoadAndScale<0>(*this, lane, scale); }
|
||||
|
||||
__attribute__((always_inline)) inline uint8_t loadAndScale0(int lane) { return loadAndScale<0>(*this, lane); }
|
||||
__attribute__((always_inline)) inline uint8_t loadAndScale1(int lane) { return loadAndScale<1>(*this, lane); }
|
||||
__attribute__((always_inline)) inline uint8_t loadAndScale2(int lane) { return loadAndScale<2>(*this, lane); }
|
||||
__attribute__((always_inline)) inline uint8_t advanceAndLoadAndScale0(int lane) { return advanceAndLoadAndScale<0>(*this, lane); }
|
||||
__attribute__((always_inline)) inline uint8_t stepAdvanceAndLoadAndScale0(int lane) { stepDithering(); return advanceAndLoadAndScale<0>(*this, lane); }
|
||||
|
||||
__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 getScale0() { return getscale<0>(*this); }
|
||||
__attribute__((always_inline)) inline uint8_t getScale1() { return getscale<1>(*this); }
|
||||
__attribute__((always_inline)) inline uint8_t getScale2() { return getscale<2>(*this); }
|
||||
};
|
||||
|
||||
template<EOrder RGB_ORDER, int LANES=1, uint32_t MASK=0xFFFFFFFF> class CPixelLEDController : public CLEDController {
|
||||
protected:
|
||||
virtual void showPixels(PixelController<RGB_ORDER,LANES,MASK> & pixels) = 0;
|
||||
|
||||
/// set all the leds on the controller to a given color
|
||||
///@param data the crgb color to set the leds to
|
||||
///@param nLeds the numner of leds to set to this color
|
||||
///@param scale the rgb scaling value for outputting color
|
||||
virtual void showColor(const struct CRGB & data, int nLeds, CRGB scale) {
|
||||
PixelController<RGB_ORDER, LANES, MASK> pixels(data, nLeds, scale, getDither());
|
||||
showPixels(pixels);
|
||||
}
|
||||
|
||||
/// write the passed in rgb data out to the leds managed by this controller
|
||||
///@param data the rgb data to write out to the strip
|
||||
///@param nLeds the number of leds being written out
|
||||
///@param scale the rgb scaling to apply to each led before writing it out
|
||||
virtual void show(const struct CRGB *data, int nLeds, CRGB scale) {
|
||||
PixelController<RGB_ORDER, LANES, MASK> pixels(data, nLeds, scale, getDither());
|
||||
showPixels(pixels);
|
||||
}
|
||||
|
||||
public:
|
||||
CPixelLEDController() : CLEDController() {}
|
||||
};
|
||||
|
||||
|
||||
FASTLED_NAMESPACE_END
|
||||
|
||||
#endif
|
||||
16
components/FastLED-idf/cpp_compat.h
Normal file
16
components/FastLED-idf/cpp_compat.h
Normal file
@ -0,0 +1,16 @@
|
||||
#ifndef __INC_CPP_COMPAT_H
|
||||
#define __INC_CPP_COMPAT_H
|
||||
|
||||
#include "FastLED.h"
|
||||
|
||||
#if __cplusplus <= 199711L
|
||||
|
||||
#define static_assert(expression, message)
|
||||
#define constexpr const
|
||||
|
||||
#else
|
||||
|
||||
// things that we can turn on if we're in a C++11 environment
|
||||
#endif
|
||||
|
||||
#endif
|
||||
65
components/FastLED-idf/dmx.h
Normal file
65
components/FastLED-idf/dmx.h
Normal file
@ -0,0 +1,65 @@
|
||||
#ifndef __INC_DMX_H
|
||||
#define __INC_DMX_H
|
||||
|
||||
#include "FastLED.h"
|
||||
|
||||
#ifdef DmxSimple_h
|
||||
#include <DmxSimple.h>
|
||||
#define HAS_DMX_SIMPLE
|
||||
|
||||
///@ingroup chipsets
|
||||
///@{
|
||||
FASTLED_NAMESPACE_BEGIN
|
||||
|
||||
// note - dmx simple must be included before FastSPI for this code to be enabled
|
||||
template <uint8_t DATA_PIN, EOrder RGB_ORDER = RGB> class DMXSimpleController : public CPixelLEDController<RGB_ORDER> {
|
||||
public:
|
||||
// initialize the LED controller
|
||||
virtual void init() { DmxSimple.usePin(DATA_PIN); }
|
||||
|
||||
protected:
|
||||
virtual void showPixels(PixelController<RGB_ORDER> & pixels) {
|
||||
int iChannel = 1;
|
||||
while(pixels.has(1)) {
|
||||
DmxSimple.write(iChannel++, pixels.loadAndScale0());
|
||||
DmxSimple.write(iChannel++, pixels.loadAndScale1());
|
||||
DmxSimple.write(iChannel++, pixels.loadAndScale2());
|
||||
pixels.advanceData();
|
||||
pixels.stepDithering();
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
FASTLED_NAMESPACE_END
|
||||
|
||||
#endif
|
||||
|
||||
#ifdef DmxSerial_h
|
||||
#include <DMXSerial.h>
|
||||
|
||||
FASTLED_NAMESPACE_BEGIN
|
||||
|
||||
template <EOrder RGB_ORDER = RGB> class DMXSerialController : public CPixelLEDController<RGB_ORDER> {
|
||||
public:
|
||||
// initialize the LED controller
|
||||
virtual void init() { DMXSerial.init(DMXController); }
|
||||
|
||||
virtual void showPixels(PixelController<RGB_ORDER> & pixels) {
|
||||
int iChannel = 1;
|
||||
while(pixels.has(1)) {
|
||||
DMXSerial.write(iChannel++, pixels.loadAndScale0());
|
||||
DMXSerial.write(iChannel++, pixels.loadAndScale1());
|
||||
DMXSerial.write(iChannel++, pixels.loadAndScale2());
|
||||
pixels.advanceData();
|
||||
pixels.stepDithering();
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
FASTLED_NAMESPACE_END
|
||||
///@}
|
||||
|
||||
#define HAS_DMX_SERIAL
|
||||
#endif
|
||||
|
||||
#endif
|
||||
69
components/FastLED-idf/fastled_config.h
Normal file
69
components/FastLED-idf/fastled_config.h
Normal file
@ -0,0 +1,69 @@
|
||||
#ifndef __INC_FASTLED_CONFIG_H
|
||||
#define __INC_FASTLED_CONFIG_H
|
||||
|
||||
#include "FastLED.h"
|
||||
|
||||
///@file fastled_config.h
|
||||
/// contains definitions that can be used to configure FastLED at compile time
|
||||
|
||||
// Use this option only for debugging pin access and forcing software pin access. Note that
|
||||
// software pin access only works in Arduino based environments. Forces use of digitalWrite
|
||||
// methods for pin access vs. direct hardware port access
|
||||
// #define FASTLED_FORCE_SOFTWARE_PINS
|
||||
|
||||
// Use this option only for debugging bitbang'd spi access or to work around bugs in hardware
|
||||
// spi access. Forces use of bit-banged spi, even on pins that has hardware SPI available.
|
||||
// #define FASTLED_FORCE_SOFTWARE_SPI
|
||||
|
||||
// Use this to force FastLED to allow interrupts in the clockless chipsets (or to force it to
|
||||
// disallow), overriding the default on platforms that support this. Set the value to 1 to
|
||||
// allow interrupts or 0 to disallow them.
|
||||
// #define FASTLED_ALLOW_INTERRUPTS 1
|
||||
// #define FASTLED_ALLOW_INTERRUPTS 0
|
||||
|
||||
// Use this to allow some integer overflows/underflows in the inoise functions.
|
||||
// The original implementions allowed this, and had some discontinuties in the noise
|
||||
// output. It's technically an implementation bug, and was fixed, but you may wish
|
||||
// to preserve the old look and feel of the inoise functions in your existing animations.
|
||||
// The default is 0: NO overflow, and 'continuous' noise output, aka the fixed way.
|
||||
// #define FASTLED_NOISE_ALLOW_AVERAGE_TO_OVERFLOW 0
|
||||
// #define FASTLED_NOISE_ALLOW_AVERAGE_TO_OVERFLOW 1
|
||||
|
||||
// Use this toggle whether or not to use the 'fixed' FastLED scale8. The initial scale8
|
||||
// had a problem where scale8(255,255) would give you 254. This is now fixed, and that
|
||||
// fix is enabled by default. However, if for some reason you have code that is not
|
||||
// working right as a result of this (e.g. code that was expecting the old scale8 behavior)
|
||||
// you can disable it here.
|
||||
#define FASTLED_SCALE8_FIXED 1
|
||||
// #define FASTLED_SCALE8_FIXED 0
|
||||
|
||||
// Use this toggle whether to use 'fixed' FastLED pixel blending, including ColorFromPalette.
|
||||
// The prior pixel blend functions had integer-rounding math errors that led to
|
||||
// small errors being inadvertently added to the low bits of blended colors, including colors
|
||||
// retrieved from color palettes using LINEAR_BLEND. This is now fixed, and the
|
||||
// fix is enabled by default. However, if for some reason you wish to run with the old
|
||||
// blending, including the integer rounding and color errors, you can disable the bugfix here.
|
||||
#define FASTLED_BLEND_FIXED 1
|
||||
// #define FASTLED_BLEND_FIXED 0
|
||||
|
||||
// Use this toggle whether to use 'fixed' FastLED 8- and 16-bit noise functions.
|
||||
// The prior noise functions had some math errors that led to 'discontinuities' in the
|
||||
// output, which by definition should be smooth and continuous. The bug led to
|
||||
// noise function output that had 'edges' and glitches in it. This is now fixed, and the
|
||||
// fix is enabled by default. However, if for some reason you wish to run with the old
|
||||
// noise code, including the glitches, you can disable the bugfix here.
|
||||
#define FASTLED_NOISE_FIXED 1
|
||||
//#define FASTLED_NOISE_FIXED 0
|
||||
|
||||
// Use this to determine how many times FastLED will attempt to re-transmit a frame if interrupted
|
||||
// for too long by interrupts.
|
||||
#ifndef FASTLED_INTERRUPT_RETRY_COUNT
|
||||
#define FASTLED_INTERRUPT_RETRY_COUNT 2
|
||||
#endif
|
||||
|
||||
// Use this toggle to enable global brightness in contollers that support is (ADA102 and SK9822).
|
||||
// It changes how color scaling works and uses global brightness before scaling down color values.
|
||||
// This enable much more accurate color control on low brightness settings.
|
||||
//#define FASTLED_USE_GLOBAL_BRIGHTNESS 1
|
||||
|
||||
#endif
|
||||
139
components/FastLED-idf/fastled_delay.h
Normal file
139
components/FastLED-idf/fastled_delay.h
Normal file
@ -0,0 +1,139 @@
|
||||
#ifndef __INC_FL_DELAY_H
|
||||
#define __INC_FL_DELAY_H
|
||||
|
||||
#include "FastLED.h"
|
||||
|
||||
///@file fastled_delay.h
|
||||
///Utility functions and classes for managing delaycycles
|
||||
|
||||
FASTLED_NAMESPACE_BEGIN
|
||||
|
||||
/// Class to ensure that a minimum amount of time has kicked since the last time run - and delay if not enough time has passed yet
|
||||
/// this should make sure that chipsets that have
|
||||
template<int WAIT> class CMinWait {
|
||||
uint16_t mLastMicros;
|
||||
public:
|
||||
CMinWait() { mLastMicros = 0; }
|
||||
|
||||
void wait() {
|
||||
uint16_t diff;
|
||||
do {
|
||||
diff = (micros() & 0xFFFF) - mLastMicros;
|
||||
} while(diff < WAIT);
|
||||
}
|
||||
|
||||
void mark() { mLastMicros = micros() & 0xFFFF; }
|
||||
};
|
||||
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// Clock cycle counted delay loop
|
||||
//
|
||||
////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
// Default is now just 'nop', with special case for AVR
|
||||
|
||||
// ESP32 core has it's own definition of NOP, so undef it first
|
||||
#ifdef ESP32
|
||||
#undef NOP
|
||||
#undef NOP2
|
||||
#endif
|
||||
|
||||
#if defined(__AVR__)
|
||||
# define FL_NOP __asm__ __volatile__ ("cp r0,r0\n");
|
||||
# define FL_NOP2 __asm__ __volatile__ ("rjmp .+0");
|
||||
#else
|
||||
# define FL_NOP __asm__ __volatile__ ("nop\n");
|
||||
# define FL_NOP2 __asm__ __volatile__ ("nop\n\t nop\n");
|
||||
#endif
|
||||
|
||||
// predeclaration to not upset the compiler
|
||||
template<int CYCLES> inline void delaycycles();
|
||||
template<int CYCLES> inline void delaycycles_min1() {
|
||||
delaycycles<1>();
|
||||
delaycycles<CYCLES-1>();
|
||||
}
|
||||
|
||||
|
||||
// TODO: ARM version of _delaycycles_
|
||||
|
||||
// usable definition
|
||||
#if defined(FASTLED_AVR)
|
||||
// worker template - this will nop for LOOP * 3 + PAD cycles total
|
||||
template<int LOOP, int PAD> inline void _delaycycles_AVR() {
|
||||
delaycycles<PAD>();
|
||||
// the loop below is 3 cycles * LOOP. the LDI is one cycle,
|
||||
// the DEC is 1 cycle, the BRNE is 2 cycles if looping back and
|
||||
// 1 if not (the LDI balances out the BRNE being 1 cycle on exit)
|
||||
__asm__ __volatile__ (
|
||||
" LDI R16, %0\n"
|
||||
"L_%=: DEC R16\n"
|
||||
" BRNE L_%=\n"
|
||||
: /* no outputs */
|
||||
: "M" (LOOP)
|
||||
: "r16"
|
||||
);
|
||||
}
|
||||
|
||||
template<int CYCLES> __attribute__((always_inline)) inline void delaycycles() {
|
||||
_delaycycles_AVR<CYCLES / 3, CYCLES % 3>();
|
||||
}
|
||||
#else
|
||||
// template<int LOOP, int PAD> inline void _delaycycles_ARM() {
|
||||
// delaycycles<PAD>();
|
||||
// // the loop below is 3 cycles * LOOP. the LDI is one cycle,
|
||||
// // the DEC is 1 cycle, the BRNE is 2 cycles if looping back and
|
||||
// // 1 if not (the LDI balances out the BRNE being 1 cycle on exit)
|
||||
// __asm__ __volatile__ (
|
||||
// " mov.w r9, %0\n"
|
||||
// "L_%=: subs.w r9, r9, #1\n"
|
||||
// " bne.n L_%=\n"
|
||||
// : /* no outputs */
|
||||
// : "M" (LOOP)
|
||||
// : "r9"
|
||||
// );
|
||||
// }
|
||||
|
||||
|
||||
template<int CYCLES> __attribute__((always_inline)) inline void delaycycles() {
|
||||
// _delaycycles_ARM<CYCLES / 3, CYCLES % 3>();
|
||||
FL_NOP; delaycycles<CYCLES-1>();
|
||||
}
|
||||
#endif
|
||||
|
||||
// pre-instantiations for values small enough to not need the loop, as well as sanity holders
|
||||
// for some negative values.
|
||||
template<> __attribute__((always_inline)) inline void delaycycles<-10>() {}
|
||||
template<> __attribute__((always_inline)) inline void delaycycles<-9>() {}
|
||||
template<> __attribute__((always_inline)) inline void delaycycles<-8>() {}
|
||||
template<> __attribute__((always_inline)) inline void delaycycles<-7>() {}
|
||||
template<> __attribute__((always_inline)) inline void delaycycles<-6>() {}
|
||||
template<> __attribute__((always_inline)) inline void delaycycles<-5>() {}
|
||||
template<> __attribute__((always_inline)) inline void delaycycles<-4>() {}
|
||||
template<> __attribute__((always_inline)) inline void delaycycles<-3>() {}
|
||||
template<> __attribute__((always_inline)) inline void delaycycles<-2>() {}
|
||||
template<> __attribute__((always_inline)) inline void delaycycles<-1>() {}
|
||||
template<> __attribute__((always_inline)) inline void delaycycles<0>() {}
|
||||
template<> __attribute__((always_inline)) inline void delaycycles<1>() {FL_NOP;}
|
||||
template<> __attribute__((always_inline)) inline void delaycycles<2>() {FL_NOP2;}
|
||||
template<> __attribute__((always_inline)) inline void delaycycles<3>() {FL_NOP;FL_NOP2;}
|
||||
template<> __attribute__((always_inline)) inline void delaycycles<4>() {FL_NOP2;FL_NOP2;}
|
||||
template<> __attribute__((always_inline)) inline void delaycycles<5>() {FL_NOP2;FL_NOP2;FL_NOP;}
|
||||
|
||||
// Some timing related macros/definitions
|
||||
|
||||
// Macro to convert from nano-seconds to clocks and clocks to nano-seconds
|
||||
// #define NS(_NS) (_NS / (1000 / (F_CPU / 1000000L)))
|
||||
#define F_CPU_MHZ (F_CPU / 1000000L)
|
||||
|
||||
// #define NS(_NS) ( (_NS * (F_CPU / 1000000L))) / 1000
|
||||
#define NS(_NS) (((_NS * F_CPU_MHZ) + 999) / 1000)
|
||||
#define CLKS_TO_MICROS(_CLKS) ((long)(_CLKS)) / (F_CPU / 1000000L)
|
||||
|
||||
// Macro for making sure there's enough time available
|
||||
#define NO_TIME(A, B, C) (NS(A) < 3 || NS(B) < 3 || NS(C) < 6)
|
||||
|
||||
FASTLED_NAMESPACE_END
|
||||
|
||||
#endif
|
||||
81
components/FastLED-idf/fastled_progmem.h
Normal file
81
components/FastLED-idf/fastled_progmem.h
Normal file
@ -0,0 +1,81 @@
|
||||
#ifndef __INC_FL_PROGMEM_H
|
||||
#define __INC_FL_PROGMEM_H
|
||||
|
||||
#include "FastLED.h"
|
||||
|
||||
///@file fastled_progmem.h
|
||||
/// wrapper definitions to allow seamless use of PROGMEM in environmens that have it
|
||||
|
||||
FASTLED_NAMESPACE_BEGIN
|
||||
|
||||
// Compatibility layer for devices that do or don't
|
||||
// have "PROGMEM" and the associated pgm_ accessors.
|
||||
//
|
||||
// If a platform supports PROGMEM, it should define
|
||||
// "FASTLED_USE_PROGMEM" as 1, otherwise FastLED will
|
||||
// fall back to NOT using PROGMEM.
|
||||
//
|
||||
// Whether or not pgmspace.h is #included is separately
|
||||
// controllable by FASTLED_INCLUDE_PGMSPACE, if needed.
|
||||
|
||||
|
||||
// If FASTLED_USE_PROGMEM is 1, we'll map FL_PROGMEM
|
||||
// and the FL_PGM_* accessors to the Arduino equivalents.
|
||||
#if FASTLED_USE_PROGMEM == 1
|
||||
#ifndef FASTLED_INCLUDE_PGMSPACE
|
||||
#define FASTLED_INCLUDE_PGMSPACE 1
|
||||
#endif
|
||||
|
||||
#if FASTLED_INCLUDE_PGMSPACE == 1
|
||||
#include <avr/pgmspace.h>
|
||||
#endif
|
||||
|
||||
#define FL_PROGMEM PROGMEM
|
||||
|
||||
// Note: only the 'near' memory wrappers are provided.
|
||||
// If you're using 'far' memory, you already have
|
||||
// portability issues to work through, but you could
|
||||
// add more support here if needed.
|
||||
#define FL_PGM_READ_BYTE_NEAR(x) (pgm_read_byte_near(x))
|
||||
#define FL_PGM_READ_WORD_NEAR(x) (pgm_read_word_near(x))
|
||||
#define FL_PGM_READ_DWORD_NEAR(x) (pgm_read_dword_near(x))
|
||||
|
||||
// Workaround for http://gcc.gnu.org/bugzilla/show_bug.cgi?id=34734
|
||||
#if __GNUC__ < 4 || (__GNUC__ == 4 && (__GNUC_MINOR__ < 6))
|
||||
#ifdef FASTLED_AVR
|
||||
#ifdef PROGMEM
|
||||
#undef PROGMEM
|
||||
#define PROGMEM __attribute__((section(".progmem.data")))
|
||||
#endif
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#else
|
||||
// If FASTLED_USE_PROGMEM is 0 or undefined,
|
||||
// we'll use regular memory (RAM) access.
|
||||
|
||||
//empty PROGMEM simulation
|
||||
#define FL_PROGMEM
|
||||
#define FL_PGM_READ_BYTE_NEAR(x) (*((const uint8_t*)(x)))
|
||||
#define FL_PGM_READ_WORD_NEAR(x) (*((const uint16_t*)(x)))
|
||||
#define FL_PGM_READ_DWORD_NEAR(x) (*((const uint32_t*)(x)))
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
// On some platforms, most notably ARM M0, unaligned access
|
||||
// to 'PROGMEM' for multibyte values (eg read dword) is
|
||||
// not allowed and causes a crash. This macro can help
|
||||
// force 4-byte alignment as needed. The FastLED gradient
|
||||
// palette code uses 'read dword', and now uses this macro
|
||||
// to make sure that gradient palettes are 4-byte aligned.
|
||||
#if defined(FASTLED_ARM) || defined(ESP32) || defined(ESP8266)
|
||||
#define FL_ALIGN_PROGMEM __attribute__ ((aligned (4)))
|
||||
#else
|
||||
#define FL_ALIGN_PROGMEM
|
||||
#endif
|
||||
|
||||
|
||||
FASTLED_NAMESPACE_END
|
||||
|
||||
#endif
|
||||
270
components/FastLED-idf/fastpin.h
Normal file
270
components/FastLED-idf/fastpin.h
Normal file
@ -0,0 +1,270 @@
|
||||
#ifndef __INC_FASTPIN_H
|
||||
#define __INC_FASTPIN_H
|
||||
|
||||
#include "FastLED.h"
|
||||
|
||||
#include "led_sysdefs.h"
|
||||
#include <stddef.h>
|
||||
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wignored-qualifiers"
|
||||
|
||||
///@file fastpin.h
|
||||
/// Class base definitions for defining fast pin access
|
||||
|
||||
FASTLED_NAMESPACE_BEGIN
|
||||
|
||||
#define NO_PIN 255
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// Pin access class - needs to tune for various platforms (naive fallback solution?)
|
||||
//
|
||||
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
class Selectable {
|
||||
public:
|
||||
virtual void select() = 0;
|
||||
virtual void release() = 0;
|
||||
virtual bool isSelected() = 0;
|
||||
};
|
||||
|
||||
#if !defined(FASTLED_NO_PINMAP)
|
||||
|
||||
class Pin : public Selectable {
|
||||
volatile RwReg *mPort;
|
||||
volatile RoReg *mInPort;
|
||||
RwReg mPinMask;
|
||||
uint8_t mPin;
|
||||
|
||||
void _init() {
|
||||
mPinMask = digitalPinToBitMask(mPin);
|
||||
mPort = (volatile RwReg*)portOutputRegister(digitalPinToPort(mPin));
|
||||
mInPort = (volatile RoReg*)portInputRegister(digitalPinToPort(mPin));
|
||||
}
|
||||
public:
|
||||
Pin(int pin) : mPin(pin) { _init(); }
|
||||
|
||||
typedef volatile RwReg * port_ptr_t;
|
||||
typedef RwReg port_t;
|
||||
|
||||
inline void setOutput() { pinMode(mPin, OUTPUT); }
|
||||
inline void setInput() { pinMode(mPin, INPUT); }
|
||||
|
||||
inline void hi() __attribute__ ((always_inline)) { *mPort |= mPinMask; }
|
||||
inline void lo() __attribute__ ((always_inline)) { *mPort &= ~mPinMask; }
|
||||
|
||||
inline void strobe() __attribute__ ((always_inline)) { toggle(); toggle(); }
|
||||
inline void toggle() __attribute__ ((always_inline)) { *mInPort = mPinMask; }
|
||||
|
||||
inline void hi(register port_ptr_t port) __attribute__ ((always_inline)) { *port |= mPinMask; }
|
||||
inline void lo(register port_ptr_t port) __attribute__ ((always_inline)) { *port &= ~mPinMask; }
|
||||
inline void set(register port_t val) __attribute__ ((always_inline)) { *mPort = val; }
|
||||
|
||||
inline void fastset(register port_ptr_t port, register port_t val) __attribute__ ((always_inline)) { *port = val; }
|
||||
|
||||
port_t hival() __attribute__ ((always_inline)) { return *mPort | mPinMask; }
|
||||
port_t loval() __attribute__ ((always_inline)) { return *mPort & ~mPinMask; }
|
||||
port_ptr_t port() __attribute__ ((always_inline)) { return mPort; }
|
||||
port_t mask() __attribute__ ((always_inline)) { return mPinMask; }
|
||||
|
||||
virtual void select() { hi(); }
|
||||
virtual void release() { lo(); }
|
||||
virtual bool isSelected() { return (*mPort & mPinMask) == mPinMask; }
|
||||
};
|
||||
|
||||
class OutputPin : public Pin {
|
||||
public:
|
||||
OutputPin(int pin) : Pin(pin) { setOutput(); }
|
||||
};
|
||||
|
||||
class InputPin : public Pin {
|
||||
public:
|
||||
InputPin(int pin) : Pin(pin) { setInput(); }
|
||||
};
|
||||
|
||||
#else
|
||||
// This is the empty code version of the raw pin class, method bodies should be filled in to Do The Right Thing[tm] when making this
|
||||
// available on a new platform
|
||||
class Pin : public Selectable {
|
||||
volatile RwReg *mPort;
|
||||
volatile RoReg *mInPort;
|
||||
RwReg mPinMask;
|
||||
uint8_t mPin;
|
||||
|
||||
void _init() {
|
||||
// TODO: fill in init on a new platform
|
||||
mPinMask = 0;
|
||||
mPort = NULL;
|
||||
mInPort = NULL;
|
||||
}
|
||||
public:
|
||||
Pin(int pin) : mPin(pin) { _init(); }
|
||||
|
||||
void setPin(int pin) { mPin = pin; _init(); }
|
||||
|
||||
typedef volatile RwReg * port_ptr_t;
|
||||
typedef RwReg port_t;
|
||||
|
||||
inline void setOutput() { /* TODO: Set pin output */ }
|
||||
inline void setInput() { /* TODO: Set pin input */ }
|
||||
|
||||
inline void hi() __attribute__ ((always_inline)) { *mPort |= mPinMask; }
|
||||
inline void lo() __attribute__ ((always_inline)) { *mPort &= ~mPinMask; }
|
||||
|
||||
inline void strobe() __attribute__ ((always_inline)) { toggle(); toggle(); }
|
||||
inline void toggle() __attribute__ ((always_inline)) { *mInPort = mPinMask; }
|
||||
|
||||
inline void hi(register port_ptr_t port) __attribute__ ((always_inline)) { *port |= mPinMask; }
|
||||
inline void lo(register port_ptr_t port) __attribute__ ((always_inline)) { *port &= ~mPinMask; }
|
||||
inline void set(register port_t val) __attribute__ ((always_inline)) { *mPort = val; }
|
||||
|
||||
inline void fastset(register port_ptr_t port, register port_t val) __attribute__ ((always_inline)) { *port = val; }
|
||||
|
||||
port_t hival() __attribute__ ((always_inline)) { return *mPort | mPinMask; }
|
||||
port_t loval() __attribute__ ((always_inline)) { return *mPort & ~mPinMask; }
|
||||
port_ptr_t port() __attribute__ ((always_inline)) { return mPort; }
|
||||
port_t mask() __attribute__ ((always_inline)) { return mPinMask; }
|
||||
|
||||
virtual void select() { hi(); }
|
||||
virtual void release() { lo(); }
|
||||
virtual bool isSelected() { return (*mPort & mPinMask) == mPinMask; }
|
||||
};
|
||||
|
||||
class OutputPin : public Pin {
|
||||
public:
|
||||
OutputPin(int pin) : Pin(pin) { setOutput(); }
|
||||
};
|
||||
|
||||
class InputPin : public Pin {
|
||||
public:
|
||||
InputPin(int pin) : Pin(pin) { setInput(); }
|
||||
};
|
||||
|
||||
#endif
|
||||
|
||||
/// The simplest level of Pin class. This relies on runtime functions durinig initialization to get the port/pin mask for the pin. Most
|
||||
/// of the accesses involve references to these static globals that get set up. This won't be the fastest set of pin operations, but it
|
||||
/// will provide pin level access on pretty much all arduino environments. In addition, it includes some methods to help optimize access in
|
||||
/// various ways. Namely, the versions of hi, lo, and fastset that take the port register as a passed in register variable (saving a global
|
||||
/// dereference), since these functions are aggressively inlined, that can help collapse out a lot of extraneous memory loads/dereferences.
|
||||
///
|
||||
/// In addition, if, while writing a bunch of data to a pin, you know no other pins will be getting written to, you can get/cache a value of
|
||||
/// the pin's port register and use that to do a full set to the register. This results in one being able to simply do a store to the register,
|
||||
/// vs. the load, and/or, and store that would be done normally.
|
||||
///
|
||||
/// There are platform specific instantiations of this class that provide direct i/o register access to pins for much higher speed pin twiddling.
|
||||
///
|
||||
/// Note that these classes are all static functions. So the proper usage is Pin<13>::hi(); or such. Instantiating objects is not recommended,
|
||||
/// as passing Pin objects around will likely -not- have the effect you're expecting.
|
||||
#ifdef FASTLED_FORCE_SOFTWARE_PINS
|
||||
template<uint8_t PIN> class FastPin {
|
||||
static RwReg sPinMask;
|
||||
static volatile RwReg *sPort;
|
||||
static volatile RoReg *sInPort;
|
||||
static void _init() {
|
||||
#if !defined(FASTLED_NO_PINMAP)
|
||||
sPinMask = digitalPinToBitMask(PIN);
|
||||
sPort = portOutputRegister(digitalPinToPort(PIN));
|
||||
sInPort = portInputRegister(digitalPinToPort(PIN));
|
||||
#endif
|
||||
}
|
||||
public:
|
||||
typedef volatile RwReg * port_ptr_t;
|
||||
typedef RwReg port_t;
|
||||
|
||||
inline static void setOutput() { _init(); pinMode(PIN, OUTPUT); }
|
||||
inline static void setInput() { _init(); pinMode(PIN, INPUT); }
|
||||
|
||||
inline static void hi() __attribute__ ((always_inline)) { *sPort |= sPinMask; }
|
||||
inline static void lo() __attribute__ ((always_inline)) { *sPort &= ~sPinMask; }
|
||||
|
||||
inline static void strobe() __attribute__ ((always_inline)) { toggle(); toggle(); }
|
||||
|
||||
inline static void toggle() __attribute__ ((always_inline)) { *sInPort = sPinMask; }
|
||||
|
||||
inline static void hi(register port_ptr_t port) __attribute__ ((always_inline)) { *port |= sPinMask; }
|
||||
inline static void lo(register port_ptr_t port) __attribute__ ((always_inline)) { *port &= ~sPinMask; }
|
||||
inline static void set(register port_t val) __attribute__ ((always_inline)) { *sPort = val; }
|
||||
|
||||
inline static void fastset(register port_ptr_t port, register port_t val) __attribute__ ((always_inline)) { *port = val; }
|
||||
|
||||
static port_t hival() __attribute__ ((always_inline)) { return *sPort | sPinMask; }
|
||||
static port_t loval() __attribute__ ((always_inline)) { return *sPort & ~sPinMask; }
|
||||
static port_ptr_t port() __attribute__ ((always_inline)) { return sPort; }
|
||||
static port_t mask() __attribute__ ((always_inline)) { return sPinMask; }
|
||||
};
|
||||
|
||||
template<uint8_t PIN> RwReg FastPin<PIN>::sPinMask;
|
||||
template<uint8_t PIN> volatile RwReg *FastPin<PIN>::sPort;
|
||||
template<uint8_t PIN> volatile RoReg *FastPin<PIN>::sInPort;
|
||||
|
||||
#else
|
||||
|
||||
template<uint8_t PIN> class FastPin {
|
||||
constexpr static bool validpin() { return false; }
|
||||
|
||||
static_assert(validpin(), "Invalid pin specified");
|
||||
|
||||
static void _init() {
|
||||
}
|
||||
public:
|
||||
typedef volatile RwReg * port_ptr_t;
|
||||
typedef RwReg port_t;
|
||||
|
||||
inline static void setOutput() { }
|
||||
inline static void setInput() { }
|
||||
|
||||
inline static void hi() __attribute__ ((always_inline)) { }
|
||||
inline static void lo() __attribute__ ((always_inline)) { }
|
||||
|
||||
inline static void strobe() __attribute__ ((always_inline)) { }
|
||||
|
||||
inline static void toggle() __attribute__ ((always_inline)) { }
|
||||
|
||||
inline static void hi(register port_ptr_t port) __attribute__ ((always_inline)) { }
|
||||
inline static void lo(register port_ptr_t port) __attribute__ ((always_inline)) { }
|
||||
inline static void set(register port_t val) __attribute__ ((always_inline)) { }
|
||||
|
||||
inline static void fastset(register port_ptr_t port, register port_t val) __attribute__ ((always_inline)) { }
|
||||
|
||||
static port_t hival() __attribute__ ((always_inline)) { return 0; }
|
||||
static port_t loval() __attribute__ ((always_inline)) { return 0;}
|
||||
static port_ptr_t port() __attribute__ ((always_inline)) { return NULL; }
|
||||
static port_t mask() __attribute__ ((always_inline)) { return 0; }
|
||||
};
|
||||
|
||||
#endif
|
||||
|
||||
template<uint8_t PIN> class FastPinBB : public FastPin<PIN> {};
|
||||
|
||||
typedef volatile uint32_t & reg32_t;
|
||||
typedef volatile uint32_t * ptr_reg32_t;
|
||||
|
||||
// Utility templates for tracking down information about pins and ports
|
||||
template<uint8_t port> struct __FL_PORT_INFO {
|
||||
static bool hasPort() { return 0; }
|
||||
static const char *portName() { return "--"; }
|
||||
static const void *portAddr() { return NULL; }
|
||||
};
|
||||
|
||||
// Give us our instantiations for defined ports - we're going to abuse this later for
|
||||
// auto discovery of pin/port mappings for new variants. Use _FL_DEFINE_PORT for ports that
|
||||
// are numeric in nature, e.g. GPIO0, GPIO1. Use _FL_DEFINE_PORT3 for ports that are letters.
|
||||
// The first parameter will be the letter, the second parameter will be an integer/counter of smoe kind
|
||||
// (this is because attempts to turn macro parameters into character constants break in some compilers)
|
||||
#define _FL_DEFINE_PORT(L, BASE) template<> struct __FL_PORT_INFO<L> { static bool hasPort() { return 1; } \
|
||||
static const char *portName() { return #L; } \
|
||||
typedef BASE __t_baseType; \
|
||||
static const void *portAddr() { return (void*)&__t_baseType::r(); } };
|
||||
|
||||
#define _FL_DEFINE_PORT3(L, LC, BASE) template<> struct __FL_PORT_INFO<LC> { static bool hasPort() { return 1; } \
|
||||
static const char *portName() { return #L; } \
|
||||
typedef BASE __t_baseType; \
|
||||
static const void *portAddr() { return (void*)&__t_baseType::r(); } };
|
||||
|
||||
FASTLED_NAMESPACE_END
|
||||
|
||||
#pragma GCC diagnostic pop
|
||||
|
||||
#endif // __INC_FASTPIN_H
|
||||
154
components/FastLED-idf/fastspi.h
Normal file
154
components/FastLED-idf/fastspi.h
Normal file
@ -0,0 +1,154 @@
|
||||
#ifndef __INC_FASTSPI_H
|
||||
#define __INC_FASTSPI_H
|
||||
|
||||
#include "FastLED.h"
|
||||
|
||||
#include "controller.h"
|
||||
#include "lib8tion.h"
|
||||
|
||||
#include "fastspi_bitbang.h"
|
||||
|
||||
FASTLED_NAMESPACE_BEGIN
|
||||
|
||||
#if defined(FASTLED_TEENSY3) && (F_CPU > 48000000)
|
||||
#define DATA_RATE_MHZ(X) (((48000000L / 1000000L) / X))
|
||||
#define DATA_RATE_KHZ(X) (((48000000L / 1000L) / X))
|
||||
#elif defined(FASTLED_TEENSY4) // && (ARM_HARDWARE_SPI)
|
||||
// just use clocks
|
||||
#define DATA_RATE_MHZ(X) (1000000 * (X))
|
||||
#define DATA_RATE_KHZ(X) (1000 * (X))
|
||||
#else
|
||||
#define DATA_RATE_MHZ(X) ((F_CPU / 1000000L) / X)
|
||||
#define DATA_RATE_KHZ(X) ((F_CPU / 1000L) / X)
|
||||
#endif
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// External SPI template definition with partial instantiation(s) to map to hardware SPI ports on platforms/builds where the pin
|
||||
// mappings are known at compile time.
|
||||
//
|
||||
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#if !defined(FASTLED_ALL_PINS_HARDWARE_SPI)
|
||||
template<uint8_t _DATA_PIN, uint8_t _CLOCK_PIN, uint32_t _SPI_CLOCK_DIVIDER>
|
||||
class SPIOutput : public AVRSoftwareSPIOutput<_DATA_PIN, _CLOCK_PIN, _SPI_CLOCK_DIVIDER> {};
|
||||
#endif
|
||||
|
||||
template<uint8_t _DATA_PIN, uint8_t _CLOCK_PIN, uint32_t _SPI_CLOCK_DIVIDER>
|
||||
class SoftwareSPIOutput : public AVRSoftwareSPIOutput<_DATA_PIN, _CLOCK_PIN, _SPI_CLOCK_DIVIDER> {};
|
||||
|
||||
#ifndef FASTLED_FORCE_SOFTWARE_SPI
|
||||
|
||||
#if defined(NRF51) && defined(FASTLED_ALL_PINS_HARDWARE_SPI)
|
||||
template<uint8_t _DATA_PIN, uint8_t _CLOCK_PIN, uint32_t _SPI_CLOCK_DIVIDER>
|
||||
class SPIOutput : public NRF51SPIOutput<_DATA_PIN, _CLOCK_PIN, _SPI_CLOCK_DIVIDER> {};
|
||||
#endif
|
||||
|
||||
#if defined(NRF52_SERIES) && defined(FASTLED_ALL_PINS_HARDWARE_SPI)
|
||||
template<uint8_t _DATA_PIN, uint8_t _CLOCK_PIN, uint32_t _SPI_CLOCK_DIVIDER>
|
||||
class SPIOutput : public NRF52SPIOutput<_DATA_PIN, _CLOCK_PIN, _SPI_CLOCK_DIVIDER> {};
|
||||
#endif
|
||||
|
||||
#if defined(SPI_DATA) && defined(SPI_CLOCK)
|
||||
|
||||
#if defined(FASTLED_TEENSY3) && defined(ARM_HARDWARE_SPI)
|
||||
|
||||
template<uint32_t SPI_SPEED>
|
||||
class SPIOutput<SPI_DATA, SPI_CLOCK, SPI_SPEED> : public ARMHardwareSPIOutput<SPI_DATA, SPI_CLOCK, SPI_SPEED, 0x4002C000> {};
|
||||
|
||||
#if defined(SPI2_DATA)
|
||||
|
||||
template<uint32_t SPI_SPEED>
|
||||
class SPIOutput<SPI2_DATA, SPI2_CLOCK, SPI_SPEED> : public ARMHardwareSPIOutput<SPI2_DATA, SPI2_CLOCK, SPI_SPEED, 0x4002C000> {};
|
||||
|
||||
template<uint32_t SPI_SPEED>
|
||||
class SPIOutput<SPI_DATA, SPI2_CLOCK, SPI_SPEED> : public ARMHardwareSPIOutput<SPI_DATA, SPI2_CLOCK, SPI_SPEED, 0x4002C000> {};
|
||||
|
||||
template<uint32_t SPI_SPEED>
|
||||
class SPIOutput<SPI2_DATA, SPI_CLOCK, SPI_SPEED> : public ARMHardwareSPIOutput<SPI2_DATA, SPI_CLOCK, SPI_SPEED, 0x4002C000> {};
|
||||
#endif
|
||||
|
||||
#elif defined(FASTLED_TEENSY4) && defined(ARM_HARDWARE_SPI)
|
||||
|
||||
template<uint32_t SPI_SPEED>
|
||||
class SPIOutput<SPI_DATA, SPI_CLOCK, SPI_SPEED> : public Teesy4HardwareSPIOutput<SPI_DATA, SPI_CLOCK, SPI_SPEED, SPI, 0> {};
|
||||
|
||||
template<uint32_t SPI_SPEED>
|
||||
class SPIOutput<SPI1_DATA, SPI_CLOCK, SPI_SPEED> : public Teesy4HardwareSPIOutput<SPI1_DATA, SPI1_CLOCK, SPI_SPEED, SPI1, 1> {};
|
||||
|
||||
template<uint32_t SPI_SPEED>
|
||||
class SPIOutput<SPI2_DATA, SPI2_CLOCK, SPI_SPEED> : public Teesy4HardwareSPIOutput<SPI2_DATA, SPI2_CLOCK, SPI_SPEED, SPI2, 2> {};
|
||||
|
||||
#elif defined(FASTLED_TEENSYLC) && defined(ARM_HARDWARE_SPI)
|
||||
|
||||
#define DECLARE_SPI0(__DATA,__CLOCK) template<uint32_t SPI_SPEED>\
|
||||
class SPIOutput<__DATA, __CLOCK, SPI_SPEED> : public ARMHardwareSPIOutput<__DATA, __CLOCK, SPI_SPEED, 0x40076000> {};
|
||||
#define DECLARE_SPI1(__DATA,__CLOCK) template<uint32_t SPI_SPEED>\
|
||||
class SPIOutput<__DATA, __CLOCK, SPI_SPEED> : public ARMHardwareSPIOutput<__DATA, __CLOCK, SPI_SPEED, 0x40077000> {};
|
||||
|
||||
DECLARE_SPI0(7,13);
|
||||
DECLARE_SPI0(8,13);
|
||||
DECLARE_SPI0(11,13);
|
||||
DECLARE_SPI0(12,13);
|
||||
DECLARE_SPI0(7,14);
|
||||
DECLARE_SPI0(8,14);
|
||||
DECLARE_SPI0(11,14);
|
||||
DECLARE_SPI0(12,14);
|
||||
DECLARE_SPI1(0,20);
|
||||
DECLARE_SPI1(1,20);
|
||||
DECLARE_SPI1(21,20);
|
||||
|
||||
#elif defined(__SAM3X8E__)
|
||||
|
||||
template<uint32_t SPI_SPEED>
|
||||
class SPIOutput<SPI_DATA, SPI_CLOCK, SPI_SPEED> : public SAMHardwareSPIOutput<SPI_DATA, SPI_CLOCK, SPI_SPEED> {};
|
||||
|
||||
#elif defined(AVR_HARDWARE_SPI)
|
||||
|
||||
template<uint32_t SPI_SPEED>
|
||||
class SPIOutput<SPI_DATA, SPI_CLOCK, SPI_SPEED> : public AVRHardwareSPIOutput<SPI_DATA, SPI_CLOCK, SPI_SPEED> {};
|
||||
|
||||
#if defined(SPI_UART0_DATA)
|
||||
|
||||
template<uint32_t SPI_SPEED>
|
||||
class SPIOutput<SPI_UART0_DATA, SPI_UART0_CLOCK, SPI_SPEED> : public AVRUSART0SPIOutput<SPI_UART0_DATA, SPI_UART0_CLOCK, SPI_SPEED> {};
|
||||
|
||||
#endif
|
||||
|
||||
#if defined(SPI_UART1_DATA)
|
||||
|
||||
template<uint32_t SPI_SPEED>
|
||||
class SPIOutput<SPI_UART1_DATA, SPI_UART1_CLOCK, SPI_SPEED> : public AVRUSART1SPIOutput<SPI_UART1_DATA, SPI_UART1_CLOCK, SPI_SPEED> {};
|
||||
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
||||
#else
|
||||
# if !defined(FASTLED_INTERNAL) && !defined(FASTLED_ALL_PINS_HARDWARE_SPI)
|
||||
# ifdef FASTLED_HAS_PRAGMA_MESSAGE
|
||||
# pragma message "No hardware SPI pins defined. All SPI access will default to bitbanged output"
|
||||
# else
|
||||
# warning "No hardware SPI pins defined. All SPI access will default to bitbanged output"
|
||||
# endif
|
||||
# endif
|
||||
#endif
|
||||
|
||||
// #if defined(USART_DATA) && defined(USART_CLOCK)
|
||||
// template<uint32_t SPI_SPEED>
|
||||
// class AVRSPIOutput<USART_DATA, USART_CLOCK, SPI_SPEED> : public AVRUSARTSPIOutput<USART_DATA, USART_CLOCK, SPI_SPEED> {};
|
||||
// #endif
|
||||
|
||||
#else
|
||||
# if !defined(FASTLED_INTERNAL) && !defined(FASTLED_ALL_PINS_HARDWARE_SPI)
|
||||
# ifdef FASTLED_HAS_PRAGMA_MESSAGE
|
||||
# pragma message "Forcing software SPI - no hardware SPI for you!"
|
||||
# else
|
||||
# warning "Forcing software SPI - no hardware SPI for you!"
|
||||
# endif
|
||||
# endif
|
||||
#endif
|
||||
|
||||
FASTLED_NAMESPACE_END
|
||||
|
||||
#endif
|
||||
380
components/FastLED-idf/fastspi_bitbang.h
Normal file
380
components/FastLED-idf/fastspi_bitbang.h
Normal file
@ -0,0 +1,380 @@
|
||||
#ifndef __INC_FASTSPI_BITBANG_H
|
||||
#define __INC_FASTSPI_BITBANG_H
|
||||
|
||||
#include "FastLED.h"
|
||||
|
||||
#include "fastled_delay.h"
|
||||
|
||||
FASTLED_NAMESPACE_BEGIN
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// Software SPI (aka bit-banging) support - with aggressive optimizations for when the clock and data pin are on the same port
|
||||
//
|
||||
// TODO: Replace the select pin definition with a set of pins, to allow using mux hardware for routing in the future
|
||||
//
|
||||
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
template <uint8_t DATA_PIN, uint8_t CLOCK_PIN, uint32_t SPI_SPEED>
|
||||
class AVRSoftwareSPIOutput {
|
||||
// The data types for pointers to the pin port - typedef'd here from the Pin definition because on avr these
|
||||
// are pointers to 8 bit values, while on arm they are 32 bit
|
||||
typedef typename FastPin<DATA_PIN>::port_ptr_t data_ptr_t;
|
||||
typedef typename FastPin<CLOCK_PIN>::port_ptr_t clock_ptr_t;
|
||||
|
||||
// The data type for what's at a pin's port - typedef'd here from the Pin definition because on avr the ports
|
||||
// are 8 bits wide while on arm they are 32.
|
||||
typedef typename FastPin<DATA_PIN>::port_t data_t;
|
||||
typedef typename FastPin<CLOCK_PIN>::port_t clock_t;
|
||||
Selectable *m_pSelect;
|
||||
|
||||
public:
|
||||
AVRSoftwareSPIOutput() { m_pSelect = NULL; }
|
||||
AVRSoftwareSPIOutput(Selectable *pSelect) { m_pSelect = pSelect; }
|
||||
void setSelect(Selectable *pSelect) { m_pSelect = pSelect; }
|
||||
|
||||
void init() {
|
||||
// set the pins to output and make sure the select is released (which apparently means hi? This is a bit
|
||||
// confusing to me)
|
||||
FastPin<DATA_PIN>::setOutput();
|
||||
FastPin<CLOCK_PIN>::setOutput();
|
||||
release();
|
||||
}
|
||||
|
||||
// stop the SPI output. Pretty much a NOP with software, as there's no registers to kick
|
||||
static void stop() { }
|
||||
|
||||
// wait until the SPI subsystem is ready for more data to write. A NOP when bitbanging
|
||||
static void wait() __attribute__((always_inline)) { }
|
||||
static void waitFully() __attribute__((always_inline)) { wait(); }
|
||||
|
||||
static void writeByteNoWait(uint8_t b) __attribute__((always_inline)) { writeByte(b); }
|
||||
static void writeBytePostWait(uint8_t b) __attribute__((always_inline)) { writeByte(b); wait(); }
|
||||
|
||||
static void writeWord(uint16_t w) __attribute__((always_inline)) { writeByte(w>>8); writeByte(w&0xFF); }
|
||||
|
||||
// naive writeByte implelentation, simply calls writeBit on the 8 bits in the byte.
|
||||
static void writeByte(uint8_t b) {
|
||||
writeBit<7>(b);
|
||||
writeBit<6>(b);
|
||||
writeBit<5>(b);
|
||||
writeBit<4>(b);
|
||||
writeBit<3>(b);
|
||||
writeBit<2>(b);
|
||||
writeBit<1>(b);
|
||||
writeBit<0>(b);
|
||||
}
|
||||
|
||||
private:
|
||||
// writeByte implementation with data/clock registers passed in.
|
||||
static void writeByte(uint8_t b, clock_ptr_t clockpin, data_ptr_t datapin) {
|
||||
writeBit<7>(b, clockpin, datapin);
|
||||
writeBit<6>(b, clockpin, datapin);
|
||||
writeBit<5>(b, clockpin, datapin);
|
||||
writeBit<4>(b, clockpin, datapin);
|
||||
writeBit<3>(b, clockpin, datapin);
|
||||
writeBit<2>(b, clockpin, datapin);
|
||||
writeBit<1>(b, clockpin, datapin);
|
||||
writeBit<0>(b, clockpin, datapin);
|
||||
}
|
||||
|
||||
// writeByte implementation with the data register passed in and prebaked values for data hi w/clock hi and
|
||||
// low and data lo w/clock hi and lo. This is to be used when clock and data are on the same GPIO register,
|
||||
// can get close to getting a bit out the door in 2 clock cycles!
|
||||
static void writeByte(uint8_t b, data_ptr_t datapin,
|
||||
data_t hival, data_t loval,
|
||||
clock_t hiclock, clock_t loclock) {
|
||||
writeBit<7>(b, datapin, hival, loval, hiclock, loclock);
|
||||
writeBit<6>(b, datapin, hival, loval, hiclock, loclock);
|
||||
writeBit<5>(b, datapin, hival, loval, hiclock, loclock);
|
||||
writeBit<4>(b, datapin, hival, loval, hiclock, loclock);
|
||||
writeBit<3>(b, datapin, hival, loval, hiclock, loclock);
|
||||
writeBit<2>(b, datapin, hival, loval, hiclock, loclock);
|
||||
writeBit<1>(b, datapin, hival, loval, hiclock, loclock);
|
||||
writeBit<0>(b, datapin, hival, loval, hiclock, loclock);
|
||||
}
|
||||
|
||||
// writeByte implementation with not just registers passed in, but pre-baked values for said registers for
|
||||
// data hi/lo and clock hi/lo values. Note: weird things will happen if this method is called in cases where
|
||||
// the data and clock pins are on the same port! Don't do that!
|
||||
static void writeByte(uint8_t b, clock_ptr_t clockpin, data_ptr_t datapin,
|
||||
data_t hival, data_t loval,
|
||||
clock_t hiclock, clock_t loclock) {
|
||||
writeBit<7>(b, clockpin, datapin, hival, loval, hiclock, loclock);
|
||||
writeBit<6>(b, clockpin, datapin, hival, loval, hiclock, loclock);
|
||||
writeBit<5>(b, clockpin, datapin, hival, loval, hiclock, loclock);
|
||||
writeBit<4>(b, clockpin, datapin, hival, loval, hiclock, loclock);
|
||||
writeBit<3>(b, clockpin, datapin, hival, loval, hiclock, loclock);
|
||||
writeBit<2>(b, clockpin, datapin, hival, loval, hiclock, loclock);
|
||||
writeBit<1>(b, clockpin, datapin, hival, loval, hiclock, loclock);
|
||||
writeBit<0>(b, clockpin, datapin, hival, loval, hiclock, loclock);
|
||||
}
|
||||
|
||||
public:
|
||||
|
||||
// We want to make sure that the clock pulse is held high for a nininum of 35ns.
|
||||
#if defined(FASTLED_TEENSY4)
|
||||
#define DELAY_NS (1000 / (SPI_SPEED/1000000))
|
||||
#define CLOCK_HI_DELAY do { delayNanoseconds((DELAY_NS/4)); } while(0);
|
||||
#define CLOCK_LO_DELAY do { delayNanoseconds((DELAY_NS/4)); } while(0);
|
||||
#else
|
||||
#define MIN_DELAY ((NS(35)>3) ? (NS(35) - 3) : 1)
|
||||
|
||||
#define CLOCK_HI_DELAY do { delaycycles<MIN_DELAY>(); delaycycles<((SPI_SPEED > 10) ? (((SPI_SPEED-6) / 2) - MIN_DELAY) : (SPI_SPEED))>(); } while(0);
|
||||
#define CLOCK_LO_DELAY do { delaycycles<((SPI_SPEED > 10) ? ((SPI_SPEED-6) / 2) : (SPI_SPEED))>(); } while(0);
|
||||
#endif
|
||||
|
||||
// write the BIT'th bit out via spi, setting the data pin then strobing the clcok
|
||||
template <uint8_t BIT> __attribute__((always_inline, hot)) inline static void writeBit(uint8_t b) {
|
||||
//cli();
|
||||
if(b & (1 << BIT)) {
|
||||
FastPin<DATA_PIN>::hi();
|
||||
#ifdef ESP32
|
||||
// try to ensure we never have adjacent write opcodes to the same register
|
||||
FastPin<CLOCK_PIN>::lo();
|
||||
FastPin<CLOCK_PIN>::hi(); CLOCK_HI_DELAY;
|
||||
FastPin<CLOCK_PIN>::toggle(); CLOCK_LO_DELAY;
|
||||
#else
|
||||
FastPin<CLOCK_PIN>::hi(); CLOCK_HI_DELAY;
|
||||
FastPin<CLOCK_PIN>::lo(); CLOCK_LO_DELAY;
|
||||
#endif
|
||||
} else {
|
||||
FastPin<DATA_PIN>::lo();
|
||||
FastPin<CLOCK_PIN>::hi(); CLOCK_HI_DELAY;
|
||||
#ifdef ESP32
|
||||
// try to ensure we never have adjacent write opcodes to the same register
|
||||
FastPin<CLOCK_PIN>::toggle(); CLOCK_HI_DELAY;
|
||||
#else
|
||||
FastPin<CLOCK_PIN>::lo(); CLOCK_LO_DELAY;
|
||||
#endif
|
||||
}
|
||||
//sei();
|
||||
}
|
||||
|
||||
private:
|
||||
// write the BIT'th bit out via spi, setting the data pin then strobing the clock, using the passed in pin registers to accelerate access if needed
|
||||
template <uint8_t BIT> __attribute__((always_inline)) inline static void writeBit(uint8_t b, clock_ptr_t clockpin, data_ptr_t datapin) {
|
||||
if(b & (1 << BIT)) {
|
||||
FastPin<DATA_PIN>::hi(datapin);
|
||||
FastPin<CLOCK_PIN>::hi(clockpin); CLOCK_HI_DELAY;
|
||||
FastPin<CLOCK_PIN>::lo(clockpin); CLOCK_LO_DELAY;
|
||||
} else {
|
||||
FastPin<DATA_PIN>::lo(datapin);
|
||||
FastPin<CLOCK_PIN>::hi(clockpin); CLOCK_HI_DELAY;
|
||||
FastPin<CLOCK_PIN>::lo(clockpin); CLOCK_LO_DELAY;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
// the version of write to use when clock and data are on separate pins with precomputed values for setting
|
||||
// the clock and data pins
|
||||
template <uint8_t BIT> __attribute__((always_inline)) inline static void writeBit(uint8_t b, clock_ptr_t clockpin, data_ptr_t datapin,
|
||||
data_t hival, data_t loval, clock_t hiclock, clock_t loclock) {
|
||||
// // only need to explicitly set clock hi if clock and data are on different ports
|
||||
if(b & (1 << BIT)) {
|
||||
FastPin<DATA_PIN>::fastset(datapin, hival);
|
||||
FastPin<CLOCK_PIN>::fastset(clockpin, hiclock); CLOCK_HI_DELAY;
|
||||
FastPin<CLOCK_PIN>::fastset(clockpin, loclock); CLOCK_LO_DELAY;
|
||||
} else {
|
||||
// FL_NOP;
|
||||
FastPin<DATA_PIN>::fastset(datapin, loval);
|
||||
FastPin<CLOCK_PIN>::fastset(clockpin, hiclock); CLOCK_HI_DELAY;
|
||||
FastPin<CLOCK_PIN>::fastset(clockpin, loclock); CLOCK_LO_DELAY;
|
||||
}
|
||||
}
|
||||
|
||||
// the version of write to use when clock and data are on the same port with precomputed values for the various
|
||||
// combinations
|
||||
template <uint8_t BIT> __attribute__((always_inline)) inline static void writeBit(uint8_t b, data_ptr_t clockdatapin,
|
||||
data_t datahiclockhi, data_t dataloclockhi,
|
||||
data_t datahiclocklo, data_t dataloclocklo) {
|
||||
#if 0
|
||||
writeBit<BIT>(b);
|
||||
#else
|
||||
if(b & (1 << BIT)) {
|
||||
FastPin<DATA_PIN>::fastset(clockdatapin, datahiclocklo);
|
||||
FastPin<DATA_PIN>::fastset(clockdatapin, datahiclockhi); CLOCK_HI_DELAY;
|
||||
FastPin<DATA_PIN>::fastset(clockdatapin, datahiclocklo); CLOCK_LO_DELAY;
|
||||
} else {
|
||||
// FL_NOP;
|
||||
FastPin<DATA_PIN>::fastset(clockdatapin, dataloclocklo);
|
||||
FastPin<DATA_PIN>::fastset(clockdatapin, dataloclockhi); CLOCK_HI_DELAY;
|
||||
FastPin<DATA_PIN>::fastset(clockdatapin, dataloclocklo); CLOCK_LO_DELAY;
|
||||
}
|
||||
#endif
|
||||
}
|
||||
public:
|
||||
|
||||
// select the SPI output (TODO: research whether this really means hi or lo. Alt TODO: move select responsibility out of the SPI classes
|
||||
// entirely, make it up to the caller to remember to lock/select the line?)
|
||||
void select() { if(m_pSelect != NULL) { m_pSelect->select(); } } // FastPin<SELECT_PIN>::hi(); }
|
||||
|
||||
// release the SPI line
|
||||
void release() { if(m_pSelect != NULL) { m_pSelect->release(); } } // FastPin<SELECT_PIN>::lo(); }
|
||||
|
||||
// Write out len bytes of the given value out over SPI. Useful for quickly flushing, say, a line of 0's down the line.
|
||||
void writeBytesValue(uint8_t value, int len) {
|
||||
select();
|
||||
writeBytesValueRaw(value, len);
|
||||
release();
|
||||
}
|
||||
|
||||
static void writeBytesValueRaw(uint8_t value, int len) {
|
||||
#ifdef FAST_SPI_INTERRUPTS_WRITE_PINS
|
||||
// TODO: Weird things may happen if software bitbanging SPI output and other pins on the output reigsters are being twiddled. Need
|
||||
// to allow specifying whether or not exclusive i/o access is allowed during this process, and if i/o access is not allowed fall
|
||||
// back to the degenerative code below
|
||||
while(len--) {
|
||||
writeByte(value);
|
||||
}
|
||||
#else
|
||||
register data_ptr_t datapin = FastPin<DATA_PIN>::port();
|
||||
|
||||
if(FastPin<DATA_PIN>::port() != FastPin<CLOCK_PIN>::port()) {
|
||||
// If data and clock are on different ports, then writing a bit will consist of writing the value foor
|
||||
// the bit (hi or low) to the data pin port, and then two writes to the clock port to strobe the clock line
|
||||
register clock_ptr_t clockpin = FastPin<CLOCK_PIN>::port();
|
||||
register data_t datahi = FastPin<DATA_PIN>::hival();
|
||||
register data_t datalo = FastPin<DATA_PIN>::loval();
|
||||
register clock_t clockhi = FastPin<CLOCK_PIN>::hival();
|
||||
register clock_t clocklo = FastPin<CLOCK_PIN>::loval();
|
||||
while(len--) {
|
||||
writeByte(value, clockpin, datapin, datahi, datalo, clockhi, clocklo);
|
||||
}
|
||||
|
||||
} else {
|
||||
// If data and clock are on the same port then we can combine setting the data and clock pins
|
||||
register data_t datahi_clockhi = FastPin<DATA_PIN>::hival() | FastPin<CLOCK_PIN>::mask();
|
||||
register data_t datalo_clockhi = FastPin<DATA_PIN>::loval() | FastPin<CLOCK_PIN>::mask();
|
||||
register data_t datahi_clocklo = FastPin<DATA_PIN>::hival() & ~FastPin<CLOCK_PIN>::mask();
|
||||
register data_t datalo_clocklo = FastPin<DATA_PIN>::loval() & ~FastPin<CLOCK_PIN>::mask();
|
||||
|
||||
while(len--) {
|
||||
writeByte(value, datapin, datahi_clockhi, datalo_clockhi, datahi_clocklo, datalo_clocklo);
|
||||
}
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
// write a block of len uint8_ts out. Need to type this better so that explicit casts into the call aren't required.
|
||||
// note that this template version takes a class parameter for a per-byte modifier to the data.
|
||||
template <class D> void writeBytes(register uint8_t *data, int len) {
|
||||
select();
|
||||
#ifdef FAST_SPI_INTERRUPTS_WRITE_PINS
|
||||
uint8_t *end = data + len;
|
||||
while(data != end) {
|
||||
writeByte(D::adjust(*data++));
|
||||
}
|
||||
#else
|
||||
register clock_ptr_t clockpin = FastPin<CLOCK_PIN>::port();
|
||||
register data_ptr_t datapin = FastPin<DATA_PIN>::port();
|
||||
|
||||
if(FastPin<DATA_PIN>::port() != FastPin<CLOCK_PIN>::port()) {
|
||||
// If data and clock are on different ports, then writing a bit will consist of writing the value foor
|
||||
// the bit (hi or low) to the data pin port, and then two writes to the clock port to strobe the clock line
|
||||
register data_t datahi = FastPin<DATA_PIN>::hival();
|
||||
register data_t datalo = FastPin<DATA_PIN>::loval();
|
||||
register clock_t clockhi = FastPin<CLOCK_PIN>::hival();
|
||||
register clock_t clocklo = FastPin<CLOCK_PIN>::loval();
|
||||
uint8_t *end = data + len;
|
||||
|
||||
while(data != end) {
|
||||
writeByte(D::adjust(*data++), clockpin, datapin, datahi, datalo, clockhi, clocklo);
|
||||
}
|
||||
|
||||
} else {
|
||||
// FastPin<CLOCK_PIN>::hi();
|
||||
// If data and clock are on the same port then we can combine setting the data and clock pins
|
||||
register data_t datahi_clockhi = FastPin<DATA_PIN>::hival() | FastPin<CLOCK_PIN>::mask();
|
||||
register data_t datalo_clockhi = FastPin<DATA_PIN>::loval() | FastPin<CLOCK_PIN>::mask();
|
||||
register data_t datahi_clocklo = FastPin<DATA_PIN>::hival() & ~FastPin<CLOCK_PIN>::mask();
|
||||
register data_t datalo_clocklo = FastPin<DATA_PIN>::loval() & ~FastPin<CLOCK_PIN>::mask();
|
||||
|
||||
uint8_t *end = data + len;
|
||||
|
||||
while(data != end) {
|
||||
writeByte(D::adjust(*data++), datapin, datahi_clockhi, datalo_clockhi, datahi_clocklo, datalo_clocklo);
|
||||
}
|
||||
// FastPin<CLOCK_PIN>::lo();
|
||||
}
|
||||
#endif
|
||||
D::postBlock(len);
|
||||
release();
|
||||
}
|
||||
|
||||
// default version of writing a block of data out to the SPI port, with no data modifications being made
|
||||
void writeBytes(register uint8_t *data, int len) { writeBytes<DATA_NOP>(data, len); }
|
||||
|
||||
|
||||
// write a block of uint8_ts out in groups of three. len is the total number of uint8_ts to write out. The template
|
||||
// parameters indicate how many uint8_ts to skip at the beginning of each grouping, as well as a class specifying a per
|
||||
// byte of data modification to be made. (See DATA_NOP above)
|
||||
template <uint8_t FLAGS, class D, EOrder RGB_ORDER> __attribute__((noinline)) void writePixels(PixelController<RGB_ORDER> pixels) {
|
||||
select();
|
||||
int len = pixels.mLen;
|
||||
|
||||
#ifdef FAST_SPI_INTERRUPTS_WRITE_PINS
|
||||
// If interrupts or other things may be generating output while we're working on things, then we need
|
||||
// to use this block
|
||||
while(pixels.has(1)) {
|
||||
if(FLAGS & FLAG_START_BIT) {
|
||||
writeBit<0>(1);
|
||||
}
|
||||
writeByte(D::adjust(pixels.loadAndScale0()));
|
||||
writeByte(D::adjust(pixels.loadAndScale1()));
|
||||
writeByte(D::adjust(pixels.loadAndScale2()));
|
||||
pixels.advanceData();
|
||||
pixels.stepDithering();
|
||||
}
|
||||
#else
|
||||
// If we can guaruntee that no one else will be writing data while we are running (namely, changing the values of the PORT/PDOR pins)
|
||||
// then we can use a bunch of optimizations in here
|
||||
register data_ptr_t datapin = FastPin<DATA_PIN>::port();
|
||||
|
||||
if(FastPin<DATA_PIN>::port() != FastPin<CLOCK_PIN>::port()) {
|
||||
register clock_ptr_t clockpin = FastPin<CLOCK_PIN>::port();
|
||||
// If data and clock are on different ports, then writing a bit will consist of writing the value foor
|
||||
// the bit (hi or low) to the data pin port, and then two writes to the clock port to strobe the clock line
|
||||
register data_t datahi = FastPin<DATA_PIN>::hival();
|
||||
register data_t datalo = FastPin<DATA_PIN>::loval();
|
||||
register clock_t clockhi = FastPin<CLOCK_PIN>::hival();
|
||||
register clock_t clocklo = FastPin<CLOCK_PIN>::loval();
|
||||
|
||||
while(pixels.has(1)) {
|
||||
if(FLAGS & FLAG_START_BIT) {
|
||||
writeBit<0>(1, clockpin, datapin, datahi, datalo, clockhi, clocklo);
|
||||
}
|
||||
writeByte(D::adjust(pixels.loadAndScale0()), clockpin, datapin, datahi, datalo, clockhi, clocklo);
|
||||
writeByte(D::adjust(pixels.loadAndScale1()), clockpin, datapin, datahi, datalo, clockhi, clocklo);
|
||||
writeByte(D::adjust(pixels.loadAndScale2()), clockpin, datapin, datahi, datalo, clockhi, clocklo);
|
||||
pixels.advanceData();
|
||||
pixels.stepDithering();
|
||||
}
|
||||
|
||||
} else {
|
||||
// If data and clock are on the same port then we can combine setting the data and clock pins
|
||||
register data_t datahi_clockhi = FastPin<DATA_PIN>::hival() | FastPin<CLOCK_PIN>::mask();
|
||||
register data_t datalo_clockhi = FastPin<DATA_PIN>::loval() | FastPin<CLOCK_PIN>::mask();
|
||||
register data_t datahi_clocklo = FastPin<DATA_PIN>::hival() & ~FastPin<CLOCK_PIN>::mask();
|
||||
register data_t datalo_clocklo = FastPin<DATA_PIN>::loval() & ~FastPin<CLOCK_PIN>::mask();
|
||||
|
||||
while(pixels.has(1)) {
|
||||
if(FLAGS & FLAG_START_BIT) {
|
||||
writeBit<0>(1, datapin, datahi_clockhi, datalo_clockhi, datahi_clocklo, datalo_clocklo);
|
||||
}
|
||||
writeByte(D::adjust(pixels.loadAndScale0()), datapin, datahi_clockhi, datalo_clockhi, datahi_clocklo, datalo_clocklo);
|
||||
writeByte(D::adjust(pixels.loadAndScale1()), datapin, datahi_clockhi, datalo_clockhi, datahi_clocklo, datalo_clocklo);
|
||||
writeByte(D::adjust(pixels.loadAndScale2()), datapin, datahi_clockhi, datalo_clockhi, datahi_clocklo, datalo_clocklo);
|
||||
pixels.advanceData();
|
||||
pixels.stepDithering();
|
||||
}
|
||||
}
|
||||
#endif
|
||||
D::postBlock(len);
|
||||
release();
|
||||
}
|
||||
};
|
||||
|
||||
FASTLED_NAMESPACE_END
|
||||
|
||||
#endif
|
||||
0
components/FastLED-idf/fastspi_dma.h
Normal file
0
components/FastLED-idf/fastspi_dma.h
Normal file
64
components/FastLED-idf/fastspi_nop.h
Normal file
64
components/FastLED-idf/fastspi_nop.h
Normal file
@ -0,0 +1,64 @@
|
||||
#ifndef __INC_FASTSPI_NOP_H
|
||||
#define __INC_FASTSPI_NOP_H
|
||||
|
||||
#if 0 // Guard against the arduino ide idiotically including every header file
|
||||
|
||||
#include "FastLED.h"
|
||||
|
||||
FASTLED_NAMESPACE_BEGIN
|
||||
|
||||
/// A nop/stub class, mostly to show the SPI methods that are needed/used by the various SPI chipset implementations. Should
|
||||
/// be used as a definition for the set of methods that the spi implementation classes should use (since C++ doesn't support the
|
||||
/// idea of interfaces - it's possible this could be done with virtual classes, need to decide if i want that overhead)
|
||||
template <uint8_t _DATA_PIN, uint8_t _CLOCK_PIN, uint32_t _SPI_CLOCK_DIVIDER>
|
||||
class NOPSPIOutput {
|
||||
Selectable *m_pSelect;
|
||||
|
||||
public:
|
||||
NOPSPIOutput() { m_pSelect = NULL; }
|
||||
NOPSPIOutput(Selectable *pSelect) { m_pSelect = pSelect; }
|
||||
|
||||
/// set the object representing the selectable
|
||||
void setSelect(Selectable *pSelect) { m_pSelect = pSelect; }
|
||||
|
||||
/// initialize the SPI subssytem
|
||||
void init() { /* TODO */ }
|
||||
|
||||
/// latch the CS select
|
||||
void select() { /* TODO */ }
|
||||
|
||||
/// release the CS select
|
||||
void release() { /* TODO */ }
|
||||
|
||||
/// wait until all queued up data has been written
|
||||
void waitFully();
|
||||
|
||||
/// not the most efficient mechanism in the world - but should be enough for sm16716 and friends
|
||||
template <uint8_t BIT> inline static void writeBit(uint8_t b) { /* TODO */ }
|
||||
|
||||
/// write a byte out via SPI (returns immediately on writing register)
|
||||
void writeByte(uint8_t b) { /* TODO */ }
|
||||
/// write a word out via SPI (returns immediately on writing register)
|
||||
void writeWord(uint16_t w) { /* TODO */ }
|
||||
|
||||
/// A raw set of writing byte values, assumes setup/init/waiting done elsewhere (static for use by adjustment classes)
|
||||
static void writeBytesValueRaw(uint8_t value, int len) { /* TODO */ }
|
||||
|
||||
/// A full cycle of writing a value for len bytes, including select, release, and waiting
|
||||
void writeBytesValue(uint8_t value, int len) { /* TODO */ }
|
||||
|
||||
/// A full cycle of writing a raw block of data out, including select, release, and waiting
|
||||
void writeBytes(uint8_t *data, int len) { /* TODO */ }
|
||||
|
||||
/// write a single bit out, which bit from the passed in byte is determined by template parameter
|
||||
template <uint8_t BIT> inline static void writeBit(uint8_t b) { /* TODO */ }
|
||||
|
||||
/// write out pixel data from the given PixelController object
|
||||
template <uint8_t FLAGS, class D, EOrder RGB_ORDER> void writePixels(PixelController<RGB_ORDER> pixels) { /* TODO */ }
|
||||
|
||||
};
|
||||
|
||||
FASTLED_NAMESPACE_END
|
||||
|
||||
#endif
|
||||
#endif
|
||||
95
components/FastLED-idf/fastspi_ref.h
Normal file
95
components/FastLED-idf/fastspi_ref.h
Normal file
@ -0,0 +1,95 @@
|
||||
#ifndef __INC_FASTSPI_ARM_SAM_H
|
||||
#define __INC_FASTSPI_ARM_SAM_H
|
||||
|
||||
#if 0 // guard against the arduino ide idiotically including every header file
|
||||
#include "FastLED.h"
|
||||
|
||||
FASTLED_NAMESPACE_BEGIN
|
||||
|
||||
// A skeletal implementation of hardware SPI support. Fill in the necessary code for init, waiting, and writing. The rest of
|
||||
// the method implementations should provide a starting point, even if not hte most efficient to start with
|
||||
template <uint8_t _DATA_PIN, uint8_t _CLOCK_PIN, uint32_t _SPI_CLOCK_DIVIDER>
|
||||
class REFHardwareSPIOutput {
|
||||
Selectable *m_pSelect;
|
||||
public:
|
||||
SAMHardwareSPIOutput() { m_pSelect = NULL; }
|
||||
SAMHArdwareSPIOutput(Selectable *pSelect) { m_pSelect = pSelect; }
|
||||
|
||||
// set the object representing the selectable
|
||||
void setSelect(Selectable *pSelect) { /* TODO */ }
|
||||
|
||||
// initialize the SPI subssytem
|
||||
void init() { /* TODO */ }
|
||||
|
||||
// latch the CS select
|
||||
void inline select() __attribute__((always_inline)) { if(m_pSelect != NULL) { m_pSelect->select(); } }
|
||||
|
||||
// release the CS select
|
||||
void inline release() __attribute__((always_inline)) { if(m_pSelect != NULL) { m_pSelect->release(); } }
|
||||
|
||||
// wait until all queued up data has been written
|
||||
static void waitFully() { /* TODO */ }
|
||||
|
||||
// write a byte out via SPI (returns immediately on writing register)
|
||||
static void writeByte(uint8_t b) { /* TODO */ }
|
||||
|
||||
// write a word out via SPI (returns immediately on writing register)
|
||||
static void writeWord(uint16_t w) { /* TODO */ }
|
||||
|
||||
// A raw set of writing byte values, assumes setup/init/waiting done elsewhere
|
||||
static void writeBytesValueRaw(uint8_t value, int len) {
|
||||
while(len--) { writeByte(value); }
|
||||
}
|
||||
|
||||
// A full cycle of writing a value for len bytes, including select, release, and waiting
|
||||
void writeBytesValue(uint8_t value, int len) {
|
||||
select(); writeBytesValueRaw(value, len); release();
|
||||
}
|
||||
|
||||
// A full cycle of writing a value for len bytes, including select, release, and waiting
|
||||
template <class D> void writeBytes(register uint8_t *data, int len) {
|
||||
uint8_t *end = data + len;
|
||||
select();
|
||||
// could be optimized to write 16bit words out instead of 8bit bytes
|
||||
while(data != end) {
|
||||
writeByte(D::adjust(*data++));
|
||||
}
|
||||
D::postBlock(len);
|
||||
waitFully();
|
||||
release();
|
||||
}
|
||||
|
||||
// A full cycle of writing a value for len bytes, including select, release, and waiting
|
||||
void writeBytes(register uint8_t *data, int len) { writeBytes<DATA_NOP>(data, len); }
|
||||
|
||||
// write a single bit out, which bit from the passed in byte is determined by template parameter
|
||||
template <uint8_t BIT> inline static void writeBit(uint8_t b) { /* TODO */ }
|
||||
|
||||
// write a block of uint8_ts out in groups of three. len is the total number of uint8_ts to write out. The template
|
||||
// parameters indicate how many uint8_ts to skip at the beginning and/or end of each grouping
|
||||
template <uint8_t FLAGS, class D, EOrder RGB_ORDER> void writePixels(PixelController<RGB_ORDER> pixels) {
|
||||
select();
|
||||
while(data != end) {
|
||||
if(FLAGS & FLAG_START_BIT) {
|
||||
writeBit<0>(1);
|
||||
}
|
||||
writeByte(D::adjust(pixels.loadAndScale0()));
|
||||
writeByte(D::adjust(pixels.loadAndScale1()));
|
||||
writeByte(D::adjust(pixels.loadAndScale2()));
|
||||
|
||||
pixels.advanceData();
|
||||
pixels.stepDithering();
|
||||
data += (3+skip);
|
||||
}
|
||||
D::postBlock(len);
|
||||
release();
|
||||
}
|
||||
|
||||
};
|
||||
|
||||
FASTLED_NAMESPACE_END
|
||||
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
||||
43
components/FastLED-idf/fastspi_types.h
Normal file
43
components/FastLED-idf/fastspi_types.h
Normal file
@ -0,0 +1,43 @@
|
||||
#ifndef __INC_FASTSPI_TYPES_H
|
||||
#define __INC_FASTSPI_TYPES_H
|
||||
|
||||
#include "FastLED.h"
|
||||
|
||||
FASTLED_NAMESPACE_BEGIN
|
||||
|
||||
// Some helper macros for getting at mis-ordered byte values
|
||||
#define SPI_B0 (RGB_BYTE0(RGB_ORDER) + (MASK_SKIP_BITS & SKIP))
|
||||
#define SPI_B1 (RGB_BYTE1(RGB_ORDER) + (MASK_SKIP_BITS & SKIP))
|
||||
#define SPI_B2 (RGB_BYTE2(RGB_ORDER) + (MASK_SKIP_BITS & SKIP))
|
||||
#define SPI_ADVANCE (3 + (MASK_SKIP_BITS & SKIP))
|
||||
|
||||
/// Some of the SPI controllers will need to perform a transform on each byte before doing
|
||||
/// anyting with it. Creating a class of this form and passing it in as a template parameter to
|
||||
/// writeBytes/writeBytes3 below will ensure that the body of this method will get called on every
|
||||
/// byte worked on. Recommendation, make the adjust method aggressively inlined.
|
||||
///
|
||||
/// TODO: Convinience macro for building these
|
||||
class DATA_NOP {
|
||||
public:
|
||||
static __attribute__((always_inline)) inline uint8_t adjust(register uint8_t data) { return data; }
|
||||
static __attribute__((always_inline)) inline uint8_t adjust(register uint8_t data, register uint8_t scale) { return scale8(data, scale); }
|
||||
static __attribute__((always_inline)) inline void postBlock(int /* len */) { }
|
||||
};
|
||||
|
||||
#define FLAG_START_BIT 0x80
|
||||
#define MASK_SKIP_BITS 0x3F
|
||||
|
||||
// Clock speed dividers
|
||||
#define SPEED_DIV_2 2
|
||||
#define SPEED_DIV_4 4
|
||||
#define SPEED_DIV_8 8
|
||||
#define SPEED_DIV_16 16
|
||||
#define SPEED_DIV_32 32
|
||||
#define SPEED_DIV_64 64
|
||||
#define SPEED_DIV_128 128
|
||||
|
||||
#define MAX_DATA_RATE 0
|
||||
|
||||
FASTLED_NAMESPACE_END
|
||||
|
||||
#endif
|
||||
714
components/FastLED-idf/hsv2rgb.cpp
Normal file
714
components/FastLED-idf/hsv2rgb.cpp
Normal file
@ -0,0 +1,714 @@
|
||||
#define FASTLED_INTERNAL
|
||||
#include <stdint.h>
|
||||
|
||||
#include "FastLED.h"
|
||||
|
||||
FASTLED_NAMESPACE_BEGIN
|
||||
|
||||
// Functions to convert HSV colors to RGB colors.
|
||||
//
|
||||
// The basically fall into two groups: spectra, and rainbows.
|
||||
// Spectra and rainbows are not the same thing. Wikipedia has a good
|
||||
// illustration here
|
||||
// http://upload.wikimedia.org/wikipedia/commons/f/f6/Prism_compare_rainbow_01.png
|
||||
// from this article
|
||||
// http://en.wikipedia.org/wiki/Rainbow#Number_of_colours_in_spectrum_or_rainbow
|
||||
// that shows a 'spectrum' and a 'rainbow' side by side. Among other
|
||||
// differences, you'll see that a 'rainbow' has much more yellow than
|
||||
// a plain spectrum. "Classic" LED color washes are spectrum based, and
|
||||
// usually show very little yellow.
|
||||
//
|
||||
// Wikipedia's page on HSV color space, with pseudocode for conversion
|
||||
// to RGB color space
|
||||
// http://en.wikipedia.org/wiki/HSL_and_HSV
|
||||
// Note that their conversion algorithm, which is (naturally) very popular
|
||||
// is in the "maximum brightness at any given hue" style, vs the "uniform
|
||||
// brightness for all hues" style.
|
||||
//
|
||||
// You can't have both; either purple is the same brightness as red, e.g
|
||||
// red = #FF0000 and purple = #800080 -> same "total light" output
|
||||
// OR purple is 'as bright as it can be', e.g.
|
||||
// red = #FF0000 and purple = #FF00FF -> purple is much brighter than red.
|
||||
// The colorspace conversions here try to keep the apparent brightness
|
||||
// constant even as the hue varies.
|
||||
//
|
||||
// Adafruit's "Wheel" function, discussed here
|
||||
// http://forums.adafruit.com/viewtopic.php?f=47&t=22483
|
||||
// is also of the "constant apparent brightness" variety.
|
||||
//
|
||||
// TODO: provide the 'maximum brightness no matter what' variation.
|
||||
//
|
||||
// See also some good, clear Arduino C code from Kasper Kamperman
|
||||
// http://www.kasperkamperman.com/blog/arduino/arduino-programming-hsb-to-rgb/
|
||||
// which in turn was was based on Windows C code from "nico80"
|
||||
// http://www.codeproject.com/Articles/9207/An-HSB-RGBA-colour-picker
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
void hsv2rgb_raw_C (const struct CHSV & hsv, struct CRGB & rgb);
|
||||
void hsv2rgb_raw_avr(const struct CHSV & hsv, struct CRGB & rgb);
|
||||
|
||||
#if defined(__AVR__) && !defined( LIB8_ATTINY )
|
||||
void hsv2rgb_raw(const struct CHSV & hsv, struct CRGB & rgb)
|
||||
{
|
||||
hsv2rgb_raw_avr( hsv, rgb);
|
||||
}
|
||||
#else
|
||||
void hsv2rgb_raw(const struct CHSV & hsv, struct CRGB & rgb)
|
||||
{
|
||||
hsv2rgb_raw_C( hsv, rgb);
|
||||
}
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
#define APPLY_DIMMING(X) (X)
|
||||
#define HSV_SECTION_6 (0x20)
|
||||
#define HSV_SECTION_3 (0x40)
|
||||
|
||||
void hsv2rgb_raw_C (const struct CHSV & hsv, struct CRGB & rgb)
|
||||
{
|
||||
// Convert hue, saturation and brightness ( HSV/HSB ) to RGB
|
||||
// "Dimming" is used on saturation and brightness to make
|
||||
// the output more visually linear.
|
||||
|
||||
// Apply dimming curves
|
||||
uint8_t value = APPLY_DIMMING( hsv.val);
|
||||
uint8_t saturation = hsv.sat;
|
||||
|
||||
// The brightness floor is minimum number that all of
|
||||
// R, G, and B will be set to.
|
||||
uint8_t invsat = APPLY_DIMMING( 255 - saturation);
|
||||
uint8_t brightness_floor = (value * invsat) / 256;
|
||||
|
||||
// The color amplitude is the maximum amount of R, G, and B
|
||||
// that will be added on top of the brightness_floor to
|
||||
// create the specific hue desired.
|
||||
uint8_t color_amplitude = value - brightness_floor;
|
||||
|
||||
// Figure out which section of the hue wheel we're in,
|
||||
// and how far offset we are withing that section
|
||||
uint8_t section = hsv.hue / HSV_SECTION_3; // 0..2
|
||||
uint8_t offset = hsv.hue % HSV_SECTION_3; // 0..63
|
||||
|
||||
uint8_t rampup = offset; // 0..63
|
||||
uint8_t rampdown = (HSV_SECTION_3 - 1) - offset; // 63..0
|
||||
|
||||
// We now scale rampup and rampdown to a 0-255 range -- at least
|
||||
// in theory, but here's where architecture-specific decsions
|
||||
// come in to play:
|
||||
// To scale them up to 0-255, we'd want to multiply by 4.
|
||||
// But in the very next step, we multiply the ramps by other
|
||||
// values and then divide the resulting product by 256.
|
||||
// So which is faster?
|
||||
// ((ramp * 4) * othervalue) / 256
|
||||
// or
|
||||
// ((ramp ) * othervalue) / 64
|
||||
// It depends on your processor architecture.
|
||||
// On 8-bit AVR, the "/ 256" is just a one-cycle register move,
|
||||
// but the "/ 64" might be a multicycle shift process. So on AVR
|
||||
// it's faster do multiply the ramp values by four, and then
|
||||
// divide by 256.
|
||||
// On ARM, the "/ 256" and "/ 64" are one cycle each, so it's
|
||||
// faster to NOT multiply the ramp values by four, and just to
|
||||
// divide the resulting product by 64 (instead of 256).
|
||||
// Moral of the story: trust your profiler, not your insticts.
|
||||
|
||||
// Since there's an AVR assembly version elsewhere, we'll
|
||||
// assume what we're on an architecture where any number of
|
||||
// bit shifts has roughly the same cost, and we'll remove the
|
||||
// redundant math at the source level:
|
||||
|
||||
// // scale up to 255 range
|
||||
// //rampup *= 4; // 0..252
|
||||
// //rampdown *= 4; // 0..252
|
||||
|
||||
// compute color-amplitude-scaled-down versions of rampup and rampdown
|
||||
uint8_t rampup_amp_adj = (rampup * color_amplitude) / (256 / 4);
|
||||
uint8_t rampdown_amp_adj = (rampdown * color_amplitude) / (256 / 4);
|
||||
|
||||
// add brightness_floor offset to everything
|
||||
uint8_t rampup_adj_with_floor = rampup_amp_adj + brightness_floor;
|
||||
uint8_t rampdown_adj_with_floor = rampdown_amp_adj + brightness_floor;
|
||||
|
||||
|
||||
if( section ) {
|
||||
if( section == 1) {
|
||||
// section 1: 0x40..0x7F
|
||||
rgb.r = brightness_floor;
|
||||
rgb.g = rampdown_adj_with_floor;
|
||||
rgb.b = rampup_adj_with_floor;
|
||||
} else {
|
||||
// section 2; 0x80..0xBF
|
||||
rgb.r = rampup_adj_with_floor;
|
||||
rgb.g = brightness_floor;
|
||||
rgb.b = rampdown_adj_with_floor;
|
||||
}
|
||||
} else {
|
||||
// section 0: 0x00..0x3F
|
||||
rgb.r = rampdown_adj_with_floor;
|
||||
rgb.g = rampup_adj_with_floor;
|
||||
rgb.b = brightness_floor;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
#if defined(__AVR__) && !defined( LIB8_ATTINY )
|
||||
void hsv2rgb_raw_avr(const struct CHSV & hsv, struct CRGB & rgb)
|
||||
{
|
||||
uint8_t hue, saturation, value;
|
||||
|
||||
hue = hsv.hue;
|
||||
saturation = hsv.sat;
|
||||
value = hsv.val;
|
||||
|
||||
// Saturation more useful the other way around
|
||||
saturation = 255 - saturation;
|
||||
uint8_t invsat = APPLY_DIMMING( saturation );
|
||||
|
||||
// Apply dimming curves
|
||||
value = APPLY_DIMMING( value );
|
||||
|
||||
// The brightness floor is minimum number that all of
|
||||
// R, G, and B will be set to, which is value * invsat
|
||||
uint8_t brightness_floor;
|
||||
|
||||
asm volatile(
|
||||
"mul %[value], %[invsat] \n"
|
||||
"mov %[brightness_floor], r1 \n"
|
||||
: [brightness_floor] "=r" (brightness_floor)
|
||||
: [value] "r" (value),
|
||||
[invsat] "r" (invsat)
|
||||
: "r0", "r1"
|
||||
);
|
||||
|
||||
// The color amplitude is the maximum amount of R, G, and B
|
||||
// that will be added on top of the brightness_floor to
|
||||
// create the specific hue desired.
|
||||
uint8_t color_amplitude = value - brightness_floor;
|
||||
|
||||
// Figure how far we are offset into the section of the
|
||||
// color wheel that we're in
|
||||
uint8_t offset = hsv.hue & (HSV_SECTION_3 - 1); // 0..63
|
||||
uint8_t rampup = offset * 4; // 0..252
|
||||
|
||||
|
||||
// compute color-amplitude-scaled-down versions of rampup and rampdown
|
||||
uint8_t rampup_amp_adj;
|
||||
uint8_t rampdown_amp_adj;
|
||||
|
||||
asm volatile(
|
||||
"mul %[rampup], %[color_amplitude] \n"
|
||||
"mov %[rampup_amp_adj], r1 \n"
|
||||
"com %[rampup] \n"
|
||||
"mul %[rampup], %[color_amplitude] \n"
|
||||
"mov %[rampdown_amp_adj], r1 \n"
|
||||
: [rampup_amp_adj] "=&r" (rampup_amp_adj),
|
||||
[rampdown_amp_adj] "=&r" (rampdown_amp_adj),
|
||||
[rampup] "+r" (rampup)
|
||||
: [color_amplitude] "r" (color_amplitude)
|
||||
: "r0", "r1"
|
||||
);
|
||||
|
||||
|
||||
// add brightness_floor offset to everything
|
||||
uint8_t rampup_adj_with_floor = rampup_amp_adj + brightness_floor;
|
||||
uint8_t rampdown_adj_with_floor = rampdown_amp_adj + brightness_floor;
|
||||
|
||||
|
||||
// keep gcc from using "X" as the index register for storing
|
||||
// results back in the return structure. AVR's X register can't
|
||||
// do "std X+q, rnn", but the Y and Z registers can.
|
||||
// if the pointer to 'rgb' is in X, gcc will add all kinds of crazy
|
||||
// extra instructions. Simply killing X here seems to help it
|
||||
// try Y or Z first.
|
||||
asm volatile( "" : : : "r26", "r27" );
|
||||
|
||||
|
||||
if( hue & 0x80 ) {
|
||||
// section 2: 0x80..0xBF
|
||||
rgb.r = rampup_adj_with_floor;
|
||||
rgb.g = brightness_floor;
|
||||
rgb.b = rampdown_adj_with_floor;
|
||||
} else {
|
||||
if( hue & 0x40) {
|
||||
// section 1: 0x40..0x7F
|
||||
rgb.r = brightness_floor;
|
||||
rgb.g = rampdown_adj_with_floor;
|
||||
rgb.b = rampup_adj_with_floor;
|
||||
} else {
|
||||
// section 0: 0x00..0x3F
|
||||
rgb.r = rampdown_adj_with_floor;
|
||||
rgb.g = rampup_adj_with_floor;
|
||||
rgb.b = brightness_floor;
|
||||
}
|
||||
}
|
||||
|
||||
cleanup_R1();
|
||||
}
|
||||
// End of AVR asm implementation
|
||||
|
||||
#endif
|
||||
|
||||
void hsv2rgb_spectrum( const CHSV& hsv, CRGB& rgb)
|
||||
{
|
||||
CHSV hsv2(hsv);
|
||||
hsv2.hue = scale8( hsv2.hue, 191);
|
||||
hsv2rgb_raw(hsv2, rgb);
|
||||
}
|
||||
|
||||
|
||||
// Sometimes the compiler will do clever things to reduce
|
||||
// code size that result in a net slowdown, if it thinks that
|
||||
// a variable is not used in a certain location.
|
||||
// This macro does its best to convince the compiler that
|
||||
// the variable is used in this location, to help control
|
||||
// code motion and de-duplication that would result in a slowdown.
|
||||
#define FORCE_REFERENCE(var) asm volatile( "" : : "r" (var) )
|
||||
|
||||
|
||||
#define K255 255
|
||||
#define K171 171
|
||||
#define K170 170
|
||||
#define K85 85
|
||||
|
||||
void hsv2rgb_rainbow( const CHSV& hsv, CRGB& rgb)
|
||||
{
|
||||
// Yellow has a higher inherent brightness than
|
||||
// any other color; 'pure' yellow is perceived to
|
||||
// be 93% as bright as white. In order to make
|
||||
// yellow appear the correct relative brightness,
|
||||
// it has to be rendered brighter than all other
|
||||
// colors.
|
||||
// Level Y1 is a moderate boost, the default.
|
||||
// Level Y2 is a strong boost.
|
||||
const uint8_t Y1 = 1;
|
||||
const uint8_t Y2 = 0;
|
||||
|
||||
// G2: Whether to divide all greens by two.
|
||||
// Depends GREATLY on your particular LEDs
|
||||
const uint8_t G2 = 0;
|
||||
|
||||
// Gscale: what to scale green down by.
|
||||
// Depends GREATLY on your particular LEDs
|
||||
const uint8_t Gscale = 0;
|
||||
|
||||
|
||||
uint8_t hue = hsv.hue;
|
||||
uint8_t sat = hsv.sat;
|
||||
uint8_t val = hsv.val;
|
||||
|
||||
uint8_t offset = hue & 0x1F; // 0..31
|
||||
|
||||
// offset8 = offset * 8
|
||||
uint8_t offset8 = offset;
|
||||
{
|
||||
#if defined(__AVR__)
|
||||
// Left to its own devices, gcc turns "x <<= 3" into a loop
|
||||
// It's much faster and smaller to just do three single-bit shifts
|
||||
// So this business is to force that.
|
||||
offset8 <<= 1;
|
||||
asm volatile("");
|
||||
offset8 <<= 1;
|
||||
asm volatile("");
|
||||
offset8 <<= 1;
|
||||
#else
|
||||
// On ARM and other non-AVR platforms, we just shift 3.
|
||||
offset8 <<= 3;
|
||||
#endif
|
||||
}
|
||||
|
||||
uint8_t third = scale8( offset8, (256 / 3)); // max = 85
|
||||
|
||||
uint8_t r, g, b;
|
||||
|
||||
if( ! (hue & 0x80) ) {
|
||||
// 0XX
|
||||
if( ! (hue & 0x40) ) {
|
||||
// 00X
|
||||
//section 0-1
|
||||
if( ! (hue & 0x20) ) {
|
||||
// 000
|
||||
//case 0: // R -> O
|
||||
r = K255 - third;
|
||||
g = third;
|
||||
b = 0;
|
||||
FORCE_REFERENCE(b);
|
||||
} else {
|
||||
// 001
|
||||
//case 1: // O -> Y
|
||||
if( Y1 ) {
|
||||
r = K171;
|
||||
g = K85 + third ;
|
||||
b = 0;
|
||||
FORCE_REFERENCE(b);
|
||||
}
|
||||
if( Y2 ) {
|
||||
r = K170 + third;
|
||||
//uint8_t twothirds = (third << 1);
|
||||
uint8_t twothirds = scale8( offset8, ((256 * 2) / 3)); // max=170
|
||||
g = K85 + twothirds;
|
||||
b = 0;
|
||||
FORCE_REFERENCE(b);
|
||||
}
|
||||
}
|
||||
} else {
|
||||
//01X
|
||||
// section 2-3
|
||||
if( ! (hue & 0x20) ) {
|
||||
// 010
|
||||
//case 2: // Y -> G
|
||||
if( Y1 ) {
|
||||
//uint8_t twothirds = (third << 1);
|
||||
uint8_t twothirds = scale8( offset8, ((256 * 2) / 3)); // max=170
|
||||
r = K171 - twothirds;
|
||||
g = K170 + third;
|
||||
b = 0;
|
||||
FORCE_REFERENCE(b);
|
||||
}
|
||||
if( Y2 ) {
|
||||
r = K255 - offset8;
|
||||
g = K255;
|
||||
b = 0;
|
||||
FORCE_REFERENCE(b);
|
||||
}
|
||||
} else {
|
||||
// 011
|
||||
// case 3: // G -> A
|
||||
r = 0;
|
||||
FORCE_REFERENCE(r);
|
||||
g = K255 - third;
|
||||
b = third;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
// section 4-7
|
||||
// 1XX
|
||||
if( ! (hue & 0x40) ) {
|
||||
// 10X
|
||||
if( ! ( hue & 0x20) ) {
|
||||
// 100
|
||||
//case 4: // A -> B
|
||||
r = 0;
|
||||
FORCE_REFERENCE(r);
|
||||
//uint8_t twothirds = (third << 1);
|
||||
uint8_t twothirds = scale8( offset8, ((256 * 2) / 3)); // max=170
|
||||
g = K171 - twothirds; //K170?
|
||||
b = K85 + twothirds;
|
||||
|
||||
} else {
|
||||
// 101
|
||||
//case 5: // B -> P
|
||||
r = third;
|
||||
g = 0;
|
||||
FORCE_REFERENCE(g);
|
||||
b = K255 - third;
|
||||
|
||||
}
|
||||
} else {
|
||||
if( ! (hue & 0x20) ) {
|
||||
// 110
|
||||
//case 6: // P -- K
|
||||
r = K85 + third;
|
||||
g = 0;
|
||||
FORCE_REFERENCE(g);
|
||||
b = K171 - third;
|
||||
|
||||
} else {
|
||||
// 111
|
||||
//case 7: // K -> R
|
||||
r = K170 + third;
|
||||
g = 0;
|
||||
FORCE_REFERENCE(g);
|
||||
b = K85 - third;
|
||||
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// This is one of the good places to scale the green down,
|
||||
// although the client can scale green down as well.
|
||||
if( G2 ) g = g >> 1;
|
||||
if( Gscale ) g = scale8_video_LEAVING_R1_DIRTY( g, Gscale);
|
||||
|
||||
// Scale down colors if we're desaturated at all
|
||||
// and add the brightness_floor to r, g, and b.
|
||||
if( sat != 255 ) {
|
||||
if( sat == 0) {
|
||||
r = 255; b = 255; g = 255;
|
||||
} else {
|
||||
//nscale8x3_video( r, g, b, sat);
|
||||
#if (FASTLED_SCALE8_FIXED==1)
|
||||
if( r ) r = scale8_LEAVING_R1_DIRTY( r, sat);
|
||||
if( g ) g = scale8_LEAVING_R1_DIRTY( g, sat);
|
||||
if( b ) b = scale8_LEAVING_R1_DIRTY( b, sat);
|
||||
#else
|
||||
if( r ) r = scale8_LEAVING_R1_DIRTY( r, sat) + 1;
|
||||
if( g ) g = scale8_LEAVING_R1_DIRTY( g, sat) + 1;
|
||||
if( b ) b = scale8_LEAVING_R1_DIRTY( b, sat) + 1;
|
||||
#endif
|
||||
cleanup_R1();
|
||||
|
||||
uint8_t desat = 255 - sat;
|
||||
desat = scale8( desat, desat);
|
||||
|
||||
uint8_t brightness_floor = desat;
|
||||
r += brightness_floor;
|
||||
g += brightness_floor;
|
||||
b += brightness_floor;
|
||||
}
|
||||
}
|
||||
|
||||
// Now scale everything down if we're at value < 255.
|
||||
if( val != 255 ) {
|
||||
|
||||
val = scale8_video_LEAVING_R1_DIRTY( val, val);
|
||||
if( val == 0 ) {
|
||||
r=0; g=0; b=0;
|
||||
} else {
|
||||
// nscale8x3_video( r, g, b, val);
|
||||
#if (FASTLED_SCALE8_FIXED==1)
|
||||
if( r ) r = scale8_LEAVING_R1_DIRTY( r, val);
|
||||
if( g ) g = scale8_LEAVING_R1_DIRTY( g, val);
|
||||
if( b ) b = scale8_LEAVING_R1_DIRTY( b, val);
|
||||
#else
|
||||
if( r ) r = scale8_LEAVING_R1_DIRTY( r, val) + 1;
|
||||
if( g ) g = scale8_LEAVING_R1_DIRTY( g, val) + 1;
|
||||
if( b ) b = scale8_LEAVING_R1_DIRTY( b, val) + 1;
|
||||
#endif
|
||||
cleanup_R1();
|
||||
}
|
||||
}
|
||||
|
||||
// Here we have the old AVR "missing std X+n" problem again
|
||||
// It turns out that fixing it winds up costing more than
|
||||
// not fixing it.
|
||||
// To paraphrase Dr Bronner, profile! profile! profile!
|
||||
//asm volatile( "" : : : "r26", "r27" );
|
||||
//asm volatile (" movw r30, r26 \n" : : : "r30", "r31");
|
||||
rgb.r = r;
|
||||
rgb.g = g;
|
||||
rgb.b = b;
|
||||
}
|
||||
|
||||
|
||||
void hsv2rgb_raw(const struct CHSV * phsv, struct CRGB * prgb, int numLeds) {
|
||||
for(int i = 0; i < numLeds; i++) {
|
||||
hsv2rgb_raw(phsv[i], prgb[i]);
|
||||
}
|
||||
}
|
||||
|
||||
void hsv2rgb_rainbow( const struct CHSV* phsv, struct CRGB * prgb, int numLeds) {
|
||||
for(int i = 0; i < numLeds; i++) {
|
||||
hsv2rgb_rainbow(phsv[i], prgb[i]);
|
||||
}
|
||||
}
|
||||
|
||||
void hsv2rgb_spectrum( const struct CHSV* phsv, struct CRGB * prgb, int numLeds) {
|
||||
for(int i = 0; i < numLeds; i++) {
|
||||
hsv2rgb_spectrum(phsv[i], prgb[i]);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
#define FIXFRAC8(N,D) (((N)*256)/(D))
|
||||
|
||||
// This function is only an approximation, and it is not
|
||||
// nearly as fast as the normal HSV-to-RGB conversion.
|
||||
// See extended notes in the .h file.
|
||||
CHSV rgb2hsv_approximate( const CRGB& rgb)
|
||||
{
|
||||
uint8_t r = rgb.r;
|
||||
uint8_t g = rgb.g;
|
||||
uint8_t b = rgb.b;
|
||||
uint8_t h, s, v;
|
||||
|
||||
// find desaturation
|
||||
uint8_t desat = 255;
|
||||
if( r < desat) desat = r;
|
||||
if( g < desat) desat = g;
|
||||
if( b < desat) desat = b;
|
||||
|
||||
// remove saturation from all channels
|
||||
r -= desat;
|
||||
g -= desat;
|
||||
b -= desat;
|
||||
|
||||
//Serial.print("desat="); Serial.print(desat); Serial.println("");
|
||||
|
||||
//uint8_t orig_desat = sqrt16( desat * 256);
|
||||
//Serial.print("orig_desat="); Serial.print(orig_desat); Serial.println("");
|
||||
|
||||
// saturation is opposite of desaturation
|
||||
s = 255 - desat;
|
||||
//Serial.print("s.1="); Serial.print(s); Serial.println("");
|
||||
|
||||
if( s != 255 ) {
|
||||
// undo 'dimming' of saturation
|
||||
s = 255 - sqrt16( (255-s) * 256);
|
||||
}
|
||||
// without lib8tion: float ... ew ... sqrt... double ew, or rather, ew ^ 0.5
|
||||
// if( s != 255 ) s = (255 - (256.0 * sqrt( (float)(255-s) / 256.0)));
|
||||
//Serial.print("s.2="); Serial.print(s); Serial.println("");
|
||||
|
||||
|
||||
// at least one channel is now zero
|
||||
// if all three channels are zero, we had a
|
||||
// shade of gray.
|
||||
if( (r + g + b) == 0) {
|
||||
// we pick hue zero for no special reason
|
||||
return CHSV( 0, 0, 255 - s);
|
||||
}
|
||||
|
||||
// scale all channels up to compensate for desaturation
|
||||
if( s < 255) {
|
||||
if( s == 0) s = 1;
|
||||
uint32_t scaleup = 65535 / (s);
|
||||
r = ((uint32_t)(r) * scaleup) / 256;
|
||||
g = ((uint32_t)(g) * scaleup) / 256;
|
||||
b = ((uint32_t)(b) * scaleup) / 256;
|
||||
}
|
||||
//Serial.print("r.2="); Serial.print(r); Serial.println("");
|
||||
//Serial.print("g.2="); Serial.print(g); Serial.println("");
|
||||
//Serial.print("b.2="); Serial.print(b); Serial.println("");
|
||||
|
||||
uint16_t total = r + g + b;
|
||||
|
||||
//Serial.print("total="); Serial.print(total); Serial.println("");
|
||||
|
||||
// scale all channels up to compensate for low values
|
||||
if( total < 255) {
|
||||
if( total == 0) total = 1;
|
||||
uint32_t scaleup = 65535 / (total);
|
||||
r = ((uint32_t)(r) * scaleup) / 256;
|
||||
g = ((uint32_t)(g) * scaleup) / 256;
|
||||
b = ((uint32_t)(b) * scaleup) / 256;
|
||||
}
|
||||
//Serial.print("r.3="); Serial.print(r); Serial.println("");
|
||||
//Serial.print("g.3="); Serial.print(g); Serial.println("");
|
||||
//Serial.print("b.3="); Serial.print(b); Serial.println("");
|
||||
|
||||
if( total > 255 ) {
|
||||
v = 255;
|
||||
} else {
|
||||
v = qadd8(desat,total);
|
||||
// undo 'dimming' of brightness
|
||||
if( v != 255) v = sqrt16( v * 256);
|
||||
// without lib8tion: float ... ew ... sqrt... double ew, or rather, ew ^ 0.5
|
||||
// if( v != 255) v = (256.0 * sqrt( (float)(v) / 256.0));
|
||||
|
||||
}
|
||||
|
||||
//Serial.print("v="); Serial.print(v); Serial.println("");
|
||||
|
||||
|
||||
#if 0
|
||||
|
||||
//#else
|
||||
if( v != 255) {
|
||||
// this part could probably use refinement/rethinking,
|
||||
// (but it doesn't overflow & wrap anymore)
|
||||
uint16_t s16;
|
||||
s16 = (s * 256);
|
||||
s16 /= v;
|
||||
//Serial.print("s16="); Serial.print(s16); Serial.println("");
|
||||
if( s16 < 256) {
|
||||
s = s16;
|
||||
} else {
|
||||
s = 255; // clamp to prevent overflow
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
//Serial.print("s.3="); Serial.print(s); Serial.println("");
|
||||
|
||||
|
||||
// since this wasn't a pure shade of gray,
|
||||
// the interesting question is what hue is it
|
||||
|
||||
|
||||
|
||||
// start with which channel is highest
|
||||
// (ties don't matter)
|
||||
uint8_t highest = r;
|
||||
if( g > highest) highest = g;
|
||||
if( b > highest) highest = b;
|
||||
|
||||
if( highest == r ) {
|
||||
// Red is highest.
|
||||
// Hue could be Purple/Pink-Red,Red-Orange,Orange-Yellow
|
||||
if( g == 0 ) {
|
||||
// if green is zero, we're in Purple/Pink-Red
|
||||
h = (HUE_PURPLE + HUE_PINK) / 2;
|
||||
h += scale8( qsub8(r, 128), FIXFRAC8(48,128));
|
||||
} else if ( (r - g) > g) {
|
||||
// if R-G > G then we're in Red-Orange
|
||||
h = HUE_RED;
|
||||
h += scale8( g, FIXFRAC8(32,85));
|
||||
} else {
|
||||
// R-G < G, we're in Orange-Yellow
|
||||
h = HUE_ORANGE;
|
||||
h += scale8( qsub8((g - 85) + (171 - r), 4), FIXFRAC8(32,85)); //221
|
||||
}
|
||||
|
||||
} else if ( highest == g) {
|
||||
// Green is highest
|
||||
// Hue could be Yellow-Green, Green-Aqua
|
||||
if( b == 0) {
|
||||
// if Blue is zero, we're in Yellow-Green
|
||||
// G = 171..255
|
||||
// R = 171.. 0
|
||||
h = HUE_YELLOW;
|
||||
uint8_t radj = scale8( qsub8(171,r), 47); //171..0 -> 0..171 -> 0..31
|
||||
uint8_t gadj = scale8( qsub8(g,171), 96); //171..255 -> 0..84 -> 0..31;
|
||||
uint8_t rgadj = radj + gadj;
|
||||
uint8_t hueadv = rgadj / 2;
|
||||
h += hueadv;
|
||||
//h += scale8( qadd8( 4, qadd8((g - 128), (128 - r))),
|
||||
// FIXFRAC8(32,255)); //
|
||||
} else {
|
||||
// if Blue is nonzero we're in Green-Aqua
|
||||
if( (g-b) > b) {
|
||||
h = HUE_GREEN;
|
||||
h += scale8( b, FIXFRAC8(32,85));
|
||||
} else {
|
||||
h = HUE_AQUA;
|
||||
h += scale8( qsub8(b, 85), FIXFRAC8(8,42));
|
||||
}
|
||||
}
|
||||
|
||||
} else /* highest == b */ {
|
||||
// Blue is highest
|
||||
// Hue could be Aqua/Blue-Blue, Blue-Purple, Purple-Pink
|
||||
if( r == 0) {
|
||||
// if red is zero, we're in Aqua/Blue-Blue
|
||||
h = HUE_AQUA + ((HUE_BLUE - HUE_AQUA) / 4);
|
||||
h += scale8( qsub8(b, 128), FIXFRAC8(24,128));
|
||||
} else if ( (b-r) > r) {
|
||||
// B-R > R, we're in Blue-Purple
|
||||
h = HUE_BLUE;
|
||||
h += scale8( r, FIXFRAC8(32,85));
|
||||
} else {
|
||||
// B-R < R, we're in Purple-Pink
|
||||
h = HUE_PURPLE;
|
||||
h += scale8( qsub8(r, 85), FIXFRAC8(32,85));
|
||||
}
|
||||
}
|
||||
|
||||
h += 1;
|
||||
return CHSV( h, s, v);
|
||||
}
|
||||
|
||||
// Examples that need work:
|
||||
// 0,192,192
|
||||
// 192,64,64
|
||||
// 224,32,32
|
||||
// 252,0,126
|
||||
// 252,252,0
|
||||
// 252,252,126
|
||||
|
||||
FASTLED_NAMESPACE_END
|
||||
91
components/FastLED-idf/hsv2rgb.h
Normal file
91
components/FastLED-idf/hsv2rgb.h
Normal file
@ -0,0 +1,91 @@
|
||||
#ifndef __INC_HSV2RGB_H
|
||||
#define __INC_HSV2RGB_H
|
||||
|
||||
#include "FastLED.h"
|
||||
|
||||
#include "pixeltypes.h"
|
||||
|
||||
FASTLED_NAMESPACE_BEGIN
|
||||
|
||||
// hsv2rgb_rainbow - convert a hue, saturation, and value to RGB
|
||||
// using a visually balanced rainbow (vs a straight
|
||||
// mathematical spectrum).
|
||||
// This 'rainbow' yields better yellow and orange
|
||||
// than a straight 'spectrum'.
|
||||
//
|
||||
// NOTE: here hue is 0-255, not just 0-191
|
||||
|
||||
void hsv2rgb_rainbow( const struct CHSV& hsv, struct CRGB& rgb);
|
||||
void hsv2rgb_rainbow( const struct CHSV* phsv, struct CRGB * prgb, int numLeds);
|
||||
#define HUE_MAX_RAINBOW 255
|
||||
|
||||
|
||||
// hsv2rgb_spectrum - convert a hue, saturation, and value to RGB
|
||||
// using a mathematically straight spectrum (vs
|
||||
// a visually balanced rainbow).
|
||||
// This 'spectrum' will have more green & blue
|
||||
// than a 'rainbow', and less yellow and orange.
|
||||
//
|
||||
// NOTE: here hue is 0-255, not just 0-191
|
||||
|
||||
void hsv2rgb_spectrum( const struct CHSV& hsv, struct CRGB& rgb);
|
||||
void hsv2rgb_spectrum( const struct CHSV* phsv, struct CRGB * prgb, int numLeds);
|
||||
#define HUE_MAX_SPECTRUM 255
|
||||
|
||||
|
||||
// hsv2rgb_raw - convert hue, saturation, and value to RGB.
|
||||
// This 'spectrum' conversion will be more green & blue
|
||||
// than a real 'rainbow', and the hue is specified just
|
||||
// in the range 0-191. Together, these result in a
|
||||
// slightly faster conversion speed, at the expense of
|
||||
// color balance.
|
||||
//
|
||||
// NOTE: Hue is 0-191 only!
|
||||
// Saturation & value are 0-255 each.
|
||||
//
|
||||
|
||||
void hsv2rgb_raw(const struct CHSV& hsv, struct CRGB & rgb);
|
||||
void hsv2rgb_raw(const struct CHSV* phsv, struct CRGB * prgb, int numLeds);
|
||||
#define HUE_MAX 191
|
||||
|
||||
|
||||
// rgb2hsv_approximate - recover _approximate_ HSV values from RGB.
|
||||
//
|
||||
// NOTE 1: This function is a long-term work in process; expect
|
||||
// results to change slightly over time as this function is
|
||||
// refined and improved.
|
||||
//
|
||||
// NOTE 2: This function is most accurate when the input is an
|
||||
// RGB color that came from a fully-saturated HSV color to start
|
||||
// with. E.g. CHSV( hue, 255, 255) -> CRGB -> CHSV will give
|
||||
// best results.
|
||||
//
|
||||
// NOTE 3: This function is not nearly as fast as HSV-to-RGB.
|
||||
// It is provided for those situations when the need for this
|
||||
// function cannot be avoided, or when extremely high performance
|
||||
// is not needed.
|
||||
//
|
||||
// NOTE 4: Why is this 'only' an "approximation"?
|
||||
// Not all RGB colors have HSV equivalents! For example, there
|
||||
// is no HSV value that will ever convert to RGB(255,255,0) using
|
||||
// the code provided in this library. So if you try to
|
||||
// convert RGB(255,255,0) 'back' to HSV, you'll necessarily get
|
||||
// only an approximation. Emphasis has been placed on getting
|
||||
// the 'hue' as close as usefully possible, but even that's a bit
|
||||
// of a challenge. The 8-bit HSV and 8-bit RGB color spaces
|
||||
// are not a "bijection".
|
||||
//
|
||||
// Nevertheless, this function does a pretty good job, particularly
|
||||
// at recovering the 'hue' from fully saturated RGB colors that
|
||||
// originally came from HSV rainbow colors. So if you start
|
||||
// with CHSV(hue_in,255,255), and convert that to RGB, and then
|
||||
// convert it back to HSV using this function, the resulting output
|
||||
// hue will either exactly the same, or very close (+/-1).
|
||||
// The more desaturated the original RGB color is, the rougher the
|
||||
// approximation, and the less accurate the results.
|
||||
//
|
||||
CHSV rgb2hsv_approximate( const CRGB& rgb);
|
||||
|
||||
FASTLED_NAMESPACE_END
|
||||
|
||||
#endif
|
||||
395
components/FastLED-idf/keywords.txt
Normal file
395
components/FastLED-idf/keywords.txt
Normal file
@ -0,0 +1,395 @@
|
||||
#######################################
|
||||
# Syntax Coloring Map For FastLED
|
||||
#######################################
|
||||
|
||||
#######################################
|
||||
# Datatypes (KEYWORD1)
|
||||
#######################################
|
||||
|
||||
CFastLED KEYWORD1
|
||||
CHSV KEYWORD1
|
||||
CRGB KEYWORD1
|
||||
CRGBArray KEYWORD1
|
||||
LEDS KEYWORD1
|
||||
FastLED KEYWORD1
|
||||
FastPin KEYWORD1
|
||||
FastSPI KEYWORD1
|
||||
FastSPI_LED2 KEYWORD1
|
||||
|
||||
CRGBPalette16 KEYWORD1
|
||||
CRGBPalette256 KEYWORD1
|
||||
CHSVPalette16 KEYWORD1
|
||||
CHSVPalette256 KEYWORD1
|
||||
CHSVPalette16 KEYWORD1
|
||||
CHSVPalette256 KEYWORD1
|
||||
CRGBPalette16 KEYWORD1
|
||||
CRGBPalette256 KEYWORD1
|
||||
|
||||
#######################################
|
||||
# Methods and Functions (KEYWORD2)
|
||||
#######################################
|
||||
|
||||
# FastLED methods
|
||||
addLeds KEYWORD2
|
||||
setBrightness KEYWORD2
|
||||
getBrightness KEYWORD2
|
||||
show KEYWORD2
|
||||
clear KEYWORD2
|
||||
clearData KEYWORD2
|
||||
showColor KEYWORD2
|
||||
setTemperature KEYWORD2
|
||||
setCorrection KEYWORD2
|
||||
setDither KEYWORD2
|
||||
setMaxPowerInMilliWatts KEYWORD2
|
||||
setMaxPowerInVoltsAndMilliamps KEYWORD2
|
||||
setMaxRefreshRate KEYWORD2
|
||||
countFPS KEYWORD2
|
||||
getFPS KEYWORD2
|
||||
|
||||
# Noise methods
|
||||
inoise16_raw KEYWORD2
|
||||
inoise8_raw KEYWORD2
|
||||
inoise16 KEYWORD2
|
||||
inoise8 KEYWORD2
|
||||
fill_2dnoise16 KEYWORD2
|
||||
fill_2dnoise8 KEYWORD2
|
||||
fill_noise16 KEYWORD2
|
||||
fill_noise8 KEYWORD2
|
||||
fill_raw_2dnoise16 KEYWORD2
|
||||
fill_raw_2dnoise16into8 KEYWORD2
|
||||
fill_raw_2dnoise8 KEYWORD2
|
||||
fill_raw_noise16into8 KEYWORD2
|
||||
fill_raw_noise8 KEYWORD2
|
||||
|
||||
# Lib8tion methods
|
||||
qadd8 KEYWORD2
|
||||
qadd7 KEYWORD2
|
||||
qsub8 KEYWORD2
|
||||
add8 KEYWORD2
|
||||
sub8 KEYWORD2
|
||||
scale8 KEYWORD2
|
||||
scale8_video KEYWORD2
|
||||
cleanup_R1 KEYWORD2
|
||||
nscale8x3 KEYWORD2
|
||||
nscale8x3_video KEYWORD2
|
||||
nscale8x2 KEYWORD2
|
||||
nscale8x2_video KEYWORD2
|
||||
scale16by8 KEYWORD2
|
||||
scale16by8 KEYWORD2
|
||||
scale16 KEYWORD2
|
||||
mul8 KEYWORD2
|
||||
qmul8 KEYWORD2
|
||||
abs8 KEYWORD2
|
||||
dim8_raw KEYWORD2
|
||||
dim8_video KEYWORD2
|
||||
dim8_lin KEYWORD2
|
||||
brighten8_raw KEYWORD2
|
||||
brighten8_video KEYWORD2
|
||||
brighten8_lin KEYWORD2
|
||||
random8 KEYWORD2
|
||||
random16 KEYWORD2
|
||||
random8 KEYWORD2
|
||||
random8 KEYWORD2
|
||||
random16 KEYWORD2
|
||||
random16 KEYWORD2
|
||||
random16_set_seed KEYWORD2
|
||||
random16_get_seed KEYWORD2
|
||||
random16_add_entropy KEYWORD2
|
||||
sin16_avr KEYWORD2
|
||||
sin16 KEYWORD2
|
||||
cos16 KEYWORD2
|
||||
sin8 KEYWORD2
|
||||
cos8 KEYWORD2
|
||||
lerp8by8 KEYWORD2
|
||||
lerp16by16 KEYWORD2
|
||||
lerp16by8 KEYWORD2
|
||||
lerp15by8 KEYWORD2
|
||||
lerp15by16 KEYWORD2
|
||||
map8 KEYWORD2
|
||||
ease8InOutQuad KEYWORD2
|
||||
ease8InOutCubic KEYWORD2
|
||||
ease8InOutApprox KEYWORD2
|
||||
ease8InOutApprox KEYWORD2
|
||||
triwave8 KEYWORD2
|
||||
quadwave8 KEYWORD2
|
||||
cubicwave8 KEYWORD2
|
||||
sqrt16 KEYWORD2
|
||||
blend8 KEYWORD2
|
||||
|
||||
# Color util methods
|
||||
blend KEYWORD2
|
||||
nblend KEYWORD2
|
||||
ColorFromPalette KEYWORD2
|
||||
HeatColor KEYWORD2
|
||||
UpscalePalette KEYWORD2
|
||||
blend KEYWORD2
|
||||
fadeLightBy KEYWORD2
|
||||
fadeToBlackBy KEYWORD2
|
||||
fade_raw KEYWORD2
|
||||
fade_video KEYWORD2
|
||||
fill_gradient KEYWORD2
|
||||
fill_gradient_RGB KEYWORD2
|
||||
fill_palette KEYWORD2
|
||||
fill_rainbow KEYWORD2
|
||||
fill_solid KEYWORD2
|
||||
map_data_into_colors_through_palette KEYWORD2
|
||||
nblend KEYWORD2
|
||||
nscale8 KEYWORD2
|
||||
nscale8_video KEYWORD2
|
||||
|
||||
# HSV methods
|
||||
hsv2grb_rainbow KEYWORD2
|
||||
hsv2rgb_spectrum KEYWORD2
|
||||
hsv2rgb_raw KEYWORD2
|
||||
fill_solid KEYWORD2
|
||||
fill_rainbow KEYWORD2
|
||||
|
||||
# Colors
|
||||
CRGB::AliceBlue KEYWORD2
|
||||
CRGB::Amethyst KEYWORD2
|
||||
CRGB::AntiqueWhite KEYWORD2
|
||||
CRGB::Aqua KEYWORD2
|
||||
CRGB::Aquamarine KEYWORD2
|
||||
CRGB::Azure KEYWORD2
|
||||
CRGB::Beige KEYWORD2
|
||||
CRGB::Bisque KEYWORD2
|
||||
CRGB::Black KEYWORD2
|
||||
CRGB::BlanchedAlmond KEYWORD2
|
||||
CRGB::Blue KEYWORD2
|
||||
CRGB::BlueViolet KEYWORD2
|
||||
CRGB::Brown KEYWORD2
|
||||
CRGB::BurlyWood KEYWORD2
|
||||
CRGB::CadetBlue KEYWORD2
|
||||
CRGB::Chartreuse KEYWORD2
|
||||
CRGB::Chocolate KEYWORD2
|
||||
CRGB::Coral KEYWORD2
|
||||
CRGB::CornflowerBlue KEYWORD2
|
||||
CRGB::Cornsilk KEYWORD2
|
||||
CRGB::Crimson KEYWORD2
|
||||
CRGB::Cyan KEYWORD2
|
||||
CRGB::DarkBlue KEYWORD2
|
||||
CRGB::DarkCyan KEYWORD2
|
||||
CRGB::DarkGoldenrod KEYWORD2
|
||||
CRGB::DarkGray KEYWORD2
|
||||
CRGB::DarkGreen KEYWORD2
|
||||
CRGB::DarkKhaki KEYWORD2
|
||||
CRGB::DarkMagenta KEYWORD2
|
||||
CRGB::DarkOliveGreen KEYWORD2
|
||||
CRGB::DarkOrange KEYWORD2
|
||||
CRGB::DarkOrchid KEYWORD2
|
||||
CRGB::DarkRed KEYWORD2
|
||||
CRGB::DarkSalmon KEYWORD2
|
||||
CRGB::DarkSeaGreen KEYWORD2
|
||||
CRGB::DarkSlateBlue KEYWORD2
|
||||
CRGB::DarkSlateGray KEYWORD2
|
||||
CRGB::DarkTurquoise KEYWORD2
|
||||
CRGB::DarkViolet KEYWORD2
|
||||
CRGB::DeepPink KEYWORD2
|
||||
CRGB::DeepSkyBlue KEYWORD2
|
||||
CRGB::DimGray KEYWORD2
|
||||
CRGB::DodgerBlue KEYWORD2
|
||||
CRGB::FireBrick KEYWORD2
|
||||
CRGB::FloralWhite KEYWORD2
|
||||
CRGB::ForestGreen KEYWORD2
|
||||
CRGB::Fuchsia KEYWORD2
|
||||
CRGB::Gainsboro KEYWORD2
|
||||
CRGB::GhostWhite KEYWORD2
|
||||
CRGB::Gold KEYWORD2
|
||||
CRGB::Goldenrod KEYWORD2
|
||||
CRGB::Gray KEYWORD2
|
||||
CRGB::Green KEYWORD2
|
||||
CRGB::GreenYellow KEYWORD2
|
||||
CRGB::Honeydew KEYWORD2
|
||||
CRGB::HotPink KEYWORD2
|
||||
CRGB::IndianRed KEYWORD2
|
||||
CRGB::Indigo KEYWORD2
|
||||
CRGB::Ivory KEYWORD2
|
||||
CRGB::Khaki KEYWORD2
|
||||
CRGB::Lavender KEYWORD2
|
||||
CRGB::LavenderBlush KEYWORD2
|
||||
CRGB::LawnGreen KEYWORD2
|
||||
CRGB::LemonChiffon KEYWORD2
|
||||
CRGB::LightBlue KEYWORD2
|
||||
CRGB::LightCoral KEYWORD2
|
||||
CRGB::LightCyan KEYWORD2
|
||||
CRGB::LightGoldenrodYellow KEYWORD2
|
||||
CRGB::LightGreen KEYWORD2
|
||||
CRGB::LightGrey KEYWORD2
|
||||
CRGB::LightPink KEYWORD2
|
||||
CRGB::LightSalmon KEYWORD2
|
||||
CRGB::LightSeaGreen KEYWORD2
|
||||
CRGB::LightSkyBlue KEYWORD2
|
||||
CRGB::LightSlateGray KEYWORD2
|
||||
CRGB::LightSteelBlue KEYWORD2
|
||||
CRGB::LightYellow KEYWORD2
|
||||
CRGB::Lime KEYWORD2
|
||||
CRGB::LimeGreen KEYWORD2
|
||||
CRGB::Linen KEYWORD2
|
||||
CRGB::Magenta KEYWORD2
|
||||
CRGB::Maroon KEYWORD2
|
||||
CRGB::MediumAquamarine KEYWORD2
|
||||
CRGB::MediumBlue KEYWORD2
|
||||
CRGB::MediumOrchid KEYWORD2
|
||||
CRGB::MediumPurple KEYWORD2
|
||||
CRGB::MediumSeaGreen KEYWORD2
|
||||
CRGB::MediumSlateBlue KEYWORD2
|
||||
CRGB::MediumSpringGreen KEYWORD2
|
||||
CRGB::MediumTurquoise KEYWORD2
|
||||
CRGB::MediumVioletRed KEYWORD2
|
||||
CRGB::MidnightBlue KEYWORD2
|
||||
CRGB::MintCream KEYWORD2
|
||||
CRGB::MistyRose KEYWORD2
|
||||
CRGB::Moccasin KEYWORD2
|
||||
CRGB::NavajoWhite KEYWORD2
|
||||
CRGB::Navy KEYWORD2
|
||||
CRGB::OldLace KEYWORD2
|
||||
CRGB::Olive KEYWORD2
|
||||
CRGB::OliveDrab KEYWORD2
|
||||
CRGB::Orange KEYWORD2
|
||||
CRGB::OrangeRed KEYWORD2
|
||||
CRGB::Orchid KEYWORD2
|
||||
CRGB::PaleGoldenrod KEYWORD2
|
||||
CRGB::PaleGreen KEYWORD2
|
||||
CRGB::PaleTurquoise KEYWORD2
|
||||
CRGB::PaleVioletRed KEYWORD2
|
||||
CRGB::PapayaWhip KEYWORD2
|
||||
CRGB::PeachPuff KEYWORD2
|
||||
CRGB::Peru KEYWORD2
|
||||
CRGB::Pink KEYWORD2
|
||||
CRGB::Plaid KEYWORD2
|
||||
CRGB::Plum KEYWORD2
|
||||
CRGB::PowderBlue KEYWORD2
|
||||
CRGB::Purple KEYWORD2
|
||||
CRGB::Red KEYWORD2
|
||||
CRGB::RosyBrown KEYWORD2
|
||||
CRGB::RoyalBlue KEYWORD2
|
||||
CRGB::SaddleBrown KEYWORD2
|
||||
CRGB::Salmon KEYWORD2
|
||||
CRGB::SandyBrown KEYWORD2
|
||||
CRGB::SeaGreen KEYWORD2
|
||||
CRGB::Seashell KEYWORD2
|
||||
CRGB::Sienna KEYWORD2
|
||||
CRGB::Silver KEYWORD2
|
||||
CRGB::SkyBlue KEYWORD2
|
||||
CRGB::SlateBlue KEYWORD2
|
||||
CRGB::SlateGray KEYWORD2
|
||||
CRGB::Snow KEYWORD2
|
||||
CRGB::SpringGreen KEYWORD2
|
||||
CRGB::SteelBlue KEYWORD2
|
||||
CRGB::Tan KEYWORD2
|
||||
CRGB::Teal KEYWORD2
|
||||
CRGB::Thistle KEYWORD2
|
||||
CRGB::Tomato KEYWORD2
|
||||
CRGB::Turquoise KEYWORD2
|
||||
CRGB::Violet KEYWORD2
|
||||
CRGB::Wheat KEYWORD2
|
||||
CRGB::White KEYWORD2
|
||||
CRGB::WhiteSmoke KEYWORD2
|
||||
CRGB::Yellow KEYWORD2
|
||||
CRGB::YellowGreen KEYWORD2
|
||||
|
||||
|
||||
#######################################
|
||||
# Constants (LITERAL1)
|
||||
#######################################
|
||||
|
||||
# Chipsets
|
||||
APA102 LITERAL1
|
||||
APA104 LITERAL1
|
||||
APA106 LITERAL1
|
||||
DMXSERIAL LITERAL1
|
||||
DMXSIMPLE LITERAL1
|
||||
DOTSTAR LITERAL1
|
||||
GE8822 LITERAL1
|
||||
GS1903 LITERAL1
|
||||
GW6205 LITERAL1
|
||||
GW6205B LITERAL1
|
||||
GW6205_400 LITERAL1
|
||||
LPD1886 LITERAL1
|
||||
LPD1886_8BIT LITERAL1
|
||||
LPD6803 LITERAL1
|
||||
LPD8806 LITERAL1
|
||||
NEOPIXEL LITERAL1
|
||||
OCTOWS2811 LITERAL1
|
||||
OCTOWS2811_400 LITERAL1
|
||||
OCTOWS2813 LITERAL1
|
||||
P9813 LITERAL1
|
||||
PIXIE LITERAL1
|
||||
PL9823 LITERAL1
|
||||
SK6812 LITERAL1
|
||||
SK6822 LITERAL1
|
||||
SK9822 LITERAL1
|
||||
SM16703 LITERAL1
|
||||
SM16716 LITERAL1
|
||||
SMART_MATRIX LITERAL1
|
||||
TM1803 LITERAL1
|
||||
TM1804 LITERAL1
|
||||
TM1809 LITERAL1
|
||||
TM1812 LITERAL1
|
||||
TM1829 LITERAL1
|
||||
UCS1903 LITERAL1
|
||||
UCS1903B LITERAL1
|
||||
UCS1904 LITERAL1
|
||||
UCS2903 LITERAL1
|
||||
WS2801 LITERAL1
|
||||
WS2803 LITERAL1
|
||||
WS2811 LITERAL1
|
||||
WS2811_400 LITERAL1
|
||||
WS2812 LITERAL1
|
||||
WS2812B LITERAL1
|
||||
WS2812SERIAL LITERAL1
|
||||
WS2813 LITERAL1
|
||||
WS2852 LITERAL1
|
||||
|
||||
# RGB orderings
|
||||
RGB LITERAL1
|
||||
RBG LITERAL1
|
||||
GRB LITERAL1
|
||||
GBR LITERAL1
|
||||
BRG LITERAL1
|
||||
BGR LITERAL1
|
||||
|
||||
# hue literals
|
||||
HUE_RED LITERAL1
|
||||
HUE_ORANGE LITERAL1
|
||||
HUE_YELLOW LITERAL1
|
||||
HUE_GREEN LITERAL1
|
||||
HUE_AQUA LITERAL1
|
||||
HUE_BLUE LITERAL1
|
||||
HUE_PURPLE LITERAL1
|
||||
HUE_PINK LITERAL1
|
||||
|
||||
# Color correction values
|
||||
TypicalSMD5050 LITERAL1
|
||||
TypicalLEDStrip LITERAL1
|
||||
Typical8mmPixel LITERAL1
|
||||
TypicalPixelString LITERAL1
|
||||
UncorrectedColor LITERAL1
|
||||
Candle LITERAL1
|
||||
Tungsten40W LITERAL1
|
||||
Tungsten100W LITERAL1
|
||||
Halogen LITERAL1
|
||||
CarbonArc LITERAL1
|
||||
HighNoonSun LITERAL1
|
||||
DirectSunlight LITERAL1
|
||||
OvercastSky LITERAL1
|
||||
ClearBlueSky LITERAL1
|
||||
WarmFluorescent LITERAL1
|
||||
StandardFluorescent LITERAL1
|
||||
CoolWhiteFluorescent LITERAL1
|
||||
FullSpectrumFluorescent LITERAL1
|
||||
GrowLightFluorescent LITERAL1
|
||||
BlackLightFluorescent LITERAL1
|
||||
MercuryVapor LITERAL1
|
||||
SodiumVapor LITERAL1
|
||||
MetalHalide LITERAL1
|
||||
HighPressureSodium LITERAL1
|
||||
UncorrectedTemperature LITERAL1
|
||||
|
||||
# Color util literals
|
||||
FORWARD_HUES LITERAL1
|
||||
BACKWARD_HUES LITERAL1
|
||||
SHORTEST_HUES LITERAL1
|
||||
LONGEST_HUES LITERAL1
|
||||
LINEARBLEND LITERAL1
|
||||
NOBLEND LITERAL1
|
||||
66
components/FastLED-idf/led_sysdefs.h
Normal file
66
components/FastLED-idf/led_sysdefs.h
Normal file
@ -0,0 +1,66 @@
|
||||
#ifndef __INC_LED_SYSDEFS_H
|
||||
#define __INC_LED_SYSDEFS_H
|
||||
|
||||
#include "FastLED.h"
|
||||
|
||||
#include "fastled_config.h"
|
||||
|
||||
#if defined(NRF51) || defined(__RFduino__) || defined (__Simblee__)
|
||||
#include "platforms/arm/nrf51/led_sysdefs_arm_nrf51.h"
|
||||
#elif defined(NRF52_SERIES)
|
||||
#include "platforms/arm/nrf52/led_sysdefs_arm_nrf52.h"
|
||||
#elif defined(__MK20DX128__) || defined(__MK20DX256__)
|
||||
// Include k20/T3 headers
|
||||
#include "platforms/arm/k20/led_sysdefs_arm_k20.h"
|
||||
#elif defined(__MK66FX1M0__) || defined(__MK64FX512__)
|
||||
// Include k66/T3.6 headers
|
||||
#include "platforms/arm/k66/led_sysdefs_arm_k66.h"
|
||||
#elif defined(__MKL26Z64__)
|
||||
// Include kl26/T-LC headers
|
||||
#include "platforms/arm/kl26/led_sysdefs_arm_kl26.h"
|
||||
#elif defined(__IMXRT1062__)
|
||||
// teensy4
|
||||
#include "platforms/arm/mxrt1062/led_sysdefs_arm_mxrt1062.h"
|
||||
#elif defined(__SAM3X8E__)
|
||||
// Include sam/due headers
|
||||
#include "platforms/arm/sam/led_sysdefs_arm_sam.h"
|
||||
#elif defined(STM32F10X_MD) || defined(__STM32F1__)
|
||||
#include "platforms/arm/stm32/led_sysdefs_arm_stm32.h"
|
||||
#elif defined(__SAMD21G18A__) || defined(__SAMD21J18A__) || defined(__SAMD21E17A__) || defined(__SAMD21E18A__) || defined(__SAMD51G19A__) || defined(__SAMD51J19A__)
|
||||
#include "platforms/arm/d21/led_sysdefs_arm_d21.h"
|
||||
#elif defined(ESP8266)
|
||||
#include "platforms/esp/8266/led_sysdefs_esp8266.h"
|
||||
#elif defined(ESP32)
|
||||
#include "platforms/esp/32/led_sysdefs_esp32.h"
|
||||
#elif defined(__AVR__)
|
||||
// AVR platforms
|
||||
#include "platforms/avr/led_sysdefs_avr.h"
|
||||
#else
|
||||
//
|
||||
// We got here because we don't recognize the platform that you're
|
||||
// trying to compile for: it's not AVR, or an ESP or ARM that we recognize.
|
||||
//
|
||||
// If you're reading this because you got the error below,
|
||||
// and if this new platform is just a minor variant of an
|
||||
// existing supported ARM platform, you may be able to add
|
||||
// a new 'defined(XXX)' selector in the apporpriate code above.
|
||||
//
|
||||
// If this platform is a new microcontroller, see "PORTING.md".
|
||||
//
|
||||
#error "This platform isn't recognized by FastLED... yet. See comments in FastLED/led_sysdefs.h for options."
|
||||
#endif
|
||||
|
||||
#ifndef FASTLED_NAMESPACE_BEGIN
|
||||
#define FASTLED_NAMESPACE_BEGIN
|
||||
#define FASTLED_NAMESPACE_END
|
||||
#define FASTLED_USING_NAMESPACE
|
||||
#endif
|
||||
|
||||
// Arduino.h needed for convenience functions digitalPinToPort/BitMask/portOutputRegister and the pinMode methods.
|
||||
#ifdef ARDUINO
|
||||
#include <Arduino.h>
|
||||
#endif
|
||||
|
||||
#define CLKS_PER_US (F_CPU/1000000)
|
||||
|
||||
#endif
|
||||
251
components/FastLED-idf/lib8tion.cpp
Normal file
251
components/FastLED-idf/lib8tion.cpp
Normal file
@ -0,0 +1,251 @@
|
||||
#define FASTLED_INTERNAL
|
||||
#include <stdint.h>
|
||||
#include "FastLED.h"
|
||||
|
||||
FASTLED_NAMESPACE_BEGIN
|
||||
|
||||
#define RAND16_SEED 1337
|
||||
uint16_t rand16seed = RAND16_SEED;
|
||||
|
||||
|
||||
// memset8, memcpy8, memmove8:
|
||||
// optimized avr replacements for the standard "C" library
|
||||
// routines memset, memcpy, and memmove.
|
||||
//
|
||||
// There are two techniques that make these routines
|
||||
// faster than the standard avr-libc routines.
|
||||
// First, the loops are unrolled 2X, meaning that
|
||||
// the average loop overhead is cut in half.
|
||||
// And second, the compare-and-branch at the bottom
|
||||
// of each loop decrements the low byte of the
|
||||
// counter, and if the carry is clear, it branches
|
||||
// back up immediately. Only if the low byte math
|
||||
// causes carry do we bother to decrement the high
|
||||
// byte and check that result for carry as well.
|
||||
// Results for a 100-byte buffer are 20-40% faster
|
||||
// than standard avr-libc, at a cost of a few extra
|
||||
// bytes of code.
|
||||
|
||||
#if defined(__AVR__)
|
||||
extern "C" {
|
||||
//__attribute__ ((noinline))
|
||||
void * memset8 ( void * ptr, uint8_t val, uint16_t num )
|
||||
{
|
||||
asm volatile(
|
||||
" movw r26, %[ptr] \n\t"
|
||||
" sbrs %A[num], 0 \n\t"
|
||||
" rjmp Lseteven_%= \n\t"
|
||||
" rjmp Lsetodd_%= \n\t"
|
||||
"Lsetloop_%=: \n\t"
|
||||
" st X+, %[val] \n\t"
|
||||
"Lsetodd_%=: \n\t"
|
||||
" st X+, %[val] \n\t"
|
||||
"Lseteven_%=: \n\t"
|
||||
" subi %A[num], 2 \n\t"
|
||||
" brcc Lsetloop_%= \n\t"
|
||||
" sbci %B[num], 0 \n\t"
|
||||
" brcc Lsetloop_%= \n\t"
|
||||
: [num] "+r" (num)
|
||||
: [ptr] "r" (ptr),
|
||||
[val] "r" (val)
|
||||
: "memory"
|
||||
);
|
||||
return ptr;
|
||||
}
|
||||
|
||||
|
||||
|
||||
//__attribute__ ((noinline))
|
||||
void * memcpy8 ( void * dst, const void* src, uint16_t num )
|
||||
{
|
||||
asm volatile(
|
||||
" movw r30, %[src] \n\t"
|
||||
" movw r26, %[dst] \n\t"
|
||||
" sbrs %A[num], 0 \n\t"
|
||||
" rjmp Lcpyeven_%= \n\t"
|
||||
" rjmp Lcpyodd_%= \n\t"
|
||||
"Lcpyloop_%=: \n\t"
|
||||
" ld __tmp_reg__, Z+ \n\t"
|
||||
" st X+, __tmp_reg__ \n\t"
|
||||
"Lcpyodd_%=: \n\t"
|
||||
" ld __tmp_reg__, Z+ \n\t"
|
||||
" st X+, __tmp_reg__ \n\t"
|
||||
"Lcpyeven_%=: \n\t"
|
||||
" subi %A[num], 2 \n\t"
|
||||
" brcc Lcpyloop_%= \n\t"
|
||||
" sbci %B[num], 0 \n\t"
|
||||
" brcc Lcpyloop_%= \n\t"
|
||||
: [num] "+r" (num)
|
||||
: [src] "r" (src),
|
||||
[dst] "r" (dst)
|
||||
: "memory"
|
||||
);
|
||||
return dst;
|
||||
}
|
||||
|
||||
//__attribute__ ((noinline))
|
||||
void * memmove8 ( void * dst, const void* src, uint16_t num )
|
||||
{
|
||||
if( src > dst) {
|
||||
// if src > dst then we can use the forward-stepping memcpy8
|
||||
return memcpy8( dst, src, num);
|
||||
} else {
|
||||
// if src < dst then we have to step backward:
|
||||
dst = (char*)dst + num;
|
||||
src = (char*)src + num;
|
||||
asm volatile(
|
||||
" movw r30, %[src] \n\t"
|
||||
" movw r26, %[dst] \n\t"
|
||||
" sbrs %A[num], 0 \n\t"
|
||||
" rjmp Lmoveven_%= \n\t"
|
||||
" rjmp Lmovodd_%= \n\t"
|
||||
"Lmovloop_%=: \n\t"
|
||||
" ld __tmp_reg__, -Z \n\t"
|
||||
" st -X, __tmp_reg__ \n\t"
|
||||
"Lmovodd_%=: \n\t"
|
||||
" ld __tmp_reg__, -Z \n\t"
|
||||
" st -X, __tmp_reg__ \n\t"
|
||||
"Lmoveven_%=: \n\t"
|
||||
" subi %A[num], 2 \n\t"
|
||||
" brcc Lmovloop_%= \n\t"
|
||||
" sbci %B[num], 0 \n\t"
|
||||
" brcc Lmovloop_%= \n\t"
|
||||
: [num] "+r" (num)
|
||||
: [src] "r" (src),
|
||||
[dst] "r" (dst)
|
||||
: "memory"
|
||||
);
|
||||
return dst;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
} /* end extern "C" */
|
||||
|
||||
#endif /* AVR */
|
||||
|
||||
|
||||
|
||||
|
||||
#if 0
|
||||
// TEST / VERIFICATION CODE ONLY BELOW THIS POINT
|
||||
#include <Arduino.h>
|
||||
#include "lib8tion.h"
|
||||
|
||||
void test1abs( int8_t i)
|
||||
{
|
||||
Serial.print("abs("); Serial.print(i); Serial.print(") = ");
|
||||
int8_t j = abs8(i);
|
||||
Serial.print(j); Serial.println(" ");
|
||||
}
|
||||
|
||||
void testabs()
|
||||
{
|
||||
delay(5000);
|
||||
for( int8_t q = -128; q != 127; q++) {
|
||||
test1abs(q);
|
||||
}
|
||||
for(;;){};
|
||||
}
|
||||
|
||||
|
||||
void testmul8()
|
||||
{
|
||||
delay(5000);
|
||||
byte r, c;
|
||||
|
||||
Serial.println("mul8:");
|
||||
for( r = 0; r <= 20; r += 1) {
|
||||
Serial.print(r); Serial.print(" : ");
|
||||
for( c = 0; c <= 20; c += 1) {
|
||||
byte t;
|
||||
t = mul8( r, c);
|
||||
Serial.print(t); Serial.print(' ');
|
||||
}
|
||||
Serial.println(' ');
|
||||
}
|
||||
Serial.println("done.");
|
||||
for(;;){};
|
||||
}
|
||||
|
||||
|
||||
void testscale8()
|
||||
{
|
||||
delay(5000);
|
||||
byte r, c;
|
||||
|
||||
Serial.println("scale8:");
|
||||
for( r = 0; r <= 240; r += 10) {
|
||||
Serial.print(r); Serial.print(" : ");
|
||||
for( c = 0; c <= 240; c += 10) {
|
||||
byte t;
|
||||
t = scale8( r, c);
|
||||
Serial.print(t); Serial.print(' ');
|
||||
}
|
||||
Serial.println(' ');
|
||||
}
|
||||
|
||||
Serial.println(' ');
|
||||
Serial.println("scale8_video:");
|
||||
|
||||
for( r = 0; r <= 100; r += 4) {
|
||||
Serial.print(r); Serial.print(" : ");
|
||||
for( c = 0; c <= 100; c += 4) {
|
||||
byte t;
|
||||
t = scale8_video( r, c);
|
||||
Serial.print(t); Serial.print(' ');
|
||||
}
|
||||
Serial.println(' ');
|
||||
}
|
||||
|
||||
Serial.println("done.");
|
||||
for(;;){};
|
||||
}
|
||||
|
||||
|
||||
|
||||
void testqadd8()
|
||||
{
|
||||
delay(5000);
|
||||
byte r, c;
|
||||
for( r = 0; r <= 240; r += 10) {
|
||||
Serial.print(r); Serial.print(" : ");
|
||||
for( c = 0; c <= 240; c += 10) {
|
||||
byte t;
|
||||
t = qadd8( r, c);
|
||||
Serial.print(t); Serial.print(' ');
|
||||
}
|
||||
Serial.println(' ');
|
||||
}
|
||||
Serial.println("done.");
|
||||
for(;;){};
|
||||
}
|
||||
|
||||
void testnscale8x3()
|
||||
{
|
||||
delay(5000);
|
||||
byte r, g, b, sc;
|
||||
for( byte z = 0; z < 10; z++) {
|
||||
r = random8(); g = random8(); b = random8(); sc = random8();
|
||||
|
||||
Serial.print("nscale8x3_video( ");
|
||||
Serial.print(r); Serial.print(", ");
|
||||
Serial.print(g); Serial.print(", ");
|
||||
Serial.print(b); Serial.print(", ");
|
||||
Serial.print(sc); Serial.print(") = [ ");
|
||||
|
||||
nscale8x3_video( r, g, b, sc);
|
||||
|
||||
Serial.print(r); Serial.print(", ");
|
||||
Serial.print(g); Serial.print(", ");
|
||||
Serial.print(b); Serial.print("]");
|
||||
|
||||
Serial.println(' ');
|
||||
}
|
||||
Serial.println("done.");
|
||||
for(;;){};
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
FASTLED_NAMESPACE_END
|
||||
1141
components/FastLED-idf/lib8tion.h
Normal file
1141
components/FastLED-idf/lib8tion.h
Normal file
File diff suppressed because it is too large
Load Diff
552
components/FastLED-idf/lib8tion/math8.h
Normal file
552
components/FastLED-idf/lib8tion/math8.h
Normal file
@ -0,0 +1,552 @@
|
||||
#ifndef __INC_LIB8TION_MATH_H
|
||||
#define __INC_LIB8TION_MATH_H
|
||||
|
||||
#include "scale8.h"
|
||||
|
||||
///@ingroup lib8tion
|
||||
|
||||
///@defgroup Math Basic math operations
|
||||
/// Fast, efficient 8-bit math functions specifically
|
||||
/// designed for high-performance LED programming.
|
||||
///
|
||||
/// Because of the AVR(Arduino) and ARM assembly language
|
||||
/// implementations provided, using these functions often
|
||||
/// results in smaller and faster code than the equivalent
|
||||
/// program using plain "C" arithmetic and logic.
|
||||
///@{
|
||||
|
||||
|
||||
/// add one byte to another, saturating at 0xFF
|
||||
/// @param i - first byte to add
|
||||
/// @param j - second byte to add
|
||||
/// @returns the sum of i & j, capped at 0xFF
|
||||
LIB8STATIC_ALWAYS_INLINE uint8_t qadd8( uint8_t i, uint8_t j)
|
||||
{
|
||||
#if QADD8_C == 1
|
||||
unsigned int t = i + j;
|
||||
if( t > 255) t = 255;
|
||||
return t;
|
||||
#elif QADD8_AVRASM == 1
|
||||
asm volatile(
|
||||
/* First, add j to i, conditioning the C flag */
|
||||
"add %0, %1 \n\t"
|
||||
|
||||
/* Now test the C flag.
|
||||
If C is clear, we branch around a load of 0xFF into i.
|
||||
If C is set, we go ahead and load 0xFF into i.
|
||||
*/
|
||||
"brcc L_%= \n\t"
|
||||
"ldi %0, 0xFF \n\t"
|
||||
"L_%=: "
|
||||
: "+a" (i)
|
||||
: "a" (j) );
|
||||
return i;
|
||||
#elif QADD8_ARM_DSP_ASM == 1
|
||||
asm volatile( "uqadd8 %0, %0, %1" : "+r" (i) : "r" (j));
|
||||
return i;
|
||||
#else
|
||||
#error "No implementation for qadd8 available."
|
||||
#endif
|
||||
}
|
||||
|
||||
/// Add one byte to another, saturating at 0x7F
|
||||
/// @param i - first byte to add
|
||||
/// @param j - second byte to add
|
||||
/// @returns the sum of i & j, capped at 0xFF
|
||||
LIB8STATIC_ALWAYS_INLINE int8_t qadd7( int8_t i, int8_t j)
|
||||
{
|
||||
#if QADD7_C == 1
|
||||
int16_t t = i + j;
|
||||
if( t > 127) t = 127;
|
||||
return t;
|
||||
#elif QADD7_AVRASM == 1
|
||||
asm volatile(
|
||||
/* First, add j to i, conditioning the V flag */
|
||||
"add %0, %1 \n\t"
|
||||
|
||||
/* Now test the V flag.
|
||||
If V is clear, we branch around a load of 0x7F into i.
|
||||
If V is set, we go ahead and load 0x7F into i.
|
||||
*/
|
||||
"brvc L_%= \n\t"
|
||||
"ldi %0, 0x7F \n\t"
|
||||
"L_%=: "
|
||||
: "+a" (i)
|
||||
: "a" (j) );
|
||||
|
||||
return i;
|
||||
#elif QADD7_ARM_DSP_ASM == 1
|
||||
asm volatile( "qadd8 %0, %0, %1" : "+r" (i) : "r" (j));
|
||||
return i;
|
||||
#else
|
||||
#error "No implementation for qadd7 available."
|
||||
#endif
|
||||
}
|
||||
|
||||
/// subtract one byte from another, saturating at 0x00
|
||||
/// @returns i - j with a floor of 0
|
||||
LIB8STATIC_ALWAYS_INLINE uint8_t qsub8( uint8_t i, uint8_t j)
|
||||
{
|
||||
#if QSUB8_C == 1
|
||||
int t = i - j;
|
||||
if( t < 0) t = 0;
|
||||
return t;
|
||||
#elif QSUB8_AVRASM == 1
|
||||
|
||||
asm volatile(
|
||||
/* First, subtract j from i, conditioning the C flag */
|
||||
"sub %0, %1 \n\t"
|
||||
|
||||
/* Now test the C flag.
|
||||
If C is clear, we branch around a load of 0x00 into i.
|
||||
If C is set, we go ahead and load 0x00 into i.
|
||||
*/
|
||||
"brcc L_%= \n\t"
|
||||
"ldi %0, 0x00 \n\t"
|
||||
"L_%=: "
|
||||
: "+a" (i)
|
||||
: "a" (j) );
|
||||
|
||||
return i;
|
||||
#else
|
||||
#error "No implementation for qsub8 available."
|
||||
#endif
|
||||
}
|
||||
|
||||
/// add one byte to another, with one byte result
|
||||
LIB8STATIC_ALWAYS_INLINE uint8_t add8( uint8_t i, uint8_t j)
|
||||
{
|
||||
#if ADD8_C == 1
|
||||
int t = i + j;
|
||||
return t;
|
||||
#elif ADD8_AVRASM == 1
|
||||
// Add j to i, period.
|
||||
asm volatile( "add %0, %1" : "+a" (i) : "a" (j));
|
||||
return i;
|
||||
#else
|
||||
#error "No implementation for add8 available."
|
||||
#endif
|
||||
}
|
||||
|
||||
/// add one byte to another, with one byte result
|
||||
LIB8STATIC_ALWAYS_INLINE uint16_t add8to16( uint8_t i, uint16_t j)
|
||||
{
|
||||
#if ADD8_C == 1
|
||||
uint16_t t = i + j;
|
||||
return t;
|
||||
#elif ADD8_AVRASM == 1
|
||||
// Add i(one byte) to j(two bytes)
|
||||
asm volatile( "add %A[j], %[i] \n\t"
|
||||
"adc %B[j], __zero_reg__ \n\t"
|
||||
: [j] "+a" (j)
|
||||
: [i] "a" (i)
|
||||
);
|
||||
return i;
|
||||
#else
|
||||
#error "No implementation for add8to16 available."
|
||||
#endif
|
||||
}
|
||||
|
||||
|
||||
/// subtract one byte from another, 8-bit result
|
||||
LIB8STATIC_ALWAYS_INLINE uint8_t sub8( uint8_t i, uint8_t j)
|
||||
{
|
||||
#if SUB8_C == 1
|
||||
int t = i - j;
|
||||
return t;
|
||||
#elif SUB8_AVRASM == 1
|
||||
// Subtract j from i, period.
|
||||
asm volatile( "sub %0, %1" : "+a" (i) : "a" (j));
|
||||
return i;
|
||||
#else
|
||||
#error "No implementation for sub8 available."
|
||||
#endif
|
||||
}
|
||||
|
||||
/// Calculate an integer average of two unsigned
|
||||
/// 8-bit integer values (uint8_t).
|
||||
/// Fractional results are rounded down, e.g. avg8(20,41) = 30
|
||||
LIB8STATIC_ALWAYS_INLINE uint8_t avg8( uint8_t i, uint8_t j)
|
||||
{
|
||||
#if AVG8_C == 1
|
||||
return (i + j) >> 1;
|
||||
#elif AVG8_AVRASM == 1
|
||||
asm volatile(
|
||||
/* First, add j to i, 9th bit overflows into C flag */
|
||||
"add %0, %1 \n\t"
|
||||
/* Divide by two, moving C flag into high 8th bit */
|
||||
"ror %0 \n\t"
|
||||
: "+a" (i)
|
||||
: "a" (j) );
|
||||
return i;
|
||||
#else
|
||||
#error "No implementation for avg8 available."
|
||||
#endif
|
||||
}
|
||||
|
||||
/// Calculate an integer average of two unsigned
|
||||
/// 16-bit integer values (uint16_t).
|
||||
/// Fractional results are rounded down, e.g. avg16(20,41) = 30
|
||||
LIB8STATIC_ALWAYS_INLINE uint16_t avg16( uint16_t i, uint16_t j)
|
||||
{
|
||||
#if AVG16_C == 1
|
||||
return (uint32_t)((uint32_t)(i) + (uint32_t)(j)) >> 1;
|
||||
#elif AVG16_AVRASM == 1
|
||||
asm volatile(
|
||||
/* First, add jLo (heh) to iLo, 9th bit overflows into C flag */
|
||||
"add %A[i], %A[j] \n\t"
|
||||
/* Now, add C + jHi to iHi, 17th bit overflows into C flag */
|
||||
"adc %B[i], %B[j] \n\t"
|
||||
/* Divide iHi by two, moving C flag into high 16th bit, old 9th bit now in C */
|
||||
"ror %B[i] \n\t"
|
||||
/* Divide iLo by two, moving C flag into high 8th bit */
|
||||
"ror %A[i] \n\t"
|
||||
: [i] "+a" (i)
|
||||
: [j] "a" (j) );
|
||||
return i;
|
||||
#else
|
||||
#error "No implementation for avg16 available."
|
||||
#endif
|
||||
}
|
||||
|
||||
|
||||
/// Calculate an integer average of two signed 7-bit
|
||||
/// integers (int8_t)
|
||||
/// If the first argument is even, result is rounded down.
|
||||
/// If the first argument is odd, result is result up.
|
||||
LIB8STATIC_ALWAYS_INLINE int8_t avg7( int8_t i, int8_t j)
|
||||
{
|
||||
#if AVG7_C == 1
|
||||
return ((i + j) >> 1) + (i & 0x1);
|
||||
#elif AVG7_AVRASM == 1
|
||||
asm volatile(
|
||||
"asr %1 \n\t"
|
||||
"asr %0 \n\t"
|
||||
"adc %0, %1 \n\t"
|
||||
: "+a" (i)
|
||||
: "a" (j) );
|
||||
return i;
|
||||
#else
|
||||
#error "No implementation for avg7 available."
|
||||
#endif
|
||||
}
|
||||
|
||||
/// Calculate an integer average of two signed 15-bit
|
||||
/// integers (int16_t)
|
||||
/// If the first argument is even, result is rounded down.
|
||||
/// If the first argument is odd, result is result up.
|
||||
LIB8STATIC_ALWAYS_INLINE int16_t avg15( int16_t i, int16_t j)
|
||||
{
|
||||
#if AVG15_C == 1
|
||||
return ((int32_t)((int32_t)(i) + (int32_t)(j)) >> 1) + (i & 0x1);
|
||||
#elif AVG15_AVRASM == 1
|
||||
asm volatile(
|
||||
/* first divide j by 2, throwing away lowest bit */
|
||||
"asr %B[j] \n\t"
|
||||
"ror %A[j] \n\t"
|
||||
/* now divide i by 2, with lowest bit going into C */
|
||||
"asr %B[i] \n\t"
|
||||
"ror %A[i] \n\t"
|
||||
/* add j + C to i */
|
||||
"adc %A[i], %A[j] \n\t"
|
||||
"adc %B[i], %B[j] \n\t"
|
||||
: [i] "+a" (i)
|
||||
: [j] "a" (j) );
|
||||
return i;
|
||||
#else
|
||||
#error "No implementation for avg15 available."
|
||||
#endif
|
||||
}
|
||||
|
||||
|
||||
/// Calculate the remainder of one unsigned 8-bit
|
||||
/// value divided by anoter, aka A % M.
|
||||
/// Implemented by repeated subtraction, which is
|
||||
/// very compact, and very fast if A is 'probably'
|
||||
/// less than M. If A is a large multiple of M,
|
||||
/// the loop has to execute multiple times. However,
|
||||
/// even in that case, the loop is only two
|
||||
/// instructions long on AVR, i.e., quick.
|
||||
LIB8STATIC_ALWAYS_INLINE uint8_t mod8( uint8_t a, uint8_t m)
|
||||
{
|
||||
#if defined(__AVR__)
|
||||
asm volatile (
|
||||
"L_%=: sub %[a],%[m] \n\t"
|
||||
" brcc L_%= \n\t"
|
||||
" add %[a],%[m] \n\t"
|
||||
: [a] "+r" (a)
|
||||
: [m] "r" (m)
|
||||
);
|
||||
#else
|
||||
while( a >= m) a -= m;
|
||||
#endif
|
||||
return a;
|
||||
}
|
||||
|
||||
/// Add two numbers, and calculate the modulo
|
||||
/// of the sum and a third number, M.
|
||||
/// In other words, it returns (A+B) % M.
|
||||
/// It is designed as a compact mechanism for
|
||||
/// incrementing a 'mode' switch and wrapping
|
||||
/// around back to 'mode 0' when the switch
|
||||
/// goes past the end of the available range.
|
||||
/// e.g. if you have seven modes, this switches
|
||||
/// to the next one and wraps around if needed:
|
||||
/// mode = addmod8( mode, 1, 7);
|
||||
///LIB8STATIC_ALWAYS_INLINESee 'mod8' for notes on performance.
|
||||
LIB8STATIC uint8_t addmod8( uint8_t a, uint8_t b, uint8_t m)
|
||||
{
|
||||
#if defined(__AVR__)
|
||||
asm volatile (
|
||||
" add %[a],%[b] \n\t"
|
||||
"L_%=: sub %[a],%[m] \n\t"
|
||||
" brcc L_%= \n\t"
|
||||
" add %[a],%[m] \n\t"
|
||||
: [a] "+r" (a)
|
||||
: [b] "r" (b), [m] "r" (m)
|
||||
);
|
||||
#else
|
||||
a += b;
|
||||
while( a >= m) a -= m;
|
||||
#endif
|
||||
return a;
|
||||
}
|
||||
|
||||
/// Subtract two numbers, and calculate the modulo
|
||||
/// of the difference and a third number, M.
|
||||
/// In other words, it returns (A-B) % M.
|
||||
/// It is designed as a compact mechanism for
|
||||
/// incrementing a 'mode' switch and wrapping
|
||||
/// around back to 'mode 0' when the switch
|
||||
/// goes past the end of the available range.
|
||||
/// e.g. if you have seven modes, this switches
|
||||
/// to the next one and wraps around if needed:
|
||||
/// mode = addmod8( mode, 1, 7);
|
||||
///LIB8STATIC_ALWAYS_INLINESee 'mod8' for notes on performance.
|
||||
LIB8STATIC uint8_t submod8( uint8_t a, uint8_t b, uint8_t m)
|
||||
{
|
||||
#if defined(__AVR__)
|
||||
asm volatile (
|
||||
" sub %[a],%[b] \n\t"
|
||||
"L_%=: sub %[a],%[m] \n\t"
|
||||
" brcc L_%= \n\t"
|
||||
" add %[a],%[m] \n\t"
|
||||
: [a] "+r" (a)
|
||||
: [b] "r" (b), [m] "r" (m)
|
||||
);
|
||||
#else
|
||||
a -= b;
|
||||
while( a >= m) a -= m;
|
||||
#endif
|
||||
return a;
|
||||
}
|
||||
|
||||
/// 8x8 bit multiplication, with 8 bit result
|
||||
LIB8STATIC_ALWAYS_INLINE uint8_t mul8( uint8_t i, uint8_t j)
|
||||
{
|
||||
#if MUL8_C == 1
|
||||
return ((int)i * (int)(j) ) & 0xFF;
|
||||
#elif MUL8_AVRASM == 1
|
||||
asm volatile(
|
||||
/* Multiply 8-bit i * 8-bit j, giving 16-bit r1,r0 */
|
||||
"mul %0, %1 \n\t"
|
||||
/* Extract the LOW 8-bits (r0) */
|
||||
"mov %0, r0 \n\t"
|
||||
/* Restore r1 to "0"; it's expected to always be that */
|
||||
"clr __zero_reg__ \n\t"
|
||||
: "+a" (i)
|
||||
: "a" (j)
|
||||
: "r0", "r1");
|
||||
|
||||
return i;
|
||||
#else
|
||||
#error "No implementation for mul8 available."
|
||||
#endif
|
||||
}
|
||||
|
||||
|
||||
/// saturating 8x8 bit multiplication, with 8 bit result
|
||||
/// @returns the product of i * j, capping at 0xFF
|
||||
LIB8STATIC_ALWAYS_INLINE uint8_t qmul8( uint8_t i, uint8_t j)
|
||||
{
|
||||
#if QMUL8_C == 1
|
||||
int p = ((int)i * (int)(j) );
|
||||
if( p > 255) p = 255;
|
||||
return p;
|
||||
#elif QMUL8_AVRASM == 1
|
||||
asm volatile(
|
||||
/* Multiply 8-bit i * 8-bit j, giving 16-bit r1,r0 */
|
||||
" mul %0, %1 \n\t"
|
||||
/* If high byte of result is zero, all is well. */
|
||||
" tst r1 \n\t"
|
||||
" breq Lnospill_%= \n\t"
|
||||
/* If high byte of result > 0, saturate low byte to 0xFF */
|
||||
" ldi %0,0xFF \n\t"
|
||||
" rjmp Ldone_%= \n\t"
|
||||
"Lnospill_%=: \n\t"
|
||||
/* Extract the LOW 8-bits (r0) */
|
||||
" mov %0, r0 \n\t"
|
||||
"Ldone_%=: \n\t"
|
||||
/* Restore r1 to "0"; it's expected to always be that */
|
||||
" clr __zero_reg__ \n\t"
|
||||
: "+a" (i)
|
||||
: "a" (j)
|
||||
: "r0", "r1");
|
||||
|
||||
return i;
|
||||
#else
|
||||
#error "No implementation for qmul8 available."
|
||||
#endif
|
||||
}
|
||||
|
||||
|
||||
/// take abs() of a signed 8-bit uint8_t
|
||||
LIB8STATIC_ALWAYS_INLINE int8_t abs8( int8_t i)
|
||||
{
|
||||
#if ABS8_C == 1
|
||||
if( i < 0) i = -i;
|
||||
return i;
|
||||
#elif ABS8_AVRASM == 1
|
||||
|
||||
|
||||
asm volatile(
|
||||
/* First, check the high bit, and prepare to skip if it's clear */
|
||||
"sbrc %0, 7 \n"
|
||||
|
||||
/* Negate the value */
|
||||
"neg %0 \n"
|
||||
|
||||
: "+r" (i) : "r" (i) );
|
||||
return i;
|
||||
#else
|
||||
#error "No implementation for abs8 available."
|
||||
#endif
|
||||
}
|
||||
|
||||
/// square root for 16-bit integers
|
||||
/// About three times faster and five times smaller
|
||||
/// than Arduino's general sqrt on AVR.
|
||||
LIB8STATIC uint8_t sqrt16(uint16_t x)
|
||||
{
|
||||
if( x <= 1) {
|
||||
return x;
|
||||
}
|
||||
|
||||
uint8_t low = 1; // lower bound
|
||||
uint8_t hi, mid;
|
||||
|
||||
if( x > 7904) {
|
||||
hi = 255;
|
||||
} else {
|
||||
hi = (x >> 5) + 8; // initial estimate for upper bound
|
||||
}
|
||||
|
||||
do {
|
||||
mid = (low + hi) >> 1;
|
||||
if ((uint16_t)(mid * mid) > x) {
|
||||
hi = mid - 1;
|
||||
} else {
|
||||
if( mid == 255) {
|
||||
return 255;
|
||||
}
|
||||
low = mid + 1;
|
||||
}
|
||||
} while (hi >= low);
|
||||
|
||||
return low - 1;
|
||||
}
|
||||
|
||||
/// blend a variable proproportion(0-255) of one byte to another
|
||||
/// @param a - the starting byte value
|
||||
/// @param b - the byte value to blend toward
|
||||
/// @param amountOfB - the proportion (0-255) of b to blend
|
||||
/// @returns a byte value between a and b, inclusive
|
||||
#if (FASTLED_BLEND_FIXED == 1)
|
||||
LIB8STATIC uint8_t blend8( uint8_t a, uint8_t b, uint8_t amountOfB)
|
||||
{
|
||||
#if BLEND8_C == 1
|
||||
uint16_t partial;
|
||||
uint8_t result;
|
||||
|
||||
uint8_t amountOfA = 255 - amountOfB;
|
||||
|
||||
partial = (a * amountOfA);
|
||||
#if (FASTLED_SCALE8_FIXED == 1)
|
||||
partial += a;
|
||||
//partial = add8to16( a, partial);
|
||||
#endif
|
||||
|
||||
partial += (b * amountOfB);
|
||||
#if (FASTLED_SCALE8_FIXED == 1)
|
||||
partial += b;
|
||||
//partial = add8to16( b, partial);
|
||||
#endif
|
||||
|
||||
result = partial >> 8;
|
||||
|
||||
return result;
|
||||
|
||||
#elif BLEND8_AVRASM == 1
|
||||
uint16_t partial;
|
||||
uint8_t result;
|
||||
|
||||
asm volatile (
|
||||
/* partial = b * amountOfB */
|
||||
" mul %[b], %[amountOfB] \n\t"
|
||||
" movw %A[partial], r0 \n\t"
|
||||
|
||||
/* amountOfB (aka amountOfA) = 255 - amountOfB */
|
||||
" com %[amountOfB] \n\t"
|
||||
|
||||
/* partial += a * amountOfB (aka amountOfA) */
|
||||
" mul %[a], %[amountOfB] \n\t"
|
||||
|
||||
" add %A[partial], r0 \n\t"
|
||||
" adc %B[partial], r1 \n\t"
|
||||
|
||||
" clr __zero_reg__ \n\t"
|
||||
|
||||
#if (FASTLED_SCALE8_FIXED == 1)
|
||||
/* partial += a */
|
||||
" add %A[partial], %[a] \n\t"
|
||||
" adc %B[partial], __zero_reg__ \n\t"
|
||||
|
||||
// partial += b
|
||||
" add %A[partial], %[b] \n\t"
|
||||
" adc %B[partial], __zero_reg__ \n\t"
|
||||
#endif
|
||||
|
||||
: [partial] "=r" (partial),
|
||||
[amountOfB] "+a" (amountOfB)
|
||||
: [a] "a" (a),
|
||||
[b] "a" (b)
|
||||
: "r0", "r1"
|
||||
);
|
||||
|
||||
result = partial >> 8;
|
||||
|
||||
return result;
|
||||
|
||||
#else
|
||||
#error "No implementation for blend8 available."
|
||||
#endif
|
||||
}
|
||||
|
||||
#else
|
||||
LIB8STATIC uint8_t blend8( uint8_t a, uint8_t b, uint8_t amountOfB)
|
||||
{
|
||||
// This version loses precision in the integer math
|
||||
// and can actually return results outside of the range
|
||||
// from a to b. Its use is not recommended.
|
||||
uint8_t result;
|
||||
uint8_t amountOfA = 255 - amountOfB;
|
||||
result = scale8_LEAVING_R1_DIRTY( a, amountOfA)
|
||||
+ scale8_LEAVING_R1_DIRTY( b, amountOfB);
|
||||
cleanup_R1();
|
||||
return result;
|
||||
}
|
||||
#endif
|
||||
|
||||
|
||||
///@}
|
||||
#endif
|
||||
94
components/FastLED-idf/lib8tion/random8.h
Normal file
94
components/FastLED-idf/lib8tion/random8.h
Normal file
@ -0,0 +1,94 @@
|
||||
#ifndef __INC_LIB8TION_RANDOM_H
|
||||
#define __INC_LIB8TION_RANDOM_H
|
||||
///@ingroup lib8tion
|
||||
|
||||
///@defgroup Random Fast random number generators
|
||||
/// Fast 8- and 16- bit unsigned random numbers.
|
||||
/// Significantly faster than Arduino random(), but
|
||||
/// also somewhat less random. You can add entropy.
|
||||
///@{
|
||||
|
||||
// X(n+1) = (2053 * X(n)) + 13849)
|
||||
#define FASTLED_RAND16_2053 ((uint16_t)(2053))
|
||||
#define FASTLED_RAND16_13849 ((uint16_t)(13849))
|
||||
|
||||
/// random number seed
|
||||
extern uint16_t rand16seed;// = RAND16_SEED;
|
||||
|
||||
/// Generate an 8-bit random number
|
||||
LIB8STATIC uint8_t random8()
|
||||
{
|
||||
rand16seed = (rand16seed * FASTLED_RAND16_2053) + FASTLED_RAND16_13849;
|
||||
// return the sum of the high and low bytes, for better
|
||||
// mixing and non-sequential correlation
|
||||
return (uint8_t)(((uint8_t)(rand16seed & 0xFF)) +
|
||||
((uint8_t)(rand16seed >> 8)));
|
||||
}
|
||||
|
||||
/// Generate a 16 bit random number
|
||||
LIB8STATIC uint16_t random16()
|
||||
{
|
||||
rand16seed = (rand16seed * FASTLED_RAND16_2053) + FASTLED_RAND16_13849;
|
||||
return rand16seed;
|
||||
}
|
||||
|
||||
/// Generate an 8-bit random number between 0 and lim
|
||||
/// @param lim the upper bound for the result
|
||||
LIB8STATIC uint8_t random8(uint8_t lim)
|
||||
{
|
||||
uint8_t r = random8();
|
||||
r = (r*lim) >> 8;
|
||||
return r;
|
||||
}
|
||||
|
||||
/// Generate an 8-bit random number in the given range
|
||||
/// @param min the lower bound for the random number
|
||||
/// @param lim the upper bound for the random number
|
||||
LIB8STATIC uint8_t random8(uint8_t min, uint8_t lim)
|
||||
{
|
||||
uint8_t delta = lim - min;
|
||||
uint8_t r = random8(delta) + min;
|
||||
return r;
|
||||
}
|
||||
|
||||
/// Generate an 16-bit random number between 0 and lim
|
||||
/// @param lim the upper bound for the result
|
||||
LIB8STATIC uint16_t random16( uint16_t lim)
|
||||
{
|
||||
uint16_t r = random16();
|
||||
uint32_t p = (uint32_t)lim * (uint32_t)r;
|
||||
r = p >> 16;
|
||||
return r;
|
||||
}
|
||||
|
||||
/// Generate an 16-bit random number in the given range
|
||||
/// @param min the lower bound for the random number
|
||||
/// @param lim the upper bound for the random number
|
||||
LIB8STATIC uint16_t random16( uint16_t min, uint16_t lim)
|
||||
{
|
||||
uint16_t delta = lim - min;
|
||||
uint16_t r = random16( delta) + min;
|
||||
return r;
|
||||
}
|
||||
|
||||
/// Set the 16-bit seed used for the random number generator
|
||||
LIB8STATIC void random16_set_seed( uint16_t seed)
|
||||
{
|
||||
rand16seed = seed;
|
||||
}
|
||||
|
||||
/// Get the current seed value for the random number generator
|
||||
LIB8STATIC uint16_t random16_get_seed()
|
||||
{
|
||||
return rand16seed;
|
||||
}
|
||||
|
||||
/// Add entropy into the random number generator
|
||||
LIB8STATIC void random16_add_entropy( uint16_t entropy)
|
||||
{
|
||||
rand16seed += entropy;
|
||||
}
|
||||
|
||||
///@}
|
||||
|
||||
#endif
|
||||
712
components/FastLED-idf/lib8tion/scale8.h
Normal file
712
components/FastLED-idf/lib8tion/scale8.h
Normal file
@ -0,0 +1,712 @@
|
||||
#ifndef __INC_LIB8TION_SCALE_H
|
||||
#define __INC_LIB8TION_SCALE_H
|
||||
|
||||
///@ingroup lib8tion
|
||||
|
||||
///@defgroup Scaling Scaling functions
|
||||
/// Fast, efficient 8-bit scaling functions specifically
|
||||
/// designed for high-performance LED programming.
|
||||
///
|
||||
/// Because of the AVR(Arduino) and ARM assembly language
|
||||
/// implementations provided, using these functions often
|
||||
/// results in smaller and faster code than the equivalent
|
||||
/// program using plain "C" arithmetic and logic.
|
||||
///@{
|
||||
|
||||
/// scale one byte by a second one, which is treated as
|
||||
/// the numerator of a fraction whose denominator is 256
|
||||
/// In other words, it computes i * (scale / 256)
|
||||
/// 4 clocks AVR with MUL, 2 clocks ARM
|
||||
LIB8STATIC_ALWAYS_INLINE uint8_t scale8( uint8_t i, fract8 scale)
|
||||
{
|
||||
#if SCALE8_C == 1
|
||||
#if (FASTLED_SCALE8_FIXED == 1)
|
||||
return (((uint16_t)i) * (1+(uint16_t)(scale))) >> 8;
|
||||
#else
|
||||
return ((uint16_t)i * (uint16_t)(scale) ) >> 8;
|
||||
#endif
|
||||
#elif SCALE8_AVRASM == 1
|
||||
#if defined(LIB8_ATTINY)
|
||||
#if (FASTLED_SCALE8_FIXED == 1)
|
||||
uint8_t work=i;
|
||||
#else
|
||||
uint8_t work=0;
|
||||
#endif
|
||||
uint8_t cnt=0x80;
|
||||
asm volatile(
|
||||
#if (FASTLED_SCALE8_FIXED == 1)
|
||||
" inc %[scale] \n\t"
|
||||
" breq DONE_%= \n\t"
|
||||
" clr %[work] \n\t"
|
||||
#endif
|
||||
"LOOP_%=: \n\t"
|
||||
/*" sbrc %[scale], 0 \n\t"
|
||||
" add %[work], %[i] \n\t"
|
||||
" ror %[work] \n\t"
|
||||
" lsr %[scale] \n\t"
|
||||
" clc \n\t"*/
|
||||
" sbrc %[scale], 0 \n\t"
|
||||
" add %[work], %[i] \n\t"
|
||||
" ror %[work] \n\t"
|
||||
" lsr %[scale] \n\t"
|
||||
" lsr %[cnt] \n\t"
|
||||
"brcc LOOP_%= \n\t"
|
||||
"DONE_%=: \n\t"
|
||||
: [work] "+r" (work), [cnt] "+r" (cnt)
|
||||
: [scale] "r" (scale), [i] "r" (i)
|
||||
:
|
||||
);
|
||||
return work;
|
||||
#else
|
||||
asm volatile(
|
||||
#if (FASTLED_SCALE8_FIXED==1)
|
||||
// Multiply 8-bit i * 8-bit scale, giving 16-bit r1,r0
|
||||
"mul %0, %1 \n\t"
|
||||
// Add i to r0, possibly setting the carry flag
|
||||
"add r0, %0 \n\t"
|
||||
// load the immediate 0 into i (note, this does _not_ touch any flags)
|
||||
"ldi %0, 0x00 \n\t"
|
||||
// walk and chew gum at the same time
|
||||
"adc %0, r1 \n\t"
|
||||
#else
|
||||
/* Multiply 8-bit i * 8-bit scale, giving 16-bit r1,r0 */
|
||||
"mul %0, %1 \n\t"
|
||||
/* Move the high 8-bits of the product (r1) back to i */
|
||||
"mov %0, r1 \n\t"
|
||||
/* Restore r1 to "0"; it's expected to always be that */
|
||||
#endif
|
||||
"clr __zero_reg__ \n\t"
|
||||
|
||||
: "+a" (i) /* writes to i */
|
||||
: "a" (scale) /* uses scale */
|
||||
: "r0", "r1" /* clobbers r0, r1 */ );
|
||||
|
||||
/* Return the result */
|
||||
return i;
|
||||
#endif
|
||||
#else
|
||||
#error "No implementation for scale8 available."
|
||||
#endif
|
||||
}
|
||||
|
||||
|
||||
/// The "video" version of scale8 guarantees that the output will
|
||||
/// be only be zero if one or both of the inputs are zero. If both
|
||||
/// inputs are non-zero, the output is guaranteed to be non-zero.
|
||||
/// This makes for better 'video'/LED dimming, at the cost of
|
||||
/// several additional cycles.
|
||||
LIB8STATIC_ALWAYS_INLINE uint8_t scale8_video( uint8_t i, fract8 scale)
|
||||
{
|
||||
#if SCALE8_C == 1 || defined(LIB8_ATTINY)
|
||||
uint8_t j = (((int)i * (int)scale) >> 8) + ((i&&scale)?1:0);
|
||||
// uint8_t nonzeroscale = (scale != 0) ? 1 : 0;
|
||||
// uint8_t j = (i == 0) ? 0 : (((int)i * (int)(scale) ) >> 8) + nonzeroscale;
|
||||
return j;
|
||||
#elif SCALE8_AVRASM == 1
|
||||
uint8_t j=0;
|
||||
asm volatile(
|
||||
" tst %[i]\n\t"
|
||||
" breq L_%=\n\t"
|
||||
" mul %[i], %[scale]\n\t"
|
||||
" mov %[j], r1\n\t"
|
||||
" clr __zero_reg__\n\t"
|
||||
" cpse %[scale], r1\n\t"
|
||||
" subi %[j], 0xFF\n\t"
|
||||
"L_%=: \n\t"
|
||||
: [j] "+a" (j)
|
||||
: [i] "a" (i), [scale] "a" (scale)
|
||||
: "r0", "r1");
|
||||
|
||||
return j;
|
||||
// uint8_t nonzeroscale = (scale != 0) ? 1 : 0;
|
||||
// asm volatile(
|
||||
// " tst %0 \n"
|
||||
// " breq L_%= \n"
|
||||
// " mul %0, %1 \n"
|
||||
// " mov %0, r1 \n"
|
||||
// " add %0, %2 \n"
|
||||
// " clr __zero_reg__ \n"
|
||||
// "L_%=: \n"
|
||||
|
||||
// : "+a" (i)
|
||||
// : "a" (scale), "a" (nonzeroscale)
|
||||
// : "r0", "r1");
|
||||
|
||||
// // Return the result
|
||||
// return i;
|
||||
#else
|
||||
#error "No implementation for scale8_video available."
|
||||
#endif
|
||||
}
|
||||
|
||||
|
||||
/// This version of scale8 does not clean up the R1 register on AVR
|
||||
/// If you are doing several 'scale8's in a row, use this, and
|
||||
/// then explicitly call cleanup_R1.
|
||||
LIB8STATIC_ALWAYS_INLINE uint8_t scale8_LEAVING_R1_DIRTY( uint8_t i, fract8 scale)
|
||||
{
|
||||
#if SCALE8_C == 1
|
||||
#if (FASTLED_SCALE8_FIXED == 1)
|
||||
return (((uint16_t)i) * ((uint16_t)(scale)+1)) >> 8;
|
||||
#else
|
||||
return ((int)i * (int)(scale) ) >> 8;
|
||||
#endif
|
||||
#elif SCALE8_AVRASM == 1
|
||||
asm volatile(
|
||||
#if (FASTLED_SCALE8_FIXED==1)
|
||||
// Multiply 8-bit i * 8-bit scale, giving 16-bit r1,r0
|
||||
"mul %0, %1 \n\t"
|
||||
// Add i to r0, possibly setting the carry flag
|
||||
"add r0, %0 \n\t"
|
||||
// load the immediate 0 into i (note, this does _not_ touch any flags)
|
||||
"ldi %0, 0x00 \n\t"
|
||||
// walk and chew gum at the same time
|
||||
"adc %0, r1 \n\t"
|
||||
#else
|
||||
/* Multiply 8-bit i * 8-bit scale, giving 16-bit r1,r0 */
|
||||
"mul %0, %1 \n\t"
|
||||
/* Move the high 8-bits of the product (r1) back to i */
|
||||
"mov %0, r1 \n\t"
|
||||
#endif
|
||||
/* R1 IS LEFT DIRTY HERE; YOU MUST ZERO IT OUT YOURSELF */
|
||||
/* "clr __zero_reg__ \n\t" */
|
||||
|
||||
: "+a" (i) /* writes to i */
|
||||
: "a" (scale) /* uses scale */
|
||||
: "r0", "r1" /* clobbers r0, r1 */ );
|
||||
|
||||
// Return the result
|
||||
return i;
|
||||
#else
|
||||
#error "No implementation for scale8_LEAVING_R1_DIRTY available."
|
||||
#endif
|
||||
}
|
||||
|
||||
/// In place modifying version of scale8, also this version of nscale8 does not
|
||||
/// clean up the R1 register on AVR
|
||||
/// If you are doing several 'scale8's in a row, use this, and
|
||||
/// then explicitly call cleanup_R1.
|
||||
|
||||
LIB8STATIC_ALWAYS_INLINE void nscale8_LEAVING_R1_DIRTY( uint8_t& i, fract8 scale)
|
||||
{
|
||||
#if SCALE8_C == 1
|
||||
#if (FASTLED_SCALE8_FIXED == 1)
|
||||
i = (((uint16_t)i) * ((uint16_t)(scale)+1)) >> 8;
|
||||
#else
|
||||
i = ((int)i * (int)(scale) ) >> 8;
|
||||
#endif
|
||||
#elif SCALE8_AVRASM == 1
|
||||
asm volatile(
|
||||
#if (FASTLED_SCALE8_FIXED==1)
|
||||
// Multiply 8-bit i * 8-bit scale, giving 16-bit r1,r0
|
||||
"mul %0, %1 \n\t"
|
||||
// Add i to r0, possibly setting the carry flag
|
||||
"add r0, %0 \n\t"
|
||||
// load the immediate 0 into i (note, this does _not_ touch any flags)
|
||||
"ldi %0, 0x00 \n\t"
|
||||
// walk and chew gum at the same time
|
||||
"adc %0, r1 \n\t"
|
||||
#else
|
||||
/* Multiply 8-bit i * 8-bit scale, giving 16-bit r1,r0 */
|
||||
"mul %0, %1 \n\t"
|
||||
/* Move the high 8-bits of the product (r1) back to i */
|
||||
"mov %0, r1 \n\t"
|
||||
#endif
|
||||
/* R1 IS LEFT DIRTY HERE; YOU MUST ZERO IT OUT YOURSELF */
|
||||
/* "clr __zero_reg__ \n\t" */
|
||||
|
||||
: "+a" (i) /* writes to i */
|
||||
: "a" (scale) /* uses scale */
|
||||
: "r0", "r1" /* clobbers r0, r1 */ );
|
||||
#else
|
||||
#error "No implementation for nscale8_LEAVING_R1_DIRTY available."
|
||||
#endif
|
||||
}
|
||||
|
||||
|
||||
/// This version of scale8_video does not clean up the R1 register on AVR
|
||||
/// If you are doing several 'scale8_video's in a row, use this, and
|
||||
/// then explicitly call cleanup_R1.
|
||||
LIB8STATIC_ALWAYS_INLINE uint8_t scale8_video_LEAVING_R1_DIRTY( uint8_t i, fract8 scale)
|
||||
{
|
||||
#if SCALE8_C == 1 || defined(LIB8_ATTINY)
|
||||
uint8_t j = (((int)i * (int)scale) >> 8) + ((i&&scale)?1:0);
|
||||
// uint8_t nonzeroscale = (scale != 0) ? 1 : 0;
|
||||
// uint8_t j = (i == 0) ? 0 : (((int)i * (int)(scale) ) >> 8) + nonzeroscale;
|
||||
return j;
|
||||
#elif SCALE8_AVRASM == 1
|
||||
uint8_t j=0;
|
||||
asm volatile(
|
||||
" tst %[i]\n\t"
|
||||
" breq L_%=\n\t"
|
||||
" mul %[i], %[scale]\n\t"
|
||||
" mov %[j], r1\n\t"
|
||||
" breq L_%=\n\t"
|
||||
" subi %[j], 0xFF\n\t"
|
||||
"L_%=: \n\t"
|
||||
: [j] "+a" (j)
|
||||
: [i] "a" (i), [scale] "a" (scale)
|
||||
: "r0", "r1");
|
||||
|
||||
return j;
|
||||
// uint8_t nonzeroscale = (scale != 0) ? 1 : 0;
|
||||
// asm volatile(
|
||||
// " tst %0 \n"
|
||||
// " breq L_%= \n"
|
||||
// " mul %0, %1 \n"
|
||||
// " mov %0, r1 \n"
|
||||
// " add %0, %2 \n"
|
||||
// " clr __zero_reg__ \n"
|
||||
// "L_%=: \n"
|
||||
|
||||
// : "+a" (i)
|
||||
// : "a" (scale), "a" (nonzeroscale)
|
||||
// : "r0", "r1");
|
||||
|
||||
// // Return the result
|
||||
// return i;
|
||||
#else
|
||||
#error "No implementation for scale8_video_LEAVING_R1_DIRTY available."
|
||||
#endif
|
||||
}
|
||||
|
||||
/// In place modifying version of scale8_video, also this version of nscale8_video
|
||||
/// does not clean up the R1 register on AVR
|
||||
/// If you are doing several 'scale8_video's in a row, use this, and
|
||||
/// then explicitly call cleanup_R1.
|
||||
LIB8STATIC_ALWAYS_INLINE void nscale8_video_LEAVING_R1_DIRTY( uint8_t & i, fract8 scale)
|
||||
{
|
||||
#if SCALE8_C == 1 || defined(LIB8_ATTINY)
|
||||
i = (((int)i * (int)scale) >> 8) + ((i&&scale)?1:0);
|
||||
#elif SCALE8_AVRASM == 1
|
||||
asm volatile(
|
||||
" tst %[i]\n\t"
|
||||
" breq L_%=\n\t"
|
||||
" mul %[i], %[scale]\n\t"
|
||||
" mov %[i], r1\n\t"
|
||||
" breq L_%=\n\t"
|
||||
" subi %[i], 0xFF\n\t"
|
||||
"L_%=: \n\t"
|
||||
: [i] "+a" (i)
|
||||
: [scale] "a" (scale)
|
||||
: "r0", "r1");
|
||||
#else
|
||||
#error "No implementation for scale8_video_LEAVING_R1_DIRTY available."
|
||||
#endif
|
||||
}
|
||||
|
||||
/// Clean up the r1 register after a series of *LEAVING_R1_DIRTY calls
|
||||
LIB8STATIC_ALWAYS_INLINE void cleanup_R1()
|
||||
{
|
||||
#if CLEANUP_R1_AVRASM == 1
|
||||
// Restore r1 to "0"; it's expected to always be that
|
||||
asm volatile( "clr __zero_reg__ \n\t" : : : "r1" );
|
||||
#endif
|
||||
}
|
||||
|
||||
|
||||
/// scale three one byte values by a fourth one, which is treated as
|
||||
/// the numerator of a fraction whose demominator is 256
|
||||
/// In other words, it computes r,g,b * (scale / 256)
|
||||
///
|
||||
/// THIS FUNCTION ALWAYS MODIFIES ITS ARGUMENTS IN PLACE
|
||||
|
||||
LIB8STATIC void nscale8x3( uint8_t& r, uint8_t& g, uint8_t& b, fract8 scale)
|
||||
{
|
||||
#if SCALE8_C == 1
|
||||
#if (FASTLED_SCALE8_FIXED == 1)
|
||||
uint16_t scale_fixed = scale + 1;
|
||||
r = (((uint16_t)r) * scale_fixed) >> 8;
|
||||
g = (((uint16_t)g) * scale_fixed) >> 8;
|
||||
b = (((uint16_t)b) * scale_fixed) >> 8;
|
||||
#else
|
||||
r = ((int)r * (int)(scale) ) >> 8;
|
||||
g = ((int)g * (int)(scale) ) >> 8;
|
||||
b = ((int)b * (int)(scale) ) >> 8;
|
||||
#endif
|
||||
#elif SCALE8_AVRASM == 1
|
||||
r = scale8_LEAVING_R1_DIRTY(r, scale);
|
||||
g = scale8_LEAVING_R1_DIRTY(g, scale);
|
||||
b = scale8_LEAVING_R1_DIRTY(b, scale);
|
||||
cleanup_R1();
|
||||
#else
|
||||
#error "No implementation for nscale8x3 available."
|
||||
#endif
|
||||
}
|
||||
|
||||
/// scale three one byte values by a fourth one, which is treated as
|
||||
/// the numerator of a fraction whose demominator is 256
|
||||
/// In other words, it computes r,g,b * (scale / 256), ensuring
|
||||
/// that non-zero values passed in remain non zero, no matter how low the scale
|
||||
/// argument.
|
||||
///
|
||||
/// THIS FUNCTION ALWAYS MODIFIES ITS ARGUMENTS IN PLACE
|
||||
LIB8STATIC void nscale8x3_video( uint8_t& r, uint8_t& g, uint8_t& b, fract8 scale)
|
||||
{
|
||||
#if SCALE8_C == 1
|
||||
uint8_t nonzeroscale = (scale != 0) ? 1 : 0;
|
||||
r = (r == 0) ? 0 : (((int)r * (int)(scale) ) >> 8) + nonzeroscale;
|
||||
g = (g == 0) ? 0 : (((int)g * (int)(scale) ) >> 8) + nonzeroscale;
|
||||
b = (b == 0) ? 0 : (((int)b * (int)(scale) ) >> 8) + nonzeroscale;
|
||||
#elif SCALE8_AVRASM == 1
|
||||
nscale8_video_LEAVING_R1_DIRTY( r, scale);
|
||||
nscale8_video_LEAVING_R1_DIRTY( g, scale);
|
||||
nscale8_video_LEAVING_R1_DIRTY( b, scale);
|
||||
cleanup_R1();
|
||||
#else
|
||||
#error "No implementation for nscale8x3 available."
|
||||
#endif
|
||||
}
|
||||
|
||||
/// scale two one byte values by a third one, which is treated as
|
||||
/// the numerator of a fraction whose demominator is 256
|
||||
/// In other words, it computes i,j * (scale / 256)
|
||||
///
|
||||
/// THIS FUNCTION ALWAYS MODIFIES ITS ARGUMENTS IN PLACE
|
||||
|
||||
LIB8STATIC void nscale8x2( uint8_t& i, uint8_t& j, fract8 scale)
|
||||
{
|
||||
#if SCALE8_C == 1
|
||||
#if FASTLED_SCALE8_FIXED == 1
|
||||
uint16_t scale_fixed = scale + 1;
|
||||
i = (((uint16_t)i) * scale_fixed ) >> 8;
|
||||
j = (((uint16_t)j) * scale_fixed ) >> 8;
|
||||
#else
|
||||
i = ((uint16_t)i * (uint16_t)(scale) ) >> 8;
|
||||
j = ((uint16_t)j * (uint16_t)(scale) ) >> 8;
|
||||
#endif
|
||||
#elif SCALE8_AVRASM == 1
|
||||
i = scale8_LEAVING_R1_DIRTY(i, scale);
|
||||
j = scale8_LEAVING_R1_DIRTY(j, scale);
|
||||
cleanup_R1();
|
||||
#else
|
||||
#error "No implementation for nscale8x2 available."
|
||||
#endif
|
||||
}
|
||||
|
||||
/// scale two one byte values by a third one, which is treated as
|
||||
/// the numerator of a fraction whose demominator is 256
|
||||
/// In other words, it computes i,j * (scale / 256), ensuring
|
||||
/// that non-zero values passed in remain non zero, no matter how low the scale
|
||||
/// argument.
|
||||
///
|
||||
/// THIS FUNCTION ALWAYS MODIFIES ITS ARGUMENTS IN PLACE
|
||||
|
||||
|
||||
LIB8STATIC void nscale8x2_video( uint8_t& i, uint8_t& j, fract8 scale)
|
||||
{
|
||||
#if SCALE8_C == 1
|
||||
uint8_t nonzeroscale = (scale != 0) ? 1 : 0;
|
||||
i = (i == 0) ? 0 : (((int)i * (int)(scale) ) >> 8) + nonzeroscale;
|
||||
j = (j == 0) ? 0 : (((int)j * (int)(scale) ) >> 8) + nonzeroscale;
|
||||
#elif SCALE8_AVRASM == 1
|
||||
nscale8_video_LEAVING_R1_DIRTY( i, scale);
|
||||
nscale8_video_LEAVING_R1_DIRTY( j, scale);
|
||||
cleanup_R1();
|
||||
#else
|
||||
#error "No implementation for nscale8x2 available."
|
||||
#endif
|
||||
}
|
||||
|
||||
|
||||
/// scale a 16-bit unsigned value by an 8-bit value,
|
||||
/// considered as numerator of a fraction whose denominator
|
||||
/// is 256. In other words, it computes i * (scale / 256)
|
||||
|
||||
LIB8STATIC_ALWAYS_INLINE uint16_t scale16by8( uint16_t i, fract8 scale )
|
||||
{
|
||||
#if SCALE16BY8_C == 1
|
||||
uint16_t result;
|
||||
#if FASTLED_SCALE8_FIXED == 1
|
||||
result = (i * (1+((uint16_t)scale))) >> 8;
|
||||
#else
|
||||
result = (i * scale) / 256;
|
||||
#endif
|
||||
return result;
|
||||
#elif SCALE16BY8_AVRASM == 1
|
||||
#if FASTLED_SCALE8_FIXED == 1
|
||||
uint16_t result = 0;
|
||||
asm volatile(
|
||||
// result.A = HighByte( (i.A x scale) + i.A )
|
||||
" mul %A[i], %[scale] \n\t"
|
||||
" add r0, %A[i] \n\t"
|
||||
// " adc r1, [zero] \n\t"
|
||||
// " mov %A[result], r1 \n\t"
|
||||
" adc %A[result], r1 \n\t"
|
||||
|
||||
// result.A-B += i.B x scale
|
||||
" mul %B[i], %[scale] \n\t"
|
||||
" add %A[result], r0 \n\t"
|
||||
" adc %B[result], r1 \n\t"
|
||||
|
||||
// cleanup r1
|
||||
" clr __zero_reg__ \n\t"
|
||||
|
||||
// result.A-B += i.B
|
||||
" add %A[result], %B[i] \n\t"
|
||||
" adc %B[result], __zero_reg__ \n\t"
|
||||
|
||||
: [result] "+r" (result)
|
||||
: [i] "r" (i), [scale] "r" (scale)
|
||||
: "r0", "r1"
|
||||
);
|
||||
return result;
|
||||
#else
|
||||
uint16_t result = 0;
|
||||
asm volatile(
|
||||
// result.A = HighByte(i.A x j )
|
||||
" mul %A[i], %[scale] \n\t"
|
||||
" mov %A[result], r1 \n\t"
|
||||
//" clr %B[result] \n\t"
|
||||
|
||||
// result.A-B += i.B x j
|
||||
" mul %B[i], %[scale] \n\t"
|
||||
" add %A[result], r0 \n\t"
|
||||
" adc %B[result], r1 \n\t"
|
||||
|
||||
// cleanup r1
|
||||
" clr __zero_reg__ \n\t"
|
||||
|
||||
: [result] "+r" (result)
|
||||
: [i] "r" (i), [scale] "r" (scale)
|
||||
: "r0", "r1"
|
||||
);
|
||||
return result;
|
||||
#endif
|
||||
#else
|
||||
#error "No implementation for scale16by8 available."
|
||||
#endif
|
||||
}
|
||||
|
||||
/// scale a 16-bit unsigned value by a 16-bit value,
|
||||
/// considered as numerator of a fraction whose denominator
|
||||
/// is 65536. In other words, it computes i * (scale / 65536)
|
||||
|
||||
LIB8STATIC uint16_t scale16( uint16_t i, fract16 scale )
|
||||
{
|
||||
#if SCALE16_C == 1
|
||||
uint16_t result;
|
||||
#if FASTLED_SCALE8_FIXED == 1
|
||||
result = ((uint32_t)(i) * (1+(uint32_t)(scale))) / 65536;
|
||||
#else
|
||||
result = ((uint32_t)(i) * (uint32_t)(scale)) / 65536;
|
||||
#endif
|
||||
return result;
|
||||
#elif SCALE16_AVRASM == 1
|
||||
#if FASTLED_SCALE8_FIXED == 1
|
||||
// implemented sort of like
|
||||
// result = ((i * scale) + i ) / 65536
|
||||
//
|
||||
// why not like this, you may ask?
|
||||
// result = (i * (scale+1)) / 65536
|
||||
// the answer is that if scale is 65535, then scale+1
|
||||
// will be zero, which is not what we want.
|
||||
uint32_t result;
|
||||
asm volatile(
|
||||
// result.A-B = i.A x scale.A
|
||||
" mul %A[i], %A[scale] \n\t"
|
||||
// save results...
|
||||
// basic idea:
|
||||
//" mov %A[result], r0 \n\t"
|
||||
//" mov %B[result], r1 \n\t"
|
||||
// which can be written as...
|
||||
" movw %A[result], r0 \n\t"
|
||||
// Because we're going to add i.A-B to
|
||||
// result.A-D, we DO need to keep both
|
||||
// the r0 and r1 portions of the product
|
||||
// UNlike in the 'unfixed scale8' version.
|
||||
// So the movw here is needed.
|
||||
: [result] "=r" (result)
|
||||
: [i] "r" (i),
|
||||
[scale] "r" (scale)
|
||||
: "r0", "r1"
|
||||
);
|
||||
|
||||
asm volatile(
|
||||
// result.C-D = i.B x scale.B
|
||||
" mul %B[i], %B[scale] \n\t"
|
||||
//" mov %C[result], r0 \n\t"
|
||||
//" mov %D[result], r1 \n\t"
|
||||
" movw %C[result], r0 \n\t"
|
||||
: [result] "+r" (result)
|
||||
: [i] "r" (i),
|
||||
[scale] "r" (scale)
|
||||
: "r0", "r1"
|
||||
);
|
||||
|
||||
const uint8_t zero = 0;
|
||||
asm volatile(
|
||||
// result.B-D += i.B x scale.A
|
||||
" mul %B[i], %A[scale] \n\t"
|
||||
|
||||
" add %B[result], r0 \n\t"
|
||||
" adc %C[result], r1 \n\t"
|
||||
" adc %D[result], %[zero] \n\t"
|
||||
|
||||
// result.B-D += i.A x scale.B
|
||||
" mul %A[i], %B[scale] \n\t"
|
||||
|
||||
" add %B[result], r0 \n\t"
|
||||
" adc %C[result], r1 \n\t"
|
||||
" adc %D[result], %[zero] \n\t"
|
||||
|
||||
// cleanup r1
|
||||
" clr r1 \n\t"
|
||||
|
||||
: [result] "+r" (result)
|
||||
: [i] "r" (i),
|
||||
[scale] "r" (scale),
|
||||
[zero] "r" (zero)
|
||||
: "r0", "r1"
|
||||
);
|
||||
|
||||
asm volatile(
|
||||
// result.A-D += i.A-B
|
||||
" add %A[result], %A[i] \n\t"
|
||||
" adc %B[result], %B[i] \n\t"
|
||||
" adc %C[result], %[zero] \n\t"
|
||||
" adc %D[result], %[zero] \n\t"
|
||||
: [result] "+r" (result)
|
||||
: [i] "r" (i),
|
||||
[zero] "r" (zero)
|
||||
);
|
||||
|
||||
result = result >> 16;
|
||||
return result;
|
||||
#else
|
||||
uint32_t result;
|
||||
asm volatile(
|
||||
// result.A-B = i.A x scale.A
|
||||
" mul %A[i], %A[scale] \n\t"
|
||||
// save results...
|
||||
// basic idea:
|
||||
//" mov %A[result], r0 \n\t"
|
||||
//" mov %B[result], r1 \n\t"
|
||||
// which can be written as...
|
||||
" movw %A[result], r0 \n\t"
|
||||
// We actually don't need to do anything with r0,
|
||||
// as result.A is never used again here, so we
|
||||
// could just move the high byte, but movw is
|
||||
// one clock cycle, just like mov, so might as
|
||||
// well, in case we want to use this code for
|
||||
// a generic 16x16 multiply somewhere.
|
||||
|
||||
: [result] "=r" (result)
|
||||
: [i] "r" (i),
|
||||
[scale] "r" (scale)
|
||||
: "r0", "r1"
|
||||
);
|
||||
|
||||
asm volatile(
|
||||
// result.C-D = i.B x scale.B
|
||||
" mul %B[i], %B[scale] \n\t"
|
||||
//" mov %C[result], r0 \n\t"
|
||||
//" mov %D[result], r1 \n\t"
|
||||
" movw %C[result], r0 \n\t"
|
||||
: [result] "+r" (result)
|
||||
: [i] "r" (i),
|
||||
[scale] "r" (scale)
|
||||
: "r0", "r1"
|
||||
);
|
||||
|
||||
const uint8_t zero = 0;
|
||||
asm volatile(
|
||||
// result.B-D += i.B x scale.A
|
||||
" mul %B[i], %A[scale] \n\t"
|
||||
|
||||
" add %B[result], r0 \n\t"
|
||||
" adc %C[result], r1 \n\t"
|
||||
" adc %D[result], %[zero] \n\t"
|
||||
|
||||
// result.B-D += i.A x scale.B
|
||||
" mul %A[i], %B[scale] \n\t"
|
||||
|
||||
" add %B[result], r0 \n\t"
|
||||
" adc %C[result], r1 \n\t"
|
||||
" adc %D[result], %[zero] \n\t"
|
||||
|
||||
// cleanup r1
|
||||
" clr r1 \n\t"
|
||||
|
||||
: [result] "+r" (result)
|
||||
: [i] "r" (i),
|
||||
[scale] "r" (scale),
|
||||
[zero] "r" (zero)
|
||||
: "r0", "r1"
|
||||
);
|
||||
|
||||
result = result >> 16;
|
||||
return result;
|
||||
#endif
|
||||
#else
|
||||
#error "No implementation for scale16 available."
|
||||
#endif
|
||||
}
|
||||
///@}
|
||||
|
||||
///@defgroup Dimming Dimming and brightening functions
|
||||
///
|
||||
/// Dimming and brightening functions
|
||||
///
|
||||
/// The eye does not respond in a linear way to light.
|
||||
/// High speed PWM'd LEDs at 50% duty cycle appear far
|
||||
/// brighter then the 'half as bright' you might expect.
|
||||
///
|
||||
/// If you want your midpoint brightness leve (128) to
|
||||
/// appear half as bright as 'full' brightness (255), you
|
||||
/// have to apply a 'dimming function'.
|
||||
///@{
|
||||
|
||||
/// Adjust a scaling value for dimming
|
||||
LIB8STATIC uint8_t dim8_raw( uint8_t x)
|
||||
{
|
||||
return scale8( x, x);
|
||||
}
|
||||
|
||||
/// Adjust a scaling value for dimming for video (value will never go below 1)
|
||||
LIB8STATIC uint8_t dim8_video( uint8_t x)
|
||||
{
|
||||
return scale8_video( x, x);
|
||||
}
|
||||
|
||||
/// Linear version of the dimming function that halves for values < 128
|
||||
LIB8STATIC uint8_t dim8_lin( uint8_t x )
|
||||
{
|
||||
if( x & 0x80 ) {
|
||||
x = scale8( x, x);
|
||||
} else {
|
||||
x += 1;
|
||||
x /= 2;
|
||||
}
|
||||
return x;
|
||||
}
|
||||
|
||||
/// inverse of the dimming function, brighten a value
|
||||
LIB8STATIC uint8_t brighten8_raw( uint8_t x)
|
||||
{
|
||||
uint8_t ix = 255 - x;
|
||||
return 255 - scale8( ix, ix);
|
||||
}
|
||||
|
||||
/// inverse of the dimming function, brighten a value
|
||||
LIB8STATIC uint8_t brighten8_video( uint8_t x)
|
||||
{
|
||||
uint8_t ix = 255 - x;
|
||||
return 255 - scale8_video( ix, ix);
|
||||
}
|
||||
|
||||
/// inverse of the dimming function, brighten a value
|
||||
LIB8STATIC uint8_t brighten8_lin( uint8_t x )
|
||||
{
|
||||
uint8_t ix = 255 - x;
|
||||
if( ix & 0x80 ) {
|
||||
ix = scale8( ix, ix);
|
||||
} else {
|
||||
ix += 1;
|
||||
ix /= 2;
|
||||
}
|
||||
return 255 - ix;
|
||||
}
|
||||
|
||||
///@}
|
||||
#endif
|
||||
259
components/FastLED-idf/lib8tion/trig8.h
Normal file
259
components/FastLED-idf/lib8tion/trig8.h
Normal file
@ -0,0 +1,259 @@
|
||||
#ifndef __INC_LIB8TION_TRIG_H
|
||||
#define __INC_LIB8TION_TRIG_H
|
||||
|
||||
///@ingroup lib8tion
|
||||
|
||||
///@defgroup Trig Fast trig functions
|
||||
/// Fast 8 and 16-bit approximations of sin(x) and cos(x).
|
||||
/// Don't use these approximations for calculating the
|
||||
/// trajectory of a rocket to Mars, but they're great
|
||||
/// for art projects and LED displays.
|
||||
///
|
||||
/// On Arduino/AVR, the 16-bit approximation is more than
|
||||
/// 10X faster than floating point sin(x) and cos(x), while
|
||||
/// the 8-bit approximation is more than 20X faster.
|
||||
///@{
|
||||
|
||||
#if defined(__AVR__)
|
||||
#define sin16 sin16_avr
|
||||
#else
|
||||
#define sin16 sin16_C
|
||||
#endif
|
||||
|
||||
/// Fast 16-bit approximation of sin(x). This approximation never varies more than
|
||||
/// 0.69% from the floating point value you'd get by doing
|
||||
///
|
||||
/// float s = sin(x) * 32767.0;
|
||||
///
|
||||
/// @param theta input angle from 0-65535
|
||||
/// @returns sin of theta, value between -32767 to 32767.
|
||||
LIB8STATIC int16_t sin16_avr( uint16_t theta )
|
||||
{
|
||||
static const uint8_t data[] =
|
||||
{ 0, 0, 49, 0, 6393%256, 6393/256, 48, 0,
|
||||
12539%256, 12539/256, 44, 0, 18204%256, 18204/256, 38, 0,
|
||||
23170%256, 23170/256, 31, 0, 27245%256, 27245/256, 23, 0,
|
||||
30273%256, 30273/256, 14, 0, 32137%256, 32137/256, 4 /*,0*/ };
|
||||
|
||||
uint16_t offset = (theta & 0x3FFF);
|
||||
|
||||
// AVR doesn't have a multi-bit shift instruction,
|
||||
// so if we say "offset >>= 3", gcc makes a tiny loop.
|
||||
// Inserting empty volatile statements between each
|
||||
// bit shift forces gcc to unroll the loop.
|
||||
offset >>= 1; // 0..8191
|
||||
asm volatile("");
|
||||
offset >>= 1; // 0..4095
|
||||
asm volatile("");
|
||||
offset >>= 1; // 0..2047
|
||||
|
||||
if( theta & 0x4000 ) offset = 2047 - offset;
|
||||
|
||||
uint8_t sectionX4;
|
||||
sectionX4 = offset / 256;
|
||||
sectionX4 *= 4;
|
||||
|
||||
uint8_t m;
|
||||
|
||||
union {
|
||||
uint16_t b;
|
||||
struct {
|
||||
uint8_t blo;
|
||||
uint8_t bhi;
|
||||
};
|
||||
} u;
|
||||
|
||||
//in effect u.b = blo + (256 * bhi);
|
||||
u.blo = data[ sectionX4 ];
|
||||
u.bhi = data[ sectionX4 + 1];
|
||||
m = data[ sectionX4 + 2];
|
||||
|
||||
uint8_t secoffset8 = (uint8_t)(offset) / 2;
|
||||
|
||||
uint16_t mx = m * secoffset8;
|
||||
|
||||
int16_t y = mx + u.b;
|
||||
if( theta & 0x8000 ) y = -y;
|
||||
|
||||
return y;
|
||||
}
|
||||
|
||||
/// Fast 16-bit approximation of sin(x). This approximation never varies more than
|
||||
/// 0.69% from the floating point value you'd get by doing
|
||||
///
|
||||
/// float s = sin(x) * 32767.0;
|
||||
///
|
||||
/// @param theta input angle from 0-65535
|
||||
/// @returns sin of theta, value between -32767 to 32767.
|
||||
LIB8STATIC int16_t sin16_C( uint16_t theta )
|
||||
{
|
||||
static const uint16_t base[] =
|
||||
{ 0, 6393, 12539, 18204, 23170, 27245, 30273, 32137 };
|
||||
static const uint8_t slope[] =
|
||||
{ 49, 48, 44, 38, 31, 23, 14, 4 };
|
||||
|
||||
uint16_t offset = (theta & 0x3FFF) >> 3; // 0..2047
|
||||
if( theta & 0x4000 ) offset = 2047 - offset;
|
||||
|
||||
uint8_t section = offset / 256; // 0..7
|
||||
uint16_t b = base[section];
|
||||
uint8_t m = slope[section];
|
||||
|
||||
uint8_t secoffset8 = (uint8_t)(offset) / 2;
|
||||
|
||||
uint16_t mx = m * secoffset8;
|
||||
int16_t y = mx + b;
|
||||
|
||||
if( theta & 0x8000 ) y = -y;
|
||||
|
||||
return y;
|
||||
}
|
||||
|
||||
|
||||
/// Fast 16-bit approximation of cos(x). This approximation never varies more than
|
||||
/// 0.69% from the floating point value you'd get by doing
|
||||
///
|
||||
/// float s = cos(x) * 32767.0;
|
||||
///
|
||||
/// @param theta input angle from 0-65535
|
||||
/// @returns sin of theta, value between -32767 to 32767.
|
||||
LIB8STATIC int16_t cos16( uint16_t theta)
|
||||
{
|
||||
return sin16( theta + 16384);
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////////////
|
||||
|
||||
// sin8 & cos8
|
||||
// Fast 8-bit approximations of sin(x) & cos(x).
|
||||
// Input angle is an unsigned int from 0-255.
|
||||
// Output is an unsigned int from 0 to 255.
|
||||
//
|
||||
// This approximation can vary to to 2%
|
||||
// from the floating point value you'd get by doing
|
||||
// float s = (sin( x ) * 128.0) + 128;
|
||||
//
|
||||
// Don't use this approximation for calculating the
|
||||
// "real" trigonometric calculations, but it's great
|
||||
// for art projects and LED displays.
|
||||
//
|
||||
// On Arduino/AVR, this approximation is more than
|
||||
// 20X faster than floating point sin(x) and cos(x)
|
||||
|
||||
#if defined(__AVR__) && !defined(LIB8_ATTINY)
|
||||
#define sin8 sin8_avr
|
||||
#else
|
||||
#define sin8 sin8_C
|
||||
#endif
|
||||
|
||||
|
||||
const uint8_t b_m16_interleave[] = { 0, 49, 49, 41, 90, 27, 117, 10 };
|
||||
|
||||
/// Fast 8-bit approximation of sin(x). This approximation never varies more than
|
||||
/// 2% from the floating point value you'd get by doing
|
||||
///
|
||||
/// float s = (sin(x) * 128.0) + 128;
|
||||
///
|
||||
/// @param theta input angle from 0-255
|
||||
/// @returns sin of theta, value between 0 and 255
|
||||
LIB8STATIC uint8_t sin8_avr( uint8_t theta)
|
||||
{
|
||||
uint8_t offset = theta;
|
||||
|
||||
asm volatile(
|
||||
"sbrc %[theta],6 \n\t"
|
||||
"com %[offset] \n\t"
|
||||
: [theta] "+r" (theta), [offset] "+r" (offset)
|
||||
);
|
||||
|
||||
offset &= 0x3F; // 0..63
|
||||
|
||||
uint8_t secoffset = offset & 0x0F; // 0..15
|
||||
if( theta & 0x40) secoffset++;
|
||||
|
||||
uint8_t m16; uint8_t b;
|
||||
|
||||
uint8_t section = offset >> 4; // 0..3
|
||||
uint8_t s2 = section * 2;
|
||||
|
||||
const uint8_t* p = b_m16_interleave;
|
||||
p += s2;
|
||||
b = *p;
|
||||
p++;
|
||||
m16 = *p;
|
||||
|
||||
uint8_t mx;
|
||||
uint8_t xr1;
|
||||
asm volatile(
|
||||
"mul %[m16],%[secoffset] \n\t"
|
||||
"mov %[mx],r0 \n\t"
|
||||
"mov %[xr1],r1 \n\t"
|
||||
"eor r1, r1 \n\t"
|
||||
"swap %[mx] \n\t"
|
||||
"andi %[mx],0x0F \n\t"
|
||||
"swap %[xr1] \n\t"
|
||||
"andi %[xr1], 0xF0 \n\t"
|
||||
"or %[mx], %[xr1] \n\t"
|
||||
: [mx] "=d" (mx), [xr1] "=d" (xr1)
|
||||
: [m16] "d" (m16), [secoffset] "d" (secoffset)
|
||||
);
|
||||
|
||||
int8_t y = mx + b;
|
||||
if( theta & 0x80 ) y = -y;
|
||||
|
||||
y += 128;
|
||||
|
||||
return y;
|
||||
}
|
||||
|
||||
|
||||
/// Fast 8-bit approximation of sin(x). This approximation never varies more than
|
||||
/// 2% from the floating point value you'd get by doing
|
||||
///
|
||||
/// float s = (sin(x) * 128.0) + 128;
|
||||
///
|
||||
/// @param theta input angle from 0-255
|
||||
/// @returns sin of theta, value between 0 and 255
|
||||
LIB8STATIC uint8_t sin8_C( uint8_t theta)
|
||||
{
|
||||
uint8_t offset = theta;
|
||||
if( theta & 0x40 ) {
|
||||
offset = (uint8_t)255 - offset;
|
||||
}
|
||||
offset &= 0x3F; // 0..63
|
||||
|
||||
uint8_t secoffset = offset & 0x0F; // 0..15
|
||||
if( theta & 0x40) secoffset++;
|
||||
|
||||
uint8_t section = offset >> 4; // 0..3
|
||||
uint8_t s2 = section * 2;
|
||||
const uint8_t* p = b_m16_interleave;
|
||||
p += s2;
|
||||
uint8_t b = *p;
|
||||
p++;
|
||||
uint8_t m16 = *p;
|
||||
|
||||
uint8_t mx = (m16 * secoffset) >> 4;
|
||||
|
||||
int8_t y = mx + b;
|
||||
if( theta & 0x80 ) y = -y;
|
||||
|
||||
y += 128;
|
||||
|
||||
return y;
|
||||
}
|
||||
|
||||
/// Fast 8-bit approximation of cos(x). This approximation never varies more than
|
||||
/// 2% from the floating point value you'd get by doing
|
||||
///
|
||||
/// float s = (cos(x) * 128.0) + 128;
|
||||
///
|
||||
/// @param theta input angle from 0-255
|
||||
/// @returns sin of theta, value between 0 and 255
|
||||
LIB8STATIC uint8_t cos8( uint8_t theta)
|
||||
{
|
||||
return sin8( theta + 64);
|
||||
}
|
||||
|
||||
///@}
|
||||
#endif
|
||||
55
components/FastLED-idf/library.json
Normal file
55
components/FastLED-idf/library.json
Normal file
@ -0,0 +1,55 @@
|
||||
{
|
||||
"name": "FastLED",
|
||||
"description": "FastLED is a library for programming addressable rgb led strips (APA102/Dotstar, WS2812/Neopixel, LPD8806, and a dozen others) acting both as a driver and as a library for color management and fast math.",
|
||||
"keywords": "led,noise,rgb,math,fast",
|
||||
"authors": [
|
||||
{
|
||||
"name": "Daniel Garcia",
|
||||
"url": "https://github.com/focalintent",
|
||||
"maintainer": true
|
||||
},
|
||||
{
|
||||
"name": "Mark Kriegsman",
|
||||
"url": "https://github.com/kriegsman",
|
||||
"maintainer": true
|
||||
},
|
||||
{
|
||||
"name": "Sam Guyer",
|
||||
"url": "https://github.com/samguyer",
|
||||
"maintainer": true
|
||||
},
|
||||
{
|
||||
"name": "Jason Coon",
|
||||
"url": "https://github.com/jasoncoon",
|
||||
"maintainer": true
|
||||
},
|
||||
{
|
||||
"name": "Josh Huber",
|
||||
"url": "https://github.com/uberjay",
|
||||
"maintainer": true
|
||||
}
|
||||
],
|
||||
"repository": {
|
||||
"type": "git",
|
||||
"url": "https://github.com/FastLED/FastLED.git"
|
||||
},
|
||||
"version": "3.3.3",
|
||||
"license": "MIT",
|
||||
"homepage": "http://fastled.io",
|
||||
"frameworks": "arduino",
|
||||
"platforms": "atmelavr, atmelsam, freescalekinetis, nordicnrf51, nxplpc, ststm32, teensy, espressif8266, espressif32, nordicnrf52",
|
||||
"export": {
|
||||
"exclude": [
|
||||
"docs",
|
||||
"extras"
|
||||
]
|
||||
},
|
||||
"build": {
|
||||
"srcFilter": [
|
||||
"+<*.c>",
|
||||
"+<*.cpp>",
|
||||
"+<*.h>"
|
||||
],
|
||||
"libArchive": false
|
||||
}
|
||||
}
|
||||
10
components/FastLED-idf/library.properties
Normal file
10
components/FastLED-idf/library.properties
Normal file
@ -0,0 +1,10 @@
|
||||
name=FastLED
|
||||
version=3.3.3
|
||||
author=Daniel Garcia
|
||||
maintainer=Daniel Garcia <dgarcia@fastled.io>
|
||||
sentence=Multi-platform library for controlling dozens of different types of LEDs along with optimized math, effect, and noise functions.
|
||||
paragraph=Multi-platform library for controlling dozens of different types of LEDs along with optimized math, effect, and noise functions.
|
||||
category=Display
|
||||
url=https://github.com/FastLED/FastLED
|
||||
architectures=*
|
||||
includes=FastLED.h
|
||||
807
components/FastLED-idf/noise.cpp
Normal file
807
components/FastLED-idf/noise.cpp
Normal file
@ -0,0 +1,807 @@
|
||||
#define FASTLED_INTERNAL
|
||||
#include "FastLED.h"
|
||||
#include <string.h>
|
||||
|
||||
FASTLED_NAMESPACE_BEGIN
|
||||
|
||||
#define P(x) FL_PGM_READ_BYTE_NEAR(p + x)
|
||||
|
||||
FL_PROGMEM static uint8_t const p[] = { 151,160,137,91,90,15,
|
||||
131,13,201,95,96,53,194,233,7,225,140,36,103,30,69,142,8,99,37,240,21,10,23,
|
||||
190, 6,148,247,120,234,75,0,26,197,62,94,252,219,203,117,35,11,32,57,177,33,
|
||||
88,237,149,56,87,174,20,125,136,171,168, 68,175,74,165,71,134,139,48,27,166,
|
||||
77,146,158,231,83,111,229,122,60,211,133,230,220,105,92,41,55,46,245,40,244,
|
||||
102,143,54, 65,25,63,161, 1,216,80,73,209,76,132,187,208, 89,18,169,200,196,
|
||||
135,130,116,188,159,86,164,100,109,198,173,186, 3,64,52,217,226,250,124,123,
|
||||
5,202,38,147,118,126,255,82,85,212,207,206,59,227,47,16,58,17,182,189,28,42,
|
||||
223,183,170,213,119,248,152, 2,44,154,163, 70,221,153,101,155,167, 43,172,9,
|
||||
129,22,39,253, 19,98,108,110,79,113,224,232,178,185, 112,104,218,246,97,228,
|
||||
251,34,242,193,238,210,144,12,191,179,162,241, 81,51,145,235,249,14,239,107,
|
||||
49,192,214, 31,181,199,106,157,184, 84,204,176,115,121,50,45,127, 4,150,254,
|
||||
138,236,205,93,222,114,67,29,24,72,243,141,128,195,78,66,215,61,156,180,151
|
||||
};
|
||||
|
||||
|
||||
#if FASTLED_NOISE_ALLOW_AVERAGE_TO_OVERFLOW == 1
|
||||
#define AVG15(U,V) (((U)+(V)) >> 1)
|
||||
#else
|
||||
// See if we should use the inlined avg15 for AVR with MUL instruction
|
||||
#if defined(__AVR__) && (LIB8_ATTINY == 0)
|
||||
#define AVG15(U,V) (avg15_inline_avr_mul((U),(V)))
|
||||
// inlined copy of avg15 for AVR with MUL instruction; cloned from math8.h
|
||||
// Forcing this inline in the 3-D 16bit noise produces a 12% speedup overall,
|
||||
// at a cost of just +8 bytes of net code size.
|
||||
static int16_t inline __attribute__((always_inline)) avg15_inline_avr_mul( int16_t i, int16_t j)
|
||||
{
|
||||
asm volatile(
|
||||
/* first divide j by 2, throwing away lowest bit */
|
||||
"asr %B[j] \n\t"
|
||||
"ror %A[j] \n\t"
|
||||
/* now divide i by 2, with lowest bit going into C */
|
||||
"asr %B[i] \n\t"
|
||||
"ror %A[i] \n\t"
|
||||
/* add j + C to i */
|
||||
"adc %A[i], %A[j] \n\t"
|
||||
"adc %B[i], %B[j] \n\t"
|
||||
: [i] "+a" (i)
|
||||
: [j] "a" (j) );
|
||||
return i;
|
||||
}
|
||||
#else
|
||||
#define AVG15(U,V) (avg15((U),(V)))
|
||||
#endif
|
||||
#endif
|
||||
|
||||
// See fastled_config.h for notes on this;
|
||||
// "#define FASTLED_NOISE_FIXED 1" is the correct value
|
||||
#if FASTLED_NOISE_FIXED == 0
|
||||
#define EASE8(x) (FADE(x) )
|
||||
#define EASE16(x) (FADE(x) )
|
||||
#else
|
||||
#define EASE8(x) (ease8InOutQuad(x) )
|
||||
#define EASE16(x) (ease16InOutQuad(x))
|
||||
#endif
|
||||
//
|
||||
// #define FADE_12
|
||||
#define FADE_16
|
||||
|
||||
#ifdef FADE_12
|
||||
#define FADE logfade12
|
||||
#define LERP(a,b,u) lerp15by12(a,b,u)
|
||||
#else
|
||||
#define FADE(x) scale16(x,x)
|
||||
#define LERP(a,b,u) lerp15by16(a,b,u)
|
||||
#endif
|
||||
static int16_t inline __attribute__((always_inline)) grad16(uint8_t hash, int16_t x, int16_t y, int16_t z) {
|
||||
#if 0
|
||||
switch(hash & 0xF) {
|
||||
case 0: return (( x) + ( y))>>1;
|
||||
case 1: return ((-x) + ( y))>>1;
|
||||
case 2: return (( x) + (-y))>>1;
|
||||
case 3: return ((-x) + (-y))>>1;
|
||||
case 4: return (( x) + ( z))>>1;
|
||||
case 5: return ((-x) + ( z))>>1;
|
||||
case 6: return (( x) + (-z))>>1;
|
||||
case 7: return ((-x) + (-z))>>1;
|
||||
case 8: return (( y) + ( z))>>1;
|
||||
case 9: return ((-y) + ( z))>>1;
|
||||
case 10: return (( y) + (-z))>>1;
|
||||
case 11: return ((-y) + (-z))>>1;
|
||||
case 12: return (( y) + ( x))>>1;
|
||||
case 13: return ((-y) + ( z))>>1;
|
||||
case 14: return (( y) + (-x))>>1;
|
||||
case 15: return ((-y) + (-z))>>1;
|
||||
}
|
||||
#else
|
||||
hash = hash&15;
|
||||
int16_t u = hash<8?x:y;
|
||||
int16_t v = hash<4?y:hash==12||hash==14?x:z;
|
||||
if(hash&1) { u = -u; }
|
||||
if(hash&2) { v = -v; }
|
||||
|
||||
return AVG15(u,v);
|
||||
#endif
|
||||
}
|
||||
|
||||
static int16_t inline __attribute__((always_inline)) grad16(uint8_t hash, int16_t x, int16_t y) {
|
||||
hash = hash & 7;
|
||||
int16_t u,v;
|
||||
if(hash < 4) { u = x; v = y; } else { u = y; v = x; }
|
||||
if(hash&1) { u = -u; }
|
||||
if(hash&2) { v = -v; }
|
||||
|
||||
return AVG15(u,v);
|
||||
}
|
||||
|
||||
static int16_t inline __attribute__((always_inline)) grad16(uint8_t hash, int16_t x) {
|
||||
hash = hash & 15;
|
||||
int16_t u,v;
|
||||
if(hash > 8) { u=x;v=x; }
|
||||
else if(hash < 4) { u=x;v=1; }
|
||||
else { u=1;v=x; }
|
||||
if(hash&1) { u = -u; }
|
||||
if(hash&2) { v = -v; }
|
||||
|
||||
return AVG15(u,v);
|
||||
}
|
||||
|
||||
// selectBasedOnHashBit performs this:
|
||||
// result = (hash & (1<<bitnumber)) ? a : b
|
||||
// but with an AVR asm version that's smaller and quicker than C
|
||||
// (and probably not worth including in lib8tion)
|
||||
static int8_t inline __attribute__((always_inline)) selectBasedOnHashBit(uint8_t hash, uint8_t bitnumber, int8_t a, int8_t b) {
|
||||
int8_t result;
|
||||
#if !defined(__AVR__)
|
||||
result = (hash & (1<<bitnumber)) ? a : b;
|
||||
#else
|
||||
asm volatile(
|
||||
"mov %[result],%[a] \n\t"
|
||||
"sbrs %[hash],%[bitnumber] \n\t"
|
||||
"mov %[result],%[b] \n\t"
|
||||
: [result] "=r" (result)
|
||||
: [hash] "r" (hash),
|
||||
[bitnumber] "M" (bitnumber),
|
||||
[a] "r" (a),
|
||||
[b] "r" (b)
|
||||
);
|
||||
#endif
|
||||
return result;
|
||||
}
|
||||
|
||||
static int8_t inline __attribute__((always_inline)) grad8(uint8_t hash, int8_t x, int8_t y, int8_t z) {
|
||||
#if 0
|
||||
switch(hash & 0xF) {
|
||||
case 0: return (( x) + ( y))>>1;
|
||||
case 1: return ((-x) + ( y))>>1;
|
||||
case 2: return (( x) + (-y))>>1;
|
||||
case 3: return ((-x) + (-y))>>1;
|
||||
case 4: return (( x) + ( z))>>1;
|
||||
case 5: return ((-x) + ( z))>>1;
|
||||
case 6: return (( x) + (-z))>>1;
|
||||
case 7: return ((-x) + (-z))>>1;
|
||||
case 8: return (( y) + ( z))>>1;
|
||||
case 9: return ((-y) + ( z))>>1;
|
||||
case 10: return (( y) + (-z))>>1;
|
||||
case 11: return ((-y) + (-z))>>1;
|
||||
case 12: return (( y) + ( x))>>1;
|
||||
case 13: return ((-y) + ( z))>>1;
|
||||
case 14: return (( y) + (-x))>>1;
|
||||
case 15: return ((-y) + (-z))>>1;
|
||||
}
|
||||
#else
|
||||
|
||||
hash &= 0xF;
|
||||
|
||||
int8_t u, v;
|
||||
//u = (hash&8)?y:x;
|
||||
u = selectBasedOnHashBit( hash, 3, y, x);
|
||||
|
||||
#if 1
|
||||
v = hash<4?y:hash==12||hash==14?x:z;
|
||||
#else
|
||||
// Verbose version for analysis; generates idenitical code.
|
||||
if( hash < 4) { // 00 01 02 03
|
||||
v = y;
|
||||
} else {
|
||||
if( hash==12 || hash==14) { // 0C 0E
|
||||
v = x;
|
||||
} else {
|
||||
v = z; // 04 05 06 07 08 09 0A 0B 0D 0F
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
if(hash&1) { u = -u; }
|
||||
if(hash&2) { v = -v; }
|
||||
|
||||
return avg7(u,v);
|
||||
#endif
|
||||
}
|
||||
|
||||
static int8_t inline __attribute__((always_inline)) grad8(uint8_t hash, int8_t x, int8_t y)
|
||||
{
|
||||
// since the tests below can be done bit-wise on the bottom
|
||||
// three bits, there's no need to mask off the higher bits
|
||||
// hash = hash & 7;
|
||||
|
||||
int8_t u,v;
|
||||
if( hash & 4) {
|
||||
u = y; v = x;
|
||||
} else {
|
||||
u = x; v = y;
|
||||
}
|
||||
|
||||
if(hash&1) { u = -u; }
|
||||
if(hash&2) { v = -v; }
|
||||
|
||||
return avg7(u,v);
|
||||
}
|
||||
|
||||
static int8_t inline __attribute__((always_inline)) grad8(uint8_t hash, int8_t x)
|
||||
{
|
||||
// since the tests below can be done bit-wise on the bottom
|
||||
// four bits, there's no need to mask off the higher bits
|
||||
// hash = hash & 15;
|
||||
|
||||
int8_t u,v;
|
||||
if(hash & 8) {
|
||||
u=x; v=x;
|
||||
} else {
|
||||
if(hash & 4) {
|
||||
u=1; v=x;
|
||||
} else {
|
||||
u=x; v=1;
|
||||
}
|
||||
}
|
||||
|
||||
if(hash&1) { u = -u; }
|
||||
if(hash&2) { v = -v; }
|
||||
|
||||
return avg7(u,v);
|
||||
}
|
||||
|
||||
|
||||
#ifdef FADE_12
|
||||
uint16_t logfade12(uint16_t val) {
|
||||
return scale16(val,val)>>4;
|
||||
}
|
||||
|
||||
static int16_t inline __attribute__((always_inline)) lerp15by12( int16_t a, int16_t b, fract16 frac)
|
||||
{
|
||||
//if(1) return (lerp(frac,a,b));
|
||||
int16_t result;
|
||||
if( b > a) {
|
||||
uint16_t delta = b - a;
|
||||
uint16_t scaled = scale16(delta,frac<<4);
|
||||
result = a + scaled;
|
||||
} else {
|
||||
uint16_t delta = a - b;
|
||||
uint16_t scaled = scale16(delta,frac<<4);
|
||||
result = a - scaled;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
#endif
|
||||
|
||||
static int8_t inline __attribute__((always_inline)) lerp7by8( int8_t a, int8_t b, fract8 frac)
|
||||
{
|
||||
// int8_t delta = b - a;
|
||||
// int16_t prod = (uint16_t)delta * (uint16_t)frac;
|
||||
// int8_t scaled = prod >> 8;
|
||||
// int8_t result = a + scaled;
|
||||
// return result;
|
||||
int8_t result;
|
||||
if( b > a) {
|
||||
uint8_t delta = b - a;
|
||||
uint8_t scaled = scale8( delta, frac);
|
||||
result = a + scaled;
|
||||
} else {
|
||||
uint8_t delta = a - b;
|
||||
uint8_t scaled = scale8( delta, frac);
|
||||
result = a - scaled;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
int16_t inoise16_raw(uint32_t x, uint32_t y, uint32_t z)
|
||||
{
|
||||
// Find the unit cube containing the point
|
||||
uint8_t X = (x>>16)&0xFF;
|
||||
uint8_t Y = (y>>16)&0xFF;
|
||||
uint8_t Z = (z>>16)&0xFF;
|
||||
|
||||
// Hash cube corner coordinates
|
||||
uint8_t A = P(X)+Y;
|
||||
uint8_t AA = P(A)+Z;
|
||||
uint8_t AB = P(A+1)+Z;
|
||||
uint8_t B = P(X+1)+Y;
|
||||
uint8_t BA = P(B) + Z;
|
||||
uint8_t BB = P(B+1)+Z;
|
||||
|
||||
// Get the relative position of the point in the cube
|
||||
uint16_t u = x & 0xFFFF;
|
||||
uint16_t v = y & 0xFFFF;
|
||||
uint16_t w = z & 0xFFFF;
|
||||
|
||||
// Get a signed version of the above for the grad function
|
||||
int16_t xx = (u >> 1) & 0x7FFF;
|
||||
int16_t yy = (v >> 1) & 0x7FFF;
|
||||
int16_t zz = (w >> 1) & 0x7FFF;
|
||||
uint16_t N = 0x8000L;
|
||||
|
||||
u = EASE16(u); v = EASE16(v); w = EASE16(w);
|
||||
|
||||
// skip the log fade adjustment for the moment, otherwise here we would
|
||||
// adjust fade values for u,v,w
|
||||
int16_t X1 = LERP(grad16(P(AA), xx, yy, zz), grad16(P(BA), xx - N, yy, zz), u);
|
||||
int16_t X2 = LERP(grad16(P(AB), xx, yy-N, zz), grad16(P(BB), xx - N, yy - N, zz), u);
|
||||
int16_t X3 = LERP(grad16(P(AA+1), xx, yy, zz-N), grad16(P(BA+1), xx - N, yy, zz-N), u);
|
||||
int16_t X4 = LERP(grad16(P(AB+1), xx, yy-N, zz-N), grad16(P(BB+1), xx - N, yy - N, zz - N), u);
|
||||
|
||||
int16_t Y1 = LERP(X1,X2,v);
|
||||
int16_t Y2 = LERP(X3,X4,v);
|
||||
|
||||
int16_t ans = LERP(Y1,Y2,w);
|
||||
|
||||
return ans;
|
||||
}
|
||||
|
||||
uint16_t inoise16(uint32_t x, uint32_t y, uint32_t z) {
|
||||
int32_t ans = inoise16_raw(x,y,z);
|
||||
ans = ans + 19052L;
|
||||
uint32_t pan = ans;
|
||||
// pan = (ans * 220L) >> 7. That's the same as:
|
||||
// pan = (ans * 440L) >> 8. And this way avoids a 7X four-byte shift-loop on AVR.
|
||||
// Identical math, except for the highest bit, which we don't care about anyway,
|
||||
// since we're returning the 'middle' 16 out of a 32-bit value anyway.
|
||||
pan *= 440L;
|
||||
return (pan>>8);
|
||||
|
||||
// // return scale16by8(pan,220)<<1;
|
||||
// return ((inoise16_raw(x,y,z)+19052)*220)>>7;
|
||||
// return scale16by8(inoise16_raw(x,y,z)+19052,220)<<1;
|
||||
}
|
||||
|
||||
int16_t inoise16_raw(uint32_t x, uint32_t y)
|
||||
{
|
||||
// Find the unit cube containing the point
|
||||
uint8_t X = x>>16;
|
||||
uint8_t Y = y>>16;
|
||||
|
||||
// Hash cube corner coordinates
|
||||
uint8_t A = P(X)+Y;
|
||||
uint8_t AA = P(A);
|
||||
uint8_t AB = P(A+1);
|
||||
uint8_t B = P(X+1)+Y;
|
||||
uint8_t BA = P(B);
|
||||
uint8_t BB = P(B+1);
|
||||
|
||||
// Get the relative position of the point in the cube
|
||||
uint16_t u = x & 0xFFFF;
|
||||
uint16_t v = y & 0xFFFF;
|
||||
|
||||
// Get a signed version of the above for the grad function
|
||||
int16_t xx = (u >> 1) & 0x7FFF;
|
||||
int16_t yy = (v >> 1) & 0x7FFF;
|
||||
uint16_t N = 0x8000L;
|
||||
|
||||
u = EASE16(u); v = EASE16(v);
|
||||
|
||||
int16_t X1 = LERP(grad16(P(AA), xx, yy), grad16(P(BA), xx - N, yy), u);
|
||||
int16_t X2 = LERP(grad16(P(AB), xx, yy-N), grad16(P(BB), xx - N, yy - N), u);
|
||||
|
||||
int16_t ans = LERP(X1,X2,v);
|
||||
|
||||
return ans;
|
||||
}
|
||||
|
||||
uint16_t inoise16(uint32_t x, uint32_t y) {
|
||||
int32_t ans = inoise16_raw(x,y);
|
||||
ans = ans + 17308L;
|
||||
uint32_t pan = ans;
|
||||
// pan = (ans * 242L) >> 7. That's the same as:
|
||||
// pan = (ans * 484L) >> 8. And this way avoids a 7X four-byte shift-loop on AVR.
|
||||
// Identical math, except for the highest bit, which we don't care about anyway,
|
||||
// since we're returning the 'middle' 16 out of a 32-bit value anyway.
|
||||
pan *= 484L;
|
||||
return (pan>>8);
|
||||
|
||||
// return (uint32_t)(((int32_t)inoise16_raw(x,y)+(uint32_t)17308)*242)>>7;
|
||||
// return scale16by8(inoise16_raw(x,y)+17308,242)<<1;
|
||||
}
|
||||
|
||||
int16_t inoise16_raw(uint32_t x)
|
||||
{
|
||||
// Find the unit cube containing the point
|
||||
uint8_t X = x>>16;
|
||||
|
||||
// Hash cube corner coordinates
|
||||
uint8_t A = P(X);
|
||||
uint8_t AA = P(A);
|
||||
uint8_t B = P(X+1);
|
||||
uint8_t BA = P(B);
|
||||
|
||||
// Get the relative position of the point in the cube
|
||||
uint16_t u = x & 0xFFFF;
|
||||
|
||||
// Get a signed version of the above for the grad function
|
||||
int16_t xx = (u >> 1) & 0x7FFF;
|
||||
uint16_t N = 0x8000L;
|
||||
|
||||
u = EASE16(u);
|
||||
|
||||
int16_t ans = LERP(grad16(P(AA), xx), grad16(P(BA), xx - N), u);
|
||||
|
||||
return ans;
|
||||
}
|
||||
|
||||
uint16_t inoise16(uint32_t x) {
|
||||
return ((uint32_t)((int32_t)inoise16_raw(x) + 17308L)) << 1;
|
||||
}
|
||||
|
||||
int8_t inoise8_raw(uint16_t x, uint16_t y, uint16_t z)
|
||||
{
|
||||
// Find the unit cube containing the point
|
||||
uint8_t X = x>>8;
|
||||
uint8_t Y = y>>8;
|
||||
uint8_t Z = z>>8;
|
||||
|
||||
// Hash cube corner coordinates
|
||||
uint8_t A = P(X)+Y;
|
||||
uint8_t AA = P(A)+Z;
|
||||
uint8_t AB = P(A+1)+Z;
|
||||
uint8_t B = P(X+1)+Y;
|
||||
uint8_t BA = P(B) + Z;
|
||||
uint8_t BB = P(B+1)+Z;
|
||||
|
||||
// Get the relative position of the point in the cube
|
||||
uint8_t u = x;
|
||||
uint8_t v = y;
|
||||
uint8_t w = z;
|
||||
|
||||
// Get a signed version of the above for the grad function
|
||||
int8_t xx = ((uint8_t)(x)>>1) & 0x7F;
|
||||
int8_t yy = ((uint8_t)(y)>>1) & 0x7F;
|
||||
int8_t zz = ((uint8_t)(z)>>1) & 0x7F;
|
||||
uint8_t N = 0x80;
|
||||
|
||||
u = EASE8(u); v = EASE8(v); w = EASE8(w);
|
||||
|
||||
int8_t X1 = lerp7by8(grad8(P(AA), xx, yy, zz), grad8(P(BA), xx - N, yy, zz), u);
|
||||
int8_t X2 = lerp7by8(grad8(P(AB), xx, yy-N, zz), grad8(P(BB), xx - N, yy - N, zz), u);
|
||||
int8_t X3 = lerp7by8(grad8(P(AA+1), xx, yy, zz-N), grad8(P(BA+1), xx - N, yy, zz-N), u);
|
||||
int8_t X4 = lerp7by8(grad8(P(AB+1), xx, yy-N, zz-N), grad8(P(BB+1), xx - N, yy - N, zz - N), u);
|
||||
|
||||
int8_t Y1 = lerp7by8(X1,X2,v);
|
||||
int8_t Y2 = lerp7by8(X3,X4,v);
|
||||
|
||||
int8_t ans = lerp7by8(Y1,Y2,w);
|
||||
|
||||
return ans;
|
||||
}
|
||||
|
||||
uint8_t inoise8(uint16_t x, uint16_t y, uint16_t z) {
|
||||
// return scale8(76+(inoise8_raw(x,y,z)),215)<<1;
|
||||
int8_t n = inoise8_raw( x, y, z); // -64..+64
|
||||
n+= 64; // 0..128
|
||||
uint8_t ans = qadd8( n, n); // 0..255
|
||||
return ans;
|
||||
}
|
||||
|
||||
int8_t inoise8_raw(uint16_t x, uint16_t y)
|
||||
{
|
||||
// Find the unit cube containing the point
|
||||
uint8_t X = x>>8;
|
||||
uint8_t Y = y>>8;
|
||||
|
||||
// Hash cube corner coordinates
|
||||
uint8_t A = P(X)+Y;
|
||||
uint8_t AA = P(A);
|
||||
uint8_t AB = P(A+1);
|
||||
uint8_t B = P(X+1)+Y;
|
||||
uint8_t BA = P(B);
|
||||
uint8_t BB = P(B+1);
|
||||
|
||||
// Get the relative position of the point in the cube
|
||||
uint8_t u = x;
|
||||
uint8_t v = y;
|
||||
|
||||
// Get a signed version of the above for the grad function
|
||||
int8_t xx = ((uint8_t)(x)>>1) & 0x7F;
|
||||
int8_t yy = ((uint8_t)(y)>>1) & 0x7F;
|
||||
uint8_t N = 0x80;
|
||||
|
||||
u = EASE8(u); v = EASE8(v);
|
||||
|
||||
int8_t X1 = lerp7by8(grad8(P(AA), xx, yy), grad8(P(BA), xx - N, yy), u);
|
||||
int8_t X2 = lerp7by8(grad8(P(AB), xx, yy-N), grad8(P(BB), xx - N, yy - N), u);
|
||||
|
||||
int8_t ans = lerp7by8(X1,X2,v);
|
||||
|
||||
return ans;
|
||||
// return scale8((70+(ans)),234)<<1;
|
||||
}
|
||||
|
||||
|
||||
|
||||
uint8_t inoise8(uint16_t x, uint16_t y) {
|
||||
//return scale8(69+inoise8_raw(x,y),237)<<1;
|
||||
int8_t n = inoise8_raw( x, y); // -64..+64
|
||||
n+= 64; // 0..128
|
||||
uint8_t ans = qadd8( n, n); // 0..255
|
||||
return ans;
|
||||
}
|
||||
|
||||
// output range = -64 .. +64
|
||||
int8_t inoise8_raw(uint16_t x)
|
||||
{
|
||||
// Find the unit cube containing the point
|
||||
uint8_t X = x>>8;
|
||||
|
||||
// Hash cube corner coordinates
|
||||
uint8_t A = P(X);
|
||||
uint8_t AA = P(A);
|
||||
uint8_t B = P(X+1);
|
||||
uint8_t BA = P(B);
|
||||
|
||||
// Get the relative position of the point in the cube
|
||||
uint8_t u = x;
|
||||
|
||||
// Get a signed version of the above for the grad function
|
||||
int8_t xx = ((uint8_t)(x)>>1) & 0x7F;
|
||||
uint8_t N = 0x80;
|
||||
|
||||
u = EASE8( u);
|
||||
|
||||
int8_t ans = lerp7by8(grad8(P(AA), xx), grad8(P(BA), xx - N), u);
|
||||
|
||||
return ans;
|
||||
}
|
||||
|
||||
uint8_t inoise8(uint16_t x) {
|
||||
int8_t n = inoise8_raw(x); //-64..+64
|
||||
n += 64; // 0..128
|
||||
uint8_t ans = qadd8(n,n); // 0..255
|
||||
return ans;
|
||||
}
|
||||
|
||||
// struct q44 {
|
||||
// uint8_t i:4;
|
||||
// uint8_t f:4;
|
||||
// q44(uint8_t _i, uint8_t _f) {i=_i; f=_f; }
|
||||
// };
|
||||
|
||||
// uint32_t mul44(uint32_t v, q44 mulby44) {
|
||||
// return (v *mulby44.i) + ((v * mulby44.f) >> 4);
|
||||
// }
|
||||
//
|
||||
// uint16_t mul44_16(uint16_t v, q44 mulby44) {
|
||||
// return (v *mulby44.i) + ((v * mulby44.f) >> 4);
|
||||
// }
|
||||
|
||||
void fill_raw_noise8(uint8_t *pData, uint8_t num_points, uint8_t octaves, uint16_t x, int scale, uint16_t time) {
|
||||
uint32_t _xx = x;
|
||||
uint32_t scx = scale;
|
||||
for(int o = 0; o < octaves; o++) {
|
||||
for(int i = 0,xx=_xx; i < num_points; i++, xx+=scx) {
|
||||
pData[i] = qadd8(pData[i],inoise8(xx,time)>>o);
|
||||
}
|
||||
|
||||
_xx <<= 1;
|
||||
scx <<= 1;
|
||||
}
|
||||
}
|
||||
|
||||
void fill_raw_noise16into8(uint8_t *pData, uint8_t num_points, uint8_t octaves, uint32_t x, int scale, uint32_t time) {
|
||||
uint32_t _xx = x;
|
||||
uint32_t scx = scale;
|
||||
for(int o = 0; o < octaves; o++) {
|
||||
for(int i = 0,xx=_xx; i < num_points; i++, xx+=scx) {
|
||||
uint32_t accum = (inoise16(xx,time))>>o;
|
||||
accum += (pData[i]<<8);
|
||||
if(accum > 65535) { accum = 65535; }
|
||||
pData[i] = accum>>8;
|
||||
}
|
||||
|
||||
_xx <<= 1;
|
||||
scx <<= 1;
|
||||
}
|
||||
}
|
||||
|
||||
void fill_raw_2dnoise8(uint8_t *pData, int width, int height, uint8_t octaves, q44 freq44, fract8 amplitude, int skip, uint16_t x, int scalex, uint16_t y, int scaley, uint16_t time) {
|
||||
if(octaves > 1) {
|
||||
fill_raw_2dnoise8(pData, width, height, octaves-1, freq44, amplitude, skip+1, x*freq44, freq44 * scalex, y*freq44, freq44 * scaley, time);
|
||||
} else {
|
||||
// amplitude is always 255 on the lowest level
|
||||
amplitude=255;
|
||||
}
|
||||
|
||||
scalex *= skip;
|
||||
scaley *= skip;
|
||||
|
||||
fract8 invamp = 255-amplitude;
|
||||
uint16_t xx = x;
|
||||
for(int i = 0; i < height; i++, y+=scaley) {
|
||||
uint8_t *pRow = pData + (i*width);
|
||||
xx = x;
|
||||
for(int j = 0; j < width; j++, xx+=scalex) {
|
||||
uint8_t noise_base = inoise8(xx,y,time);
|
||||
noise_base = (0x80 & noise_base) ? (noise_base - 127) : (127 - noise_base);
|
||||
noise_base = scale8(noise_base<<1,amplitude);
|
||||
if(skip == 1) {
|
||||
pRow[j] = scale8(pRow[j],invamp) + noise_base;
|
||||
} else {
|
||||
for(int ii = i; ii<(i+skip) && ii<height; ii++) {
|
||||
uint8_t *pRow = pData + (ii*width);
|
||||
for(int jj=j; jj<(j+skip) && jj<width; jj++) {
|
||||
pRow[jj] = scale8(pRow[jj],invamp) + noise_base;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void fill_raw_2dnoise8(uint8_t *pData, int width, int height, uint8_t octaves, uint16_t x, int scalex, uint16_t y, int scaley, uint16_t time) {
|
||||
fill_raw_2dnoise8(pData, width, height, octaves, q44(2,0), 128, 1, x, scalex, y, scaley, time);
|
||||
}
|
||||
|
||||
void fill_raw_2dnoise16(uint16_t *pData, int width, int height, uint8_t octaves, q88 freq88, fract16 amplitude, int skip, uint32_t x, int scalex, uint32_t y, int scaley, uint32_t time) {
|
||||
if(octaves > 1) {
|
||||
fill_raw_2dnoise16(pData, width, height, octaves-1, freq88, amplitude, skip, x *freq88 , scalex *freq88, y * freq88, scaley * freq88, time);
|
||||
} else {
|
||||
// amplitude is always 255 on the lowest level
|
||||
amplitude=65535;
|
||||
}
|
||||
|
||||
scalex *= skip;
|
||||
scaley *= skip;
|
||||
fract16 invamp = 65535-amplitude;
|
||||
for(int i = 0; i < height; i+=skip, y+=scaley) {
|
||||
uint16_t *pRow = pData + (i*width);
|
||||
for(int j = 0,xx=x; j < width; j+=skip, xx+=scalex) {
|
||||
uint16_t noise_base = inoise16(xx,y,time);
|
||||
noise_base = (0x8000 & noise_base) ? noise_base - (32767) : 32767 - noise_base;
|
||||
noise_base = scale16(noise_base<<1, amplitude);
|
||||
if(skip==1) {
|
||||
pRow[j] = scale16(pRow[j],invamp) + noise_base;
|
||||
} else {
|
||||
for(int ii = i; ii<(i+skip) && ii<height; ii++) {
|
||||
uint16_t *pRow = pData + (ii*width);
|
||||
for(int jj=j; jj<(j+skip) && jj<width; jj++) {
|
||||
pRow[jj] = scale16(pRow[jj],invamp) + noise_base;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
int32_t nmin=11111110;
|
||||
int32_t nmax=0;
|
||||
|
||||
void fill_raw_2dnoise16into8(uint8_t *pData, int width, int height, uint8_t octaves, q44 freq44, fract8 amplitude, int skip, uint32_t x, int scalex, uint32_t y, int scaley, uint32_t time) {
|
||||
if(octaves > 1) {
|
||||
fill_raw_2dnoise16into8(pData, width, height, octaves-1, freq44, amplitude, skip+1, x*freq44, scalex *freq44, y*freq44, scaley * freq44, time);
|
||||
} else {
|
||||
// amplitude is always 255 on the lowest level
|
||||
amplitude=255;
|
||||
}
|
||||
|
||||
scalex *= skip;
|
||||
scaley *= skip;
|
||||
uint32_t xx;
|
||||
fract8 invamp = 255-amplitude;
|
||||
for(int i = 0; i < height; i+=skip, y+=scaley) {
|
||||
uint8_t *pRow = pData + (i*width);
|
||||
xx = x;
|
||||
for(int j = 0; j < width; j+=skip, xx+=scalex) {
|
||||
uint16_t noise_base = inoise16(xx,y,time);
|
||||
noise_base = (0x8000 & noise_base) ? noise_base - (32767) : 32767 - noise_base;
|
||||
noise_base = scale8(noise_base>>7,amplitude);
|
||||
if(skip==1) {
|
||||
pRow[j] = qadd8(scale8(pRow[j],invamp),noise_base);
|
||||
} else {
|
||||
for(int ii = i; ii<(i+skip) && ii<height; ii++) {
|
||||
uint8_t *pRow = pData + (ii*width);
|
||||
for(int jj=j; jj<(j+skip) && jj<width; jj++) {
|
||||
pRow[jj] = scale8(pRow[jj],invamp) + noise_base;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void fill_raw_2dnoise16into8(uint8_t *pData, int width, int height, uint8_t octaves, uint32_t x, int scalex, uint32_t y, int scaley, uint32_t time) {
|
||||
fill_raw_2dnoise16into8(pData, width, height, octaves, q44(2,0), 171, 1, x, scalex, y, scaley, time);
|
||||
}
|
||||
|
||||
void fill_noise8(CRGB *leds, int num_leds,
|
||||
uint8_t octaves, uint16_t x, int scale,
|
||||
uint8_t hue_octaves, uint16_t hue_x, int hue_scale,
|
||||
uint16_t time) {
|
||||
uint8_t V[num_leds];
|
||||
uint8_t H[num_leds];
|
||||
|
||||
memset(V,0,num_leds);
|
||||
memset(H,0,num_leds);
|
||||
|
||||
fill_raw_noise8(V,num_leds,octaves,x,scale,time);
|
||||
fill_raw_noise8(H,num_leds,hue_octaves,hue_x,hue_scale,time);
|
||||
|
||||
for(int i = 0; i < num_leds; i++) {
|
||||
leds[i] = CHSV(H[i],255,V[i]);
|
||||
}
|
||||
}
|
||||
|
||||
void fill_noise16(CRGB *leds, int num_leds,
|
||||
uint8_t octaves, uint16_t x, int scale,
|
||||
uint8_t hue_octaves, uint16_t hue_x, int hue_scale,
|
||||
uint16_t time, uint8_t hue_shift) {
|
||||
uint8_t V[num_leds];
|
||||
uint8_t H[num_leds];
|
||||
|
||||
memset(V,0,num_leds);
|
||||
memset(H,0,num_leds);
|
||||
|
||||
fill_raw_noise16into8(V,num_leds,octaves,x,scale,time);
|
||||
fill_raw_noise8(H,num_leds,hue_octaves,hue_x,hue_scale,time);
|
||||
|
||||
for(int i = 0; i < num_leds; i++) {
|
||||
leds[i] = CHSV(H[i] + hue_shift,255,V[i]);
|
||||
}
|
||||
}
|
||||
|
||||
void fill_2dnoise8(CRGB *leds, int width, int height, bool serpentine,
|
||||
uint8_t octaves, uint16_t x, int xscale, uint16_t y, int yscale, uint16_t time,
|
||||
uint8_t hue_octaves, uint16_t hue_x, int hue_xscale, uint16_t hue_y, uint16_t hue_yscale,uint16_t hue_time,bool blend) {
|
||||
uint8_t V[height][width];
|
||||
uint8_t H[height][width];
|
||||
|
||||
memset(V,0,height*width);
|
||||
memset(H,0,height*width);
|
||||
|
||||
fill_raw_2dnoise8((uint8_t*)V,width,height,octaves,x,xscale,y,yscale,time);
|
||||
fill_raw_2dnoise8((uint8_t*)H,width,height,hue_octaves,hue_x,hue_xscale,hue_y,hue_yscale,hue_time);
|
||||
|
||||
int w1 = width-1;
|
||||
int h1 = height-1;
|
||||
for(int i = 0; i < height; i++) {
|
||||
int wb = i*width;
|
||||
for(int j = 0; j < width; j++) {
|
||||
CRGB led(CHSV(H[h1-i][w1-j],255,V[i][j]));
|
||||
|
||||
int pos = j;
|
||||
if(serpentine && (i & 0x1)) {
|
||||
pos = w1-j;
|
||||
}
|
||||
|
||||
if(blend) {
|
||||
leds[wb+pos] >>= 1; leds[wb+pos] += (led>>=1);
|
||||
} else {
|
||||
leds[wb+pos] = led;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void fill_2dnoise16(CRGB *leds, int width, int height, bool serpentine,
|
||||
uint8_t octaves, uint32_t x, int xscale, uint32_t y, int yscale, uint32_t time,
|
||||
uint8_t hue_octaves, uint16_t hue_x, int hue_xscale, uint16_t hue_y, uint16_t hue_yscale,uint16_t hue_time, bool blend, uint16_t hue_shift) {
|
||||
uint8_t V[height][width];
|
||||
uint8_t H[height][width];
|
||||
|
||||
memset(V,0,height*width);
|
||||
memset(H,0,height*width);
|
||||
|
||||
fill_raw_2dnoise16into8((uint8_t*)V,width,height,octaves,q44(2,0),171,1,x,xscale,y,yscale,time);
|
||||
// fill_raw_2dnoise16into8((uint8_t*)V,width,height,octaves,x,xscale,y,yscale,time);
|
||||
// fill_raw_2dnoise8((uint8_t*)V,width,height,hue_octaves,x,xscale,y,yscale,time);
|
||||
fill_raw_2dnoise8((uint8_t*)H,width,height,hue_octaves,hue_x,hue_xscale,hue_y,hue_yscale,hue_time);
|
||||
|
||||
|
||||
int w1 = width-1;
|
||||
int h1 = height-1;
|
||||
hue_shift >>= 8;
|
||||
|
||||
for(int i = 0; i < height; i++) {
|
||||
int wb = i*width;
|
||||
for(int j = 0; j < width; j++) {
|
||||
CRGB led(CHSV(hue_shift + (H[h1-i][w1-j]),196,V[i][j]));
|
||||
|
||||
int pos = j;
|
||||
if(serpentine && (i & 0x1)) {
|
||||
pos = w1-j;
|
||||
}
|
||||
|
||||
if(blend) {
|
||||
leds[wb+pos] >>= 1; leds[wb+pos] += (led>>=1);
|
||||
} else {
|
||||
leds[wb+pos] = led;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
FASTLED_NAMESPACE_END
|
||||
97
components/FastLED-idf/noise.h
Normal file
97
components/FastLED-idf/noise.h
Normal file
@ -0,0 +1,97 @@
|
||||
#ifndef __INC_NOISE_H
|
||||
#define __INC_NOISE_H
|
||||
|
||||
#include "FastLED.h"
|
||||
|
||||
FASTLED_NAMESPACE_BEGIN
|
||||
|
||||
///@file noise.h
|
||||
/// Noise functions provided by the library.
|
||||
|
||||
///@defgroup Noise Noise functions
|
||||
///Simplex noise function definitions
|
||||
///@{
|
||||
/// @name scaled 16 bit noise functions
|
||||
///@{
|
||||
/// 16 bit, fixed point implementation of perlin's Simplex Noise. Coordinates are
|
||||
/// 16.16 fixed point values, 32 bit integers with integral coordinates in the high 16
|
||||
/// bits and fractional in the low 16 bits, and the function takes 1d, 2d, and 3d coordinate
|
||||
/// values. These functions are scaled to return 0-65535
|
||||
|
||||
extern uint16_t inoise16(uint32_t x, uint32_t y, uint32_t z);
|
||||
extern uint16_t inoise16(uint32_t x, uint32_t y);
|
||||
extern uint16_t inoise16(uint32_t x);
|
||||
///@}
|
||||
|
||||
/// @name raw 16 bit noise functions
|
||||
//@{
|
||||
/// 16 bit raw versions of the noise functions. These values are not scaled/altered and have
|
||||
/// output values roughly in the range (-18k,18k)
|
||||
extern int16_t inoise16_raw(uint32_t x, uint32_t y, uint32_t z);
|
||||
extern int16_t inoise16_raw(uint32_t x, uint32_t y);
|
||||
extern int16_t inoise16_raw(uint32_t x);
|
||||
///@}
|
||||
|
||||
/// @name 8 bit scaled noise functions
|
||||
///@{
|
||||
/// 8 bit, fixed point implementation of perlin's Simplex Noise. Coordinates are
|
||||
/// 8.8 fixed point values, 16 bit integers with integral coordinates in the high 8
|
||||
/// bits and fractional in the low 8 bits, and the function takes 1d, 2d, and 3d coordinate
|
||||
/// values. These functions are scaled to return 0-255
|
||||
extern uint8_t inoise8(uint16_t x, uint16_t y, uint16_t z);
|
||||
extern uint8_t inoise8(uint16_t x, uint16_t y);
|
||||
extern uint8_t inoise8(uint16_t x);
|
||||
///@}
|
||||
|
||||
/// @name 8 bit raw noise functions
|
||||
///@{
|
||||
/// 8 bit raw versions of the noise functions. These values are not scaled/altered and have
|
||||
/// output values roughly in the range (-70,70)
|
||||
extern int8_t inoise8_raw(uint16_t x, uint16_t y, uint16_t z);
|
||||
extern int8_t inoise8_raw(uint16_t x, uint16_t y);
|
||||
extern int8_t inoise8_raw(uint16_t x);
|
||||
///@}
|
||||
|
||||
///@name raw fill functions
|
||||
///@{
|
||||
/// Raw noise fill functions - fill into a 1d or 2d array of 8-bit values using either 8-bit noise or 16-bit noise
|
||||
/// functions.
|
||||
///@param pData the array of data to write into
|
||||
///@param num_points the number of points of noise to compute
|
||||
///@param octaves the number of octaves to use for noise
|
||||
///@param x the x position in the noise field
|
||||
///@param y the y position in the noise field for 2d functions
|
||||
///@param scalex the scale (distance) between x points when filling in noise
|
||||
///@param scaley the scale (distance) between y points when filling in noise
|
||||
///@param time the time position for the noise field
|
||||
void fill_raw_noise8(uint8_t *pData, uint8_t num_points, uint8_t octaves, uint16_t x, int scalex, uint16_t time);
|
||||
void fill_raw_noise16into8(uint8_t *pData, uint8_t num_points, uint8_t octaves, uint32_t x, int scalex, uint32_t time);
|
||||
void fill_raw_2dnoise8(uint8_t *pData, int width, int height, uint8_t octaves, uint16_t x, int scalex, uint16_t y, int scaley, uint16_t time);
|
||||
void fill_raw_2dnoise16into8(uint8_t *pData, int width, int height, uint8_t octaves, uint32_t x, int scalex, uint32_t y, int scaley, uint32_t time);
|
||||
|
||||
void fill_raw_2dnoise16(uint16_t *pData, int width, int height, uint8_t octaves, q88 freq88, fract16 amplitude, int skip, uint32_t x, int scalex, uint32_t y, int scaley, uint32_t time);
|
||||
void fill_raw_2dnoise16into8(uint8_t *pData, int width, int height, uint8_t octaves, q44 freq44, fract8 amplitude, int skip, uint32_t x, int scalex, uint32_t y, int scaley, uint32_t time);
|
||||
///@}
|
||||
|
||||
///@name fill functions
|
||||
///@{
|
||||
/// fill functions to fill leds with values based on noise functions. These functions use the fill_raw_* functions as appropriate.
|
||||
void fill_noise8(CRGB *leds, int num_leds,
|
||||
uint8_t octaves, uint16_t x, int scale,
|
||||
uint8_t hue_octaves, uint16_t hue_x, int hue_scale,
|
||||
uint16_t time);
|
||||
void fill_noise16(CRGB *leds, int num_leds,
|
||||
uint8_t octaves, uint16_t x, int scale,
|
||||
uint8_t hue_octaves, uint16_t hue_x, int hue_scale,
|
||||
uint16_t time, uint8_t hue_shift=0);
|
||||
void fill_2dnoise8(CRGB *leds, int width, int height, bool serpentine,
|
||||
uint8_t octaves, uint16_t x, int xscale, uint16_t y, int yscale, uint16_t time,
|
||||
uint8_t hue_octaves, uint16_t hue_x, int hue_xscale, uint16_t hue_y, uint16_t hue_yscale,uint16_t hue_time,bool blend);
|
||||
void fill_2dnoise16(CRGB *leds, int width, int height, bool serpentine,
|
||||
uint8_t octaves, uint32_t x, int xscale, uint32_t y, int yscale, uint32_t time,
|
||||
uint8_t hue_octaves, uint16_t hue_x, int hue_xscale, uint16_t hue_y, uint16_t hue_yscale,uint16_t hue_time, bool blend, uint16_t hue_shift=0);
|
||||
|
||||
FASTLED_NAMESPACE_END
|
||||
///@}
|
||||
|
||||
#endif
|
||||
305
components/FastLED-idf/pixelset.h
Normal file
305
components/FastLED-idf/pixelset.h
Normal file
@ -0,0 +1,305 @@
|
||||
#ifndef __INC_PIXELSET_H
|
||||
#define __INC_PIXELSET_H
|
||||
|
||||
#include "FastLED.h"
|
||||
|
||||
#ifndef abs
|
||||
#include <stdlib.h>
|
||||
#endif
|
||||
|
||||
/// Represents a set of CRGB led objects. Provides the [] array operator, and works like a normal array in that case.
|
||||
/// This should be kept in sync with the set of functions provided by CRGB as well as functions in colorutils. Note
|
||||
/// that a pixel set is a window into another set of led data, it is not its own set of led data.
|
||||
template<class PIXEL_TYPE>
|
||||
class CPixelView {
|
||||
public:
|
||||
const int8_t dir;
|
||||
const int len;
|
||||
PIXEL_TYPE * const leds;
|
||||
PIXEL_TYPE * const end_pos;
|
||||
|
||||
public:
|
||||
|
||||
/// PixelSet copy constructor
|
||||
inline CPixelView(const CPixelView & other) : dir(other.dir), len(other.len), leds(other.leds), end_pos(other.end_pos) {}
|
||||
|
||||
/// pixelset constructor for a pixel set starting at the given PIXEL_TYPE* and going for _len leds. Note that the length
|
||||
/// can be backwards, creating a PixelSet that walks backwards over the data
|
||||
/// @param leds point to the raw led data
|
||||
/// @param len how many leds in this set
|
||||
inline CPixelView(PIXEL_TYPE *_leds, int _len) : dir(_len < 0 ? -1 : 1), len(_len), leds(_leds), end_pos(_leds + _len) {}
|
||||
|
||||
/// PixelSet constructor for the given set of leds, with start and end boundaries. Note that start can be after
|
||||
/// end, resulting in a set that will iterate backwards
|
||||
/// @param leds point to the raw led data
|
||||
/// @param start the start index of the leds for this array
|
||||
/// @param end the end index of the leds for this array
|
||||
inline CPixelView(PIXEL_TYPE *_leds, int _start, int _end) : dir(((_end-_start)<0) ? -1 : 1), len((_end - _start) + dir), leds(_leds + _start), end_pos(_leds + _start + len) {}
|
||||
|
||||
/// Get the size of this set
|
||||
/// @return the size of the set
|
||||
int size() { return abs(len); }
|
||||
|
||||
/// Whether or not this set goes backwards
|
||||
/// @return whether or not the set is backwards
|
||||
bool reversed() { return len < 0; }
|
||||
|
||||
/// do these sets point to the same thing (note, this is different from the contents of the set being the same)
|
||||
bool operator==(const CPixelView & rhs) const { return leds == rhs.leds && len == rhs.len && dir == rhs.dir; }
|
||||
|
||||
/// do these sets point to the different things (note, this is different from the contents of the set being the same)
|
||||
bool operator!=(const CPixelView & rhs) const { return leds != rhs.leds || len != rhs.len || dir != rhs.dir; }
|
||||
|
||||
/// access a single element in this set, just like an array operator
|
||||
inline PIXEL_TYPE & operator[](int x) const { if(dir & 0x80) { return leds[-x]; } else { return leds[x]; } }
|
||||
|
||||
/// Access an inclusive subset of the leds in this set. Note that start can be greater than end, which will
|
||||
/// result in a reverse ordering for many functions (useful for mirroring)
|
||||
/// @param start the first element from this set for the new subset
|
||||
/// @param end the last element for the new subset
|
||||
inline CPixelView operator()(int start, int end) { return CPixelView(leds, start, end); }
|
||||
|
||||
/// Access an inclusive subset of the leds in this set, starting from the first.
|
||||
/// @param end the last element for the new subset
|
||||
/// Not sure i want this? inline CPixelView operator()(int end) { return CPixelView(leds, 0, end); }
|
||||
|
||||
/// Return the reverse ordering of this set
|
||||
inline CPixelView operator-() { return CPixelView(leds, len - dir, 0); }
|
||||
|
||||
/// Return a pointer to the first element in this set
|
||||
inline operator PIXEL_TYPE* () const { return leds; }
|
||||
|
||||
/// Assign the passed in color to all elements in this set
|
||||
/// @param color the new color for the elements in the set
|
||||
inline CPixelView & operator=(const PIXEL_TYPE & color) {
|
||||
for(iterator pixel = begin(), _end = end(); pixel != _end; ++pixel) { (*pixel) = color; }
|
||||
return *this;
|
||||
}
|
||||
|
||||
|
||||
void dump() const {
|
||||
/**
|
||||
Serial.print("len: "); Serial.print(len); Serial.print(", dir:"); Serial.print((int)dir);
|
||||
Serial.print(", range:"); Serial.print((uint32_t)leds); Serial.print("-"); Serial.print((uint32_t)end_pos);
|
||||
Serial.print(", diff:"); Serial.print((int32_t)(end_pos - leds));
|
||||
Serial.println("");
|
||||
**/
|
||||
}
|
||||
|
||||
/// Copy the contents of the passed in set to our set. Note if one set is smaller than the other, only the
|
||||
/// smallest number of items will be copied over.
|
||||
inline CPixelView & operator=(const CPixelView & rhs) {
|
||||
for(iterator pixel = begin(), rhspixel = rhs.begin(), _end = end(), rhs_end = rhs.end(); (pixel != _end) && (rhspixel != rhs_end); ++pixel, ++rhspixel) {
|
||||
(*pixel) = (*rhspixel);
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
|
||||
/// @name modification/scaling operators
|
||||
//@{
|
||||
/// Add the passed in value to r,g, b for all the pixels in this set
|
||||
inline CPixelView & addToRGB(uint8_t inc) { for(iterator pixel = begin(), _end = end(); pixel != _end; ++pixel) { (*pixel) += inc; } return *this; }
|
||||
/// Add every pixel in the other set to this set
|
||||
inline CPixelView & operator+=(CPixelView & rhs) { for(iterator pixel = begin(), rhspixel = rhs.begin(), _end = end(), rhs_end = rhs.end(); (pixel != _end) && (rhspixel != rhs_end); ++pixel, ++rhspixel) { (*pixel) += (*rhspixel); } return *this; }
|
||||
|
||||
/// Subtract the passed in value from r,g,b for all pixels in this set
|
||||
inline CPixelView & subFromRGB(uint8_t inc) { for(iterator pixel = begin(), _end = end(); pixel != _end; ++pixel) { (*pixel) -= inc; } return *this; }
|
||||
/// Subtract every pixel in the other set from this set
|
||||
inline CPixelView & operator-=(CPixelView & rhs) { for(iterator pixel = begin(), rhspixel = rhs.begin(), _end = end(), rhs_end = rhs.end(); (pixel != _end) && (rhspixel != rhs_end); ++pixel, ++rhspixel) { (*pixel) -= (*rhspixel); } return *this; }
|
||||
|
||||
/// Increment every pixel value in this set
|
||||
inline CPixelView & operator++() { for(iterator pixel = begin(), _end = end(); pixel != _end; ++pixel) { (*pixel)++; } return *this; }
|
||||
/// Increment every pixel value in this set
|
||||
inline CPixelView & operator++(int DUMMY_ARG) { for(iterator pixel = begin(), _end = end(); pixel != _end; ++pixel) { (*pixel)++; } return *this; }
|
||||
|
||||
/// Decrement every pixel value in this set
|
||||
inline CPixelView & operator--() { for(iterator pixel = begin(), _end = end(); pixel != _end; ++pixel) { (*pixel)--; } return *this; }
|
||||
/// Decrement every pixel value in this set
|
||||
inline CPixelView & operator--(int DUMMY_ARG) { for(iterator pixel = begin(), _end = end(); pixel != _end; ++pixel) { (*pixel)--; } return *this; }
|
||||
|
||||
/// Divide every led by the given value
|
||||
inline CPixelView & operator/=(uint8_t d) { for(iterator pixel = begin(), _end = end(); pixel != _end; ++pixel) { (*pixel) /= d; } return *this; }
|
||||
/// Shift every led in this set right by the given number of bits
|
||||
inline CPixelView & operator>>=(uint8_t d) { for(iterator pixel = begin(), _end = end(); pixel != _end; ++pixel) { (*pixel) >>= d; } return *this; }
|
||||
/// Multiply every led in this set by the given value
|
||||
inline CPixelView & operator*=(uint8_t d) { for(iterator pixel = begin(), _end = end(); pixel != _end; ++pixel) { (*pixel) *= d; } return *this; }
|
||||
|
||||
/// Scale every led by the given scale
|
||||
inline CPixelView & nscale8_video(uint8_t scaledown) { for(iterator pixel = begin(), _end = end(); pixel != _end; ++pixel) { (*pixel).nscale8_video(scaledown); } return *this;}
|
||||
/// Scale down every led by the given scale
|
||||
inline CPixelView & operator%=(uint8_t scaledown) { for(iterator pixel = begin(), _end = end(); pixel != _end; ++pixel) { (*pixel).nscale8_video(scaledown); } return *this; }
|
||||
/// Fade every led down by the given scale
|
||||
inline CPixelView & fadeLightBy(uint8_t fadefactor) { return nscale8_video(255 - fadefactor); }
|
||||
|
||||
/// Scale every led by the given scale
|
||||
inline CPixelView & nscale8(uint8_t scaledown) { for(iterator pixel = begin(), _end = end(); pixel != _end; ++pixel) { (*pixel).nscale8(scaledown); } return *this; }
|
||||
/// Scale every led by the given scale
|
||||
inline CPixelView & nscale8(PIXEL_TYPE & scaledown) { for(iterator pixel = begin(), _end = end(); pixel != _end; ++pixel) { (*pixel).nscale8(scaledown); } return *this; }
|
||||
/// Scale every led in this set by every led in the other set
|
||||
inline CPixelView & nscale8(CPixelView & rhs) { for(iterator pixel = begin(), rhspixel = rhs.begin(), _end = end(), rhs_end = rhs.end(); (pixel != _end) && (rhspixel != rhs_end); ++pixel, ++rhspixel) { (*pixel).nscale8((*rhspixel)); } return *this; }
|
||||
|
||||
/// Fade every led down by the given scale
|
||||
inline CPixelView & fadeToBlackBy(uint8_t fade) { return nscale8(255 - fade); }
|
||||
|
||||
/// Apply the PIXEL_TYPE |= operator to every pixel in this set with the given PIXEL_TYPE value (bringing each channel to the higher of the two values)
|
||||
inline CPixelView & operator|=(const PIXEL_TYPE & rhs) { for(iterator pixel = begin(), _end = end(); pixel != _end; ++pixel) { (*pixel) |= rhs; } return *this; }
|
||||
/// Apply the PIXEL_TYPE |= operator to every pixel in this set with every pixel in the passed in set
|
||||
inline CPixelView & operator|=(const CPixelView & rhs) { for(iterator pixel = begin(), rhspixel = rhs.begin(), _end = end(), rhs_end = rhs.end(); (pixel != _end) && (rhspixel != rhs_end); ++pixel, ++rhspixel) { (*pixel) |= (*rhspixel); } return *this; }
|
||||
/// Apply the PIXEL_TYPE |= operator to every pixel in this set
|
||||
inline CPixelView & operator|=(uint8_t d) { for(iterator pixel = begin(), _end = end(); pixel != _end; ++pixel) { (*pixel) |= d; } return *this; }
|
||||
|
||||
/// Apply the PIXEL_TYPE &= operator to every pixel in this set with the given PIXEL_TYPE value (bringing each channel down to the lower of the two values)
|
||||
inline CPixelView & operator&=(const PIXEL_TYPE & rhs) { for(iterator pixel = begin(), _end = end(); pixel != _end; ++pixel) { (*pixel) &= rhs; } return *this; }
|
||||
/// Apply the PIXEL_TYPE &= operator to every pixel in this set with every pixel in the passed in set
|
||||
inline CPixelView & operator&=(const CPixelView & rhs) { for(iterator pixel = begin(), rhspixel = rhs.begin(), _end = end(), rhs_end = rhs.end(); (pixel != _end) && (rhspixel != rhs_end); ++pixel, ++rhspixel) { (*pixel) &= (*rhspixel); } return *this; }
|
||||
/// APply the PIXEL_TYPE &= operator to every pixel in this set with the passed in value
|
||||
inline CPixelView & operator&=(uint8_t d) { for(iterator pixel = begin(), _end = end(); pixel != _end; ++pixel) { (*pixel) &= d; } return *this; }
|
||||
//@}
|
||||
|
||||
/// Returns whether or not any leds in this set are non-zero
|
||||
inline operator bool() { for(iterator pixel = begin(), _end = end(); pixel != _end; ++pixel) { if((*pixel)) return true; } return false; }
|
||||
|
||||
// Color util functions
|
||||
inline CPixelView & fill_solid(const PIXEL_TYPE & color) { *this = color; return *this; }
|
||||
inline CPixelView & fill_solid(const CHSV & color) { if(dir>0) { *this = color; return *this; } }
|
||||
|
||||
inline CPixelView & fill_rainbow(uint8_t initialhue, uint8_t deltahue=5) {
|
||||
if(dir >= 0) {
|
||||
::fill_rainbow(leds,len,initialhue,deltahue);
|
||||
} else {
|
||||
::fill_rainbow(leds+len+1,-len,initialhue,deltahue);
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
|
||||
inline CPixelView & fill_gradient(const CHSV & startcolor, const CHSV & endcolor, TGradientDirectionCode directionCode = SHORTEST_HUES) {
|
||||
if(dir >= 0) {
|
||||
::fill_gradient(leds,len,startcolor, endcolor, directionCode);
|
||||
} else {
|
||||
::fill_gradient(leds + len + 1, (-len), endcolor, startcolor, directionCode);
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
|
||||
inline CPixelView & fill_gradient(const CHSV & c1, const CHSV & c2, const CHSV & c3, TGradientDirectionCode directionCode = SHORTEST_HUES) {
|
||||
if(dir >= 0) {
|
||||
::fill_gradient(leds, len, c1, c2, c3, directionCode);
|
||||
} else {
|
||||
::fill_gradient(leds + len + 1, -len, c3, c2, c1, directionCode);
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
|
||||
inline CPixelView & fill_gradient(const CHSV & c1, const CHSV & c2, const CHSV & c3, const CHSV & c4, TGradientDirectionCode directionCode = SHORTEST_HUES) {
|
||||
if(dir >= 0) {
|
||||
::fill_gradient(leds, len, c1, c2, c3, c4, directionCode);
|
||||
} else {
|
||||
::fill_gradient(leds + len + 1, -len, c4, c3, c2, c1, directionCode);
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
|
||||
inline CPixelView & fill_gradient_RGB(const PIXEL_TYPE & startcolor, const PIXEL_TYPE & endcolor, TGradientDirectionCode directionCode = SHORTEST_HUES) {
|
||||
if(dir >= 0) {
|
||||
::fill_gradient_RGB(leds,len,startcolor, endcolor);
|
||||
} else {
|
||||
::fill_gradient_RGB(leds + len + 1, (-len), endcolor, startcolor);
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
|
||||
inline CPixelView & fill_gradient_RGB(const PIXEL_TYPE & c1, const PIXEL_TYPE & c2, const PIXEL_TYPE & c3) {
|
||||
if(dir >= 0) {
|
||||
::fill_gradient_RGB(leds, len, c1, c2, c3);
|
||||
} else {
|
||||
::fill_gradient_RGB(leds + len + 1, -len, c3, c2, c1);
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
|
||||
inline CPixelView & fill_gradient_RGB(const PIXEL_TYPE & c1, const PIXEL_TYPE & c2, const PIXEL_TYPE & c3, const PIXEL_TYPE & c4) {
|
||||
if(dir >= 0) {
|
||||
::fill_gradient_RGB(leds, len, c1, c2, c3, c4);
|
||||
} else {
|
||||
::fill_gradient_RGB(leds + len + 1, -len, c4, c3, c2, c1);
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
|
||||
inline CPixelView & nblend(const PIXEL_TYPE & overlay, fract8 amountOfOverlay) { for(iterator pixel = begin(), _end = end(); pixel != _end; ++pixel) { ::nblend((*pixel), overlay, amountOfOverlay); } return *this; }
|
||||
inline CPixelView & nblend(const CPixelView & rhs, fract8 amountOfOverlay) { for(iterator pixel = begin(), rhspixel = rhs.begin(), _end = end(), rhs_end = rhs.end(); (pixel != _end) && (rhspixel != rhs_end); ++pixel, ++rhspixel) { ::nblend((*pixel), (*rhspixel), amountOfOverlay); } return *this; }
|
||||
|
||||
// Note: only bringing in a 1d blur, not sure 2d blur makes sense when looking at sub arrays
|
||||
inline CPixelView & blur1d(fract8 blur_amount) {
|
||||
if(dir >= 0) {
|
||||
::blur1d(leds, len, blur_amount);
|
||||
} else {
|
||||
::blur1d(leds + len + 1, -len, blur_amount);
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
|
||||
inline CPixelView & napplyGamma_video(float gamma) {
|
||||
if(dir >= 0) {
|
||||
::napplyGamma_video(leds, len, gamma);
|
||||
} else {
|
||||
::napplyGamma_video(leds + len + 1, -len, gamma);
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
|
||||
inline CPixelView & napplyGamma_video(float gammaR, float gammaG, float gammaB) {
|
||||
if(dir >= 0) {
|
||||
::napplyGamma_video(leds, len, gammaR, gammaG, gammaB);
|
||||
} else {
|
||||
::napplyGamma_video(leds + len + 1, -len, gammaR, gammaG, gammaB);
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
|
||||
// TODO: Make this a fully specified/proper iterator
|
||||
template <class T>
|
||||
class pixelset_iterator_base {
|
||||
T * leds;
|
||||
const int8_t dir;
|
||||
public:
|
||||
__attribute__((always_inline)) inline pixelset_iterator_base(const pixelset_iterator_base & rhs) : leds(rhs.leds), dir(rhs.dir) {}
|
||||
__attribute__((always_inline)) inline pixelset_iterator_base(T * _leds, const char _dir) : leds(_leds), dir(_dir) {}
|
||||
|
||||
__attribute__((always_inline)) inline pixelset_iterator_base& operator++() { leds += dir; return *this; }
|
||||
__attribute__((always_inline)) inline pixelset_iterator_base operator++(int) { pixelset_iterator_base tmp(*this); leds += dir; return tmp; }
|
||||
|
||||
__attribute__((always_inline)) inline bool operator==(pixelset_iterator_base & other) const { return leds == other.leds; } // && set==other.set; }
|
||||
__attribute__((always_inline)) inline bool operator!=(pixelset_iterator_base & other) const { return leds != other.leds; } // || set != other.set; }
|
||||
|
||||
__attribute__((always_inline)) inline PIXEL_TYPE& operator*() const { return *leds; }
|
||||
};
|
||||
|
||||
typedef pixelset_iterator_base<PIXEL_TYPE> iterator;
|
||||
typedef pixelset_iterator_base<const PIXEL_TYPE> const_iterator;
|
||||
|
||||
iterator begin() { return iterator(leds, dir); }
|
||||
iterator end() { return iterator(end_pos, dir); }
|
||||
|
||||
iterator begin() const { return iterator(leds, dir); }
|
||||
iterator end() const { return iterator(end_pos, dir); }
|
||||
|
||||
const_iterator cbegin() const { return const_iterator(leds, dir); }
|
||||
const_iterator cend() const { return const_iterator(end_pos, dir); }
|
||||
};
|
||||
|
||||
typedef CPixelView<CRGB> CRGBSet;
|
||||
|
||||
__attribute__((always_inline))
|
||||
inline CRGB *operator+(const CRGBSet & pixels, int offset) { return (CRGB*)pixels + offset; }
|
||||
|
||||
|
||||
template<int SIZE>
|
||||
class CRGBArray : public CPixelView<CRGB> {
|
||||
CRGB rawleds[SIZE];
|
||||
public:
|
||||
CRGBArray() : CPixelView<CRGB>(rawleds, SIZE) {}
|
||||
using CPixelView::operator=;
|
||||
};
|
||||
|
||||
#endif
|
||||
871
components/FastLED-idf/pixeltypes.h
Normal file
871
components/FastLED-idf/pixeltypes.h
Normal file
@ -0,0 +1,871 @@
|
||||
#ifndef __INC_PIXELS_H
|
||||
#define __INC_PIXELS_H
|
||||
|
||||
#include "FastLED.h"
|
||||
|
||||
#include <stdint.h>
|
||||
#include "lib8tion.h"
|
||||
#include "color.h"
|
||||
|
||||
FASTLED_NAMESPACE_BEGIN
|
||||
|
||||
struct CRGB;
|
||||
struct CHSV;
|
||||
|
||||
///@defgroup Pixeltypes CHSV and CRGB type definitions
|
||||
///@{
|
||||
|
||||
/// Forward declaration of hsv2rgb_rainbow here,
|
||||
/// to avoid circular dependencies.
|
||||
extern void hsv2rgb_rainbow( const CHSV& hsv, CRGB& rgb);
|
||||
|
||||
/// Representation of an HSV pixel (hue, saturation, value (aka brightness)).
|
||||
struct CHSV {
|
||||
union {
|
||||
struct {
|
||||
union {
|
||||
uint8_t hue;
|
||||
uint8_t h; };
|
||||
union {
|
||||
uint8_t saturation;
|
||||
uint8_t sat;
|
||||
uint8_t s; };
|
||||
union {
|
||||
uint8_t value;
|
||||
uint8_t val;
|
||||
uint8_t v; };
|
||||
};
|
||||
uint8_t raw[3];
|
||||
};
|
||||
|
||||
/// default values are UNITIALIZED
|
||||
inline CHSV() __attribute__((always_inline))
|
||||
{
|
||||
}
|
||||
|
||||
/// allow construction from H, S, V
|
||||
inline CHSV( uint8_t ih, uint8_t is, uint8_t iv) __attribute__((always_inline))
|
||||
: h(ih), s(is), v(iv)
|
||||
{
|
||||
}
|
||||
|
||||
/// allow copy construction
|
||||
inline CHSV(const CHSV& rhs) __attribute__((always_inline))
|
||||
{
|
||||
h = rhs.h;
|
||||
s = rhs.s;
|
||||
v = rhs.v;
|
||||
}
|
||||
|
||||
inline CHSV& operator= (const CHSV& rhs) __attribute__((always_inline))
|
||||
{
|
||||
h = rhs.h;
|
||||
s = rhs.s;
|
||||
v = rhs.v;
|
||||
return *this;
|
||||
}
|
||||
|
||||
inline CHSV& setHSV(uint8_t ih, uint8_t is, uint8_t iv) __attribute__((always_inline))
|
||||
{
|
||||
h = ih;
|
||||
s = is;
|
||||
v = iv;
|
||||
return *this;
|
||||
}
|
||||
};
|
||||
|
||||
/// Pre-defined hue values for HSV objects
|
||||
typedef enum {
|
||||
HUE_RED = 0,
|
||||
HUE_ORANGE = 32,
|
||||
HUE_YELLOW = 64,
|
||||
HUE_GREEN = 96,
|
||||
HUE_AQUA = 128,
|
||||
HUE_BLUE = 160,
|
||||
HUE_PURPLE = 192,
|
||||
HUE_PINK = 224
|
||||
} HSVHue;
|
||||
|
||||
/// Representation of an RGB pixel (Red, Green, Blue)
|
||||
struct CRGB {
|
||||
union {
|
||||
struct {
|
||||
union {
|
||||
uint8_t r;
|
||||
uint8_t red;
|
||||
};
|
||||
union {
|
||||
uint8_t g;
|
||||
uint8_t green;
|
||||
};
|
||||
union {
|
||||
uint8_t b;
|
||||
uint8_t blue;
|
||||
};
|
||||
};
|
||||
uint8_t raw[3];
|
||||
};
|
||||
|
||||
/// Array access operator to index into the crgb object
|
||||
inline uint8_t& operator[] (uint8_t x) __attribute__((always_inline))
|
||||
{
|
||||
return raw[x];
|
||||
}
|
||||
|
||||
/// Array access operator to index into the crgb object
|
||||
inline const uint8_t& operator[] (uint8_t x) const __attribute__((always_inline))
|
||||
{
|
||||
return raw[x];
|
||||
}
|
||||
|
||||
// default values are UNINITIALIZED
|
||||
inline CRGB() __attribute__((always_inline))
|
||||
{
|
||||
}
|
||||
|
||||
/// allow construction from R, G, B
|
||||
inline CRGB( uint8_t ir, uint8_t ig, uint8_t ib) __attribute__((always_inline))
|
||||
: r(ir), g(ig), b(ib)
|
||||
{
|
||||
}
|
||||
|
||||
/// allow construction from 32-bit (really 24-bit) bit 0xRRGGBB color code
|
||||
inline CRGB( uint32_t colorcode) __attribute__((always_inline))
|
||||
: r((colorcode >> 16) & 0xFF), g((colorcode >> 8) & 0xFF), b((colorcode >> 0) & 0xFF)
|
||||
{
|
||||
}
|
||||
|
||||
/// allow construction from a LEDColorCorrection enum
|
||||
inline CRGB( LEDColorCorrection colorcode) __attribute__((always_inline))
|
||||
: r((colorcode >> 16) & 0xFF), g((colorcode >> 8) & 0xFF), b((colorcode >> 0) & 0xFF)
|
||||
{
|
||||
|
||||
}
|
||||
|
||||
/// allow construction from a ColorTemperature enum
|
||||
inline CRGB( ColorTemperature colorcode) __attribute__((always_inline))
|
||||
: r((colorcode >> 16) & 0xFF), g((colorcode >> 8) & 0xFF), b((colorcode >> 0) & 0xFF)
|
||||
{
|
||||
|
||||
}
|
||||
|
||||
/// allow copy construction
|
||||
inline CRGB(const CRGB& rhs) __attribute__((always_inline))
|
||||
{
|
||||
r = rhs.r;
|
||||
g = rhs.g;
|
||||
b = rhs.b;
|
||||
}
|
||||
|
||||
/// allow construction from HSV color
|
||||
inline CRGB(const CHSV& rhs) __attribute__((always_inline))
|
||||
{
|
||||
hsv2rgb_rainbow( rhs, *this);
|
||||
}
|
||||
|
||||
/// allow assignment from one RGB struct to another
|
||||
inline CRGB& operator= (const CRGB& rhs) __attribute__((always_inline))
|
||||
{
|
||||
r = rhs.r;
|
||||
g = rhs.g;
|
||||
b = rhs.b;
|
||||
return *this;
|
||||
}
|
||||
|
||||
/// allow assignment from 32-bit (really 24-bit) 0xRRGGBB color code
|
||||
inline CRGB& operator= (const uint32_t colorcode) __attribute__((always_inline))
|
||||
{
|
||||
r = (colorcode >> 16) & 0xFF;
|
||||
g = (colorcode >> 8) & 0xFF;
|
||||
b = (colorcode >> 0) & 0xFF;
|
||||
return *this;
|
||||
}
|
||||
|
||||
/// allow assignment from R, G, and B
|
||||
inline CRGB& setRGB (uint8_t nr, uint8_t ng, uint8_t nb) __attribute__((always_inline))
|
||||
{
|
||||
r = nr;
|
||||
g = ng;
|
||||
b = nb;
|
||||
return *this;
|
||||
}
|
||||
|
||||
/// allow assignment from H, S, and V
|
||||
inline CRGB& setHSV (uint8_t hue, uint8_t sat, uint8_t val) __attribute__((always_inline))
|
||||
{
|
||||
hsv2rgb_rainbow( CHSV(hue, sat, val), *this);
|
||||
return *this;
|
||||
}
|
||||
|
||||
/// allow assignment from just a Hue, saturation and value automatically at max.
|
||||
inline CRGB& setHue (uint8_t hue) __attribute__((always_inline))
|
||||
{
|
||||
hsv2rgb_rainbow( CHSV(hue, 255, 255), *this);
|
||||
return *this;
|
||||
}
|
||||
|
||||
/// allow assignment from HSV color
|
||||
inline CRGB& operator= (const CHSV& rhs) __attribute__((always_inline))
|
||||
{
|
||||
hsv2rgb_rainbow( rhs, *this);
|
||||
return *this;
|
||||
}
|
||||
|
||||
/// allow assignment from 32-bit (really 24-bit) 0xRRGGBB color code
|
||||
inline CRGB& setColorCode (uint32_t colorcode) __attribute__((always_inline))
|
||||
{
|
||||
r = (colorcode >> 16) & 0xFF;
|
||||
g = (colorcode >> 8) & 0xFF;
|
||||
b = (colorcode >> 0) & 0xFF;
|
||||
return *this;
|
||||
}
|
||||
|
||||
|
||||
/// add one RGB to another, saturating at 0xFF for each channel
|
||||
inline CRGB& operator+= (const CRGB& rhs )
|
||||
{
|
||||
r = qadd8( r, rhs.r);
|
||||
g = qadd8( g, rhs.g);
|
||||
b = qadd8( b, rhs.b);
|
||||
return *this;
|
||||
}
|
||||
|
||||
/// add a contstant to each channel, saturating at 0xFF
|
||||
/// this is NOT an operator+= overload because the compiler
|
||||
/// can't usefully decide when it's being passed a 32-bit
|
||||
/// constant (e.g. CRGB::Red) and an 8-bit one (CRGB::Blue)
|
||||
inline CRGB& addToRGB (uint8_t d )
|
||||
{
|
||||
r = qadd8( r, d);
|
||||
g = qadd8( g, d);
|
||||
b = qadd8( b, d);
|
||||
return *this;
|
||||
}
|
||||
|
||||
/// subtract one RGB from another, saturating at 0x00 for each channel
|
||||
inline CRGB& operator-= (const CRGB& rhs )
|
||||
{
|
||||
r = qsub8( r, rhs.r);
|
||||
g = qsub8( g, rhs.g);
|
||||
b = qsub8( b, rhs.b);
|
||||
return *this;
|
||||
}
|
||||
|
||||
/// subtract a constant from each channel, saturating at 0x00
|
||||
/// this is NOT an operator+= overload because the compiler
|
||||
/// can't usefully decide when it's being passed a 32-bit
|
||||
/// constant (e.g. CRGB::Red) and an 8-bit one (CRGB::Blue)
|
||||
inline CRGB& subtractFromRGB(uint8_t d )
|
||||
{
|
||||
r = qsub8( r, d);
|
||||
g = qsub8( g, d);
|
||||
b = qsub8( b, d);
|
||||
return *this;
|
||||
}
|
||||
|
||||
/// subtract a constant of '1' from each channel, saturating at 0x00
|
||||
inline CRGB& operator-- () __attribute__((always_inline))
|
||||
{
|
||||
subtractFromRGB(1);
|
||||
return *this;
|
||||
}
|
||||
|
||||
/// subtract a constant of '1' from each channel, saturating at 0x00
|
||||
inline CRGB operator-- (int ) __attribute__((always_inline))
|
||||
{
|
||||
CRGB retval(*this);
|
||||
--(*this);
|
||||
return retval;
|
||||
}
|
||||
|
||||
/// add a constant of '1' from each channel, saturating at 0xFF
|
||||
inline CRGB& operator++ () __attribute__((always_inline))
|
||||
{
|
||||
addToRGB(1);
|
||||
return *this;
|
||||
}
|
||||
|
||||
/// add a constant of '1' from each channel, saturating at 0xFF
|
||||
inline CRGB operator++ (int ) __attribute__((always_inline))
|
||||
{
|
||||
CRGB retval(*this);
|
||||
++(*this);
|
||||
return retval;
|
||||
}
|
||||
|
||||
/// divide each of the channels by a constant
|
||||
inline CRGB& operator/= (uint8_t d )
|
||||
{
|
||||
r /= d;
|
||||
g /= d;
|
||||
b /= d;
|
||||
return *this;
|
||||
}
|
||||
|
||||
/// right shift each of the channels by a constant
|
||||
inline CRGB& operator>>= (uint8_t d)
|
||||
{
|
||||
r >>= d;
|
||||
g >>= d;
|
||||
b >>= d;
|
||||
return *this;
|
||||
}
|
||||
|
||||
/// multiply each of the channels by a constant,
|
||||
/// saturating each channel at 0xFF
|
||||
inline CRGB& operator*= (uint8_t d )
|
||||
{
|
||||
r = qmul8( r, d);
|
||||
g = qmul8( g, d);
|
||||
b = qmul8( b, d);
|
||||
return *this;
|
||||
}
|
||||
|
||||
/// scale down a RGB to N 256ths of it's current brightness, using
|
||||
/// 'video' dimming rules, which means that unless the scale factor is ZERO
|
||||
/// each channel is guaranteed NOT to dim down to zero. If it's already
|
||||
/// nonzero, it'll stay nonzero, even if that means the hue shifts a little
|
||||
/// at low brightness levels.
|
||||
inline CRGB& nscale8_video (uint8_t scaledown )
|
||||
{
|
||||
nscale8x3_video( r, g, b, scaledown);
|
||||
return *this;
|
||||
}
|
||||
|
||||
/// %= is a synonym for nscale8_video. Think of it is scaling down
|
||||
/// by "a percentage"
|
||||
inline CRGB& operator%= (uint8_t scaledown )
|
||||
{
|
||||
nscale8x3_video( r, g, b, scaledown);
|
||||
return *this;
|
||||
}
|
||||
|
||||
/// fadeLightBy is a synonym for nscale8_video( ..., 255-fadefactor)
|
||||
inline CRGB& fadeLightBy (uint8_t fadefactor )
|
||||
{
|
||||
nscale8x3_video( r, g, b, 255 - fadefactor);
|
||||
return *this;
|
||||
}
|
||||
|
||||
/// scale down a RGB to N 256ths of it's current brightness, using
|
||||
/// 'plain math' dimming rules, which means that if the low light levels
|
||||
/// may dim all the way to 100% black.
|
||||
inline CRGB& nscale8 (uint8_t scaledown )
|
||||
{
|
||||
nscale8x3( r, g, b, scaledown);
|
||||
return *this;
|
||||
}
|
||||
|
||||
/// scale down a RGB to N 256ths of it's current brightness, using
|
||||
/// 'plain math' dimming rules, which means that if the low light levels
|
||||
/// may dim all the way to 100% black.
|
||||
inline CRGB& nscale8 (const CRGB & scaledown )
|
||||
{
|
||||
r = ::scale8(r, scaledown.r);
|
||||
g = ::scale8(g, scaledown.g);
|
||||
b = ::scale8(b, scaledown.b);
|
||||
return *this;
|
||||
}
|
||||
|
||||
/// return a CRGB object that is a scaled down version of this object
|
||||
inline CRGB scale8 (const CRGB & scaledown ) const
|
||||
{
|
||||
CRGB out;
|
||||
out.r = ::scale8(r, scaledown.r);
|
||||
out.g = ::scale8(g, scaledown.g);
|
||||
out.b = ::scale8(b, scaledown.b);
|
||||
return out;
|
||||
}
|
||||
|
||||
/// fadeToBlackBy is a synonym for nscale8( ..., 255-fadefactor)
|
||||
inline CRGB& fadeToBlackBy (uint8_t fadefactor )
|
||||
{
|
||||
nscale8x3( r, g, b, 255 - fadefactor);
|
||||
return *this;
|
||||
}
|
||||
|
||||
/// "or" operator brings each channel up to the higher of the two values
|
||||
inline CRGB& operator|= (const CRGB& rhs )
|
||||
{
|
||||
if( rhs.r > r) r = rhs.r;
|
||||
if( rhs.g > g) g = rhs.g;
|
||||
if( rhs.b > b) b = rhs.b;
|
||||
return *this;
|
||||
}
|
||||
|
||||
/// "or" operator brings each channel up to the higher of the two values
|
||||
inline CRGB& operator|= (uint8_t d )
|
||||
{
|
||||
if( d > r) r = d;
|
||||
if( d > g) g = d;
|
||||
if( d > b) b = d;
|
||||
return *this;
|
||||
}
|
||||
|
||||
/// "and" operator brings each channel down to the lower of the two values
|
||||
inline CRGB& operator&= (const CRGB& rhs )
|
||||
{
|
||||
if( rhs.r < r) r = rhs.r;
|
||||
if( rhs.g < g) g = rhs.g;
|
||||
if( rhs.b < b) b = rhs.b;
|
||||
return *this;
|
||||
}
|
||||
|
||||
/// "and" operator brings each channel down to the lower of the two values
|
||||
inline CRGB& operator&= (uint8_t d )
|
||||
{
|
||||
if( d < r) r = d;
|
||||
if( d < g) g = d;
|
||||
if( d < b) b = d;
|
||||
return *this;
|
||||
}
|
||||
|
||||
/// this allows testing a CRGB for zero-ness
|
||||
inline operator bool() const __attribute__((always_inline))
|
||||
{
|
||||
return r || g || b;
|
||||
}
|
||||
|
||||
/// invert each channel
|
||||
inline CRGB operator- ()
|
||||
{
|
||||
CRGB retval;
|
||||
retval.r = 255 - r;
|
||||
retval.g = 255 - g;
|
||||
retval.b = 255 - b;
|
||||
return retval;
|
||||
}
|
||||
|
||||
#if (defined SmartMatrix_h || defined SmartMatrix3_h)
|
||||
operator rgb24() const {
|
||||
rgb24 ret;
|
||||
ret.red = r;
|
||||
ret.green = g;
|
||||
ret.blue = b;
|
||||
return ret;
|
||||
}
|
||||
#endif
|
||||
|
||||
/// Get the 'luma' of a CRGB object - aka roughly how much light the
|
||||
/// CRGB pixel is putting out (from 0 to 255).
|
||||
inline uint8_t getLuma ( ) const {
|
||||
//Y' = 0.2126 R' + 0.7152 G' + 0.0722 B'
|
||||
// 54 183 18 (!)
|
||||
|
||||
uint8_t luma = scale8_LEAVING_R1_DIRTY( r, 54) + \
|
||||
scale8_LEAVING_R1_DIRTY( g, 183) + \
|
||||
scale8_LEAVING_R1_DIRTY( b, 18);
|
||||
cleanup_R1();
|
||||
return luma;
|
||||
}
|
||||
|
||||
/// Get the average of the R, G, and B values
|
||||
inline uint8_t getAverageLight( ) const {
|
||||
#if FASTLED_SCALE8_FIXED == 1
|
||||
const uint8_t eightyfive = 85;
|
||||
#else
|
||||
const uint8_t eightyfive = 86;
|
||||
#endif
|
||||
uint8_t avg = scale8_LEAVING_R1_DIRTY( r, eightyfive) + \
|
||||
scale8_LEAVING_R1_DIRTY( g, eightyfive) + \
|
||||
scale8_LEAVING_R1_DIRTY( b, eightyfive);
|
||||
cleanup_R1();
|
||||
return avg;
|
||||
}
|
||||
|
||||
/// maximize the brightness of this CRGB object
|
||||
inline void maximizeBrightness( uint8_t limit = 255 ) {
|
||||
uint8_t max = red;
|
||||
if( green > max) max = green;
|
||||
if( blue > max) max = blue;
|
||||
|
||||
// stop div/0 when color is black
|
||||
if(max > 0) {
|
||||
uint16_t factor = ((uint16_t)(limit) * 256) / max;
|
||||
red = (red * factor) / 256;
|
||||
green = (green * factor) / 256;
|
||||
blue = (blue * factor) / 256;
|
||||
}
|
||||
}
|
||||
|
||||
/// return a new CRGB object after performing a linear interpolation between this object and the passed in object
|
||||
inline CRGB lerp8( const CRGB& other, fract8 frac) const
|
||||
{
|
||||
CRGB ret;
|
||||
|
||||
ret.r = lerp8by8(r,other.r,frac);
|
||||
ret.g = lerp8by8(g,other.g,frac);
|
||||
ret.b = lerp8by8(b,other.b,frac);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
/// return a new CRGB object after performing a linear interpolation between this object and the passed in object
|
||||
inline CRGB lerp16( const CRGB& other, fract16 frac) const
|
||||
{
|
||||
CRGB ret;
|
||||
|
||||
ret.r = lerp16by16(r<<8,other.r<<8,frac)>>8;
|
||||
ret.g = lerp16by16(g<<8,other.g<<8,frac)>>8;
|
||||
ret.b = lerp16by16(b<<8,other.b<<8,frac)>>8;
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
/// getParity returns 0 or 1, depending on the
|
||||
/// lowest bit of the sum of the color components.
|
||||
inline uint8_t getParity()
|
||||
{
|
||||
uint8_t sum = r + g + b;
|
||||
return (sum & 0x01);
|
||||
}
|
||||
|
||||
/// setParity adjusts the color in the smallest
|
||||
/// way possible so that the parity of the color
|
||||
/// is now the desired value. This allows you to
|
||||
/// 'hide' one bit of information in the color.
|
||||
///
|
||||
/// Ideally, we find one color channel which already
|
||||
/// has data in it, and modify just that channel by one.
|
||||
/// We don't want to light up a channel that's black
|
||||
/// if we can avoid it, and if the pixel is 'grayscale',
|
||||
/// (meaning that R==G==B), we modify all three channels
|
||||
/// at once, to preserve the neutral hue.
|
||||
///
|
||||
/// There's no such thing as a free lunch; in many cases
|
||||
/// this 'hidden bit' may actually be visible, but this
|
||||
/// code makes reasonable efforts to hide it as much
|
||||
/// as is reasonably possible.
|
||||
///
|
||||
/// Also, an effort is made to have make it such that
|
||||
/// repeatedly setting the parity to different values
|
||||
/// will not cause the color to 'drift'. Toggling
|
||||
/// the parity twice should generally result in the
|
||||
/// original color again.
|
||||
///
|
||||
inline void setParity( uint8_t parity)
|
||||
{
|
||||
uint8_t curparity = getParity();
|
||||
|
||||
if( parity == curparity) return;
|
||||
|
||||
if( parity ) {
|
||||
// going 'up'
|
||||
if( (b > 0) && (b < 255)) {
|
||||
if( r == g && g == b) {
|
||||
r++;
|
||||
g++;
|
||||
}
|
||||
b++;
|
||||
} else if( (r > 0) && (r < 255)) {
|
||||
r++;
|
||||
} else if( (g > 0) && (g < 255)) {
|
||||
g++;
|
||||
} else {
|
||||
if( r == g && g == b) {
|
||||
r ^= 0x01;
|
||||
g ^= 0x01;
|
||||
}
|
||||
b ^= 0x01;
|
||||
}
|
||||
} else {
|
||||
// going 'down'
|
||||
if( b > 1) {
|
||||
if( r == g && g == b) {
|
||||
r--;
|
||||
g--;
|
||||
}
|
||||
b--;
|
||||
} else if( g > 1) {
|
||||
g--;
|
||||
} else if( r > 1) {
|
||||
r--;
|
||||
} else {
|
||||
if( r == g && g == b) {
|
||||
r ^= 0x01;
|
||||
g ^= 0x01;
|
||||
}
|
||||
b ^= 0x01;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Predefined RGB colors
|
||||
typedef enum {
|
||||
AliceBlue=0xF0F8FF,
|
||||
Amethyst=0x9966CC,
|
||||
AntiqueWhite=0xFAEBD7,
|
||||
Aqua=0x00FFFF,
|
||||
Aquamarine=0x7FFFD4,
|
||||
Azure=0xF0FFFF,
|
||||
Beige=0xF5F5DC,
|
||||
Bisque=0xFFE4C4,
|
||||
Black=0x000000,
|
||||
BlanchedAlmond=0xFFEBCD,
|
||||
Blue=0x0000FF,
|
||||
BlueViolet=0x8A2BE2,
|
||||
Brown=0xA52A2A,
|
||||
BurlyWood=0xDEB887,
|
||||
CadetBlue=0x5F9EA0,
|
||||
Chartreuse=0x7FFF00,
|
||||
Chocolate=0xD2691E,
|
||||
Coral=0xFF7F50,
|
||||
CornflowerBlue=0x6495ED,
|
||||
Cornsilk=0xFFF8DC,
|
||||
Crimson=0xDC143C,
|
||||
Cyan=0x00FFFF,
|
||||
DarkBlue=0x00008B,
|
||||
DarkCyan=0x008B8B,
|
||||
DarkGoldenrod=0xB8860B,
|
||||
DarkGray=0xA9A9A9,
|
||||
DarkGrey=0xA9A9A9,
|
||||
DarkGreen=0x006400,
|
||||
DarkKhaki=0xBDB76B,
|
||||
DarkMagenta=0x8B008B,
|
||||
DarkOliveGreen=0x556B2F,
|
||||
DarkOrange=0xFF8C00,
|
||||
DarkOrchid=0x9932CC,
|
||||
DarkRed=0x8B0000,
|
||||
DarkSalmon=0xE9967A,
|
||||
DarkSeaGreen=0x8FBC8F,
|
||||
DarkSlateBlue=0x483D8B,
|
||||
DarkSlateGray=0x2F4F4F,
|
||||
DarkSlateGrey=0x2F4F4F,
|
||||
DarkTurquoise=0x00CED1,
|
||||
DarkViolet=0x9400D3,
|
||||
DeepPink=0xFF1493,
|
||||
DeepSkyBlue=0x00BFFF,
|
||||
DimGray=0x696969,
|
||||
DimGrey=0x696969,
|
||||
DodgerBlue=0x1E90FF,
|
||||
FireBrick=0xB22222,
|
||||
FloralWhite=0xFFFAF0,
|
||||
ForestGreen=0x228B22,
|
||||
Fuchsia=0xFF00FF,
|
||||
Gainsboro=0xDCDCDC,
|
||||
GhostWhite=0xF8F8FF,
|
||||
Gold=0xFFD700,
|
||||
Goldenrod=0xDAA520,
|
||||
Gray=0x808080,
|
||||
Grey=0x808080,
|
||||
Green=0x008000,
|
||||
GreenYellow=0xADFF2F,
|
||||
Honeydew=0xF0FFF0,
|
||||
HotPink=0xFF69B4,
|
||||
IndianRed=0xCD5C5C,
|
||||
Indigo=0x4B0082,
|
||||
Ivory=0xFFFFF0,
|
||||
Khaki=0xF0E68C,
|
||||
Lavender=0xE6E6FA,
|
||||
LavenderBlush=0xFFF0F5,
|
||||
LawnGreen=0x7CFC00,
|
||||
LemonChiffon=0xFFFACD,
|
||||
LightBlue=0xADD8E6,
|
||||
LightCoral=0xF08080,
|
||||
LightCyan=0xE0FFFF,
|
||||
LightGoldenrodYellow=0xFAFAD2,
|
||||
LightGreen=0x90EE90,
|
||||
LightGrey=0xD3D3D3,
|
||||
LightPink=0xFFB6C1,
|
||||
LightSalmon=0xFFA07A,
|
||||
LightSeaGreen=0x20B2AA,
|
||||
LightSkyBlue=0x87CEFA,
|
||||
LightSlateGray=0x778899,
|
||||
LightSlateGrey=0x778899,
|
||||
LightSteelBlue=0xB0C4DE,
|
||||
LightYellow=0xFFFFE0,
|
||||
Lime=0x00FF00,
|
||||
LimeGreen=0x32CD32,
|
||||
Linen=0xFAF0E6,
|
||||
Magenta=0xFF00FF,
|
||||
Maroon=0x800000,
|
||||
MediumAquamarine=0x66CDAA,
|
||||
MediumBlue=0x0000CD,
|
||||
MediumOrchid=0xBA55D3,
|
||||
MediumPurple=0x9370DB,
|
||||
MediumSeaGreen=0x3CB371,
|
||||
MediumSlateBlue=0x7B68EE,
|
||||
MediumSpringGreen=0x00FA9A,
|
||||
MediumTurquoise=0x48D1CC,
|
||||
MediumVioletRed=0xC71585,
|
||||
MidnightBlue=0x191970,
|
||||
MintCream=0xF5FFFA,
|
||||
MistyRose=0xFFE4E1,
|
||||
Moccasin=0xFFE4B5,
|
||||
NavajoWhite=0xFFDEAD,
|
||||
Navy=0x000080,
|
||||
OldLace=0xFDF5E6,
|
||||
Olive=0x808000,
|
||||
OliveDrab=0x6B8E23,
|
||||
Orange=0xFFA500,
|
||||
OrangeRed=0xFF4500,
|
||||
Orchid=0xDA70D6,
|
||||
PaleGoldenrod=0xEEE8AA,
|
||||
PaleGreen=0x98FB98,
|
||||
PaleTurquoise=0xAFEEEE,
|
||||
PaleVioletRed=0xDB7093,
|
||||
PapayaWhip=0xFFEFD5,
|
||||
PeachPuff=0xFFDAB9,
|
||||
Peru=0xCD853F,
|
||||
Pink=0xFFC0CB,
|
||||
Plaid=0xCC5533,
|
||||
Plum=0xDDA0DD,
|
||||
PowderBlue=0xB0E0E6,
|
||||
Purple=0x800080,
|
||||
Red=0xFF0000,
|
||||
RosyBrown=0xBC8F8F,
|
||||
RoyalBlue=0x4169E1,
|
||||
SaddleBrown=0x8B4513,
|
||||
Salmon=0xFA8072,
|
||||
SandyBrown=0xF4A460,
|
||||
SeaGreen=0x2E8B57,
|
||||
Seashell=0xFFF5EE,
|
||||
Sienna=0xA0522D,
|
||||
Silver=0xC0C0C0,
|
||||
SkyBlue=0x87CEEB,
|
||||
SlateBlue=0x6A5ACD,
|
||||
SlateGray=0x708090,
|
||||
SlateGrey=0x708090,
|
||||
Snow=0xFFFAFA,
|
||||
SpringGreen=0x00FF7F,
|
||||
SteelBlue=0x4682B4,
|
||||
Tan=0xD2B48C,
|
||||
Teal=0x008080,
|
||||
Thistle=0xD8BFD8,
|
||||
Tomato=0xFF6347,
|
||||
Turquoise=0x40E0D0,
|
||||
Violet=0xEE82EE,
|
||||
Wheat=0xF5DEB3,
|
||||
White=0xFFFFFF,
|
||||
WhiteSmoke=0xF5F5F5,
|
||||
Yellow=0xFFFF00,
|
||||
YellowGreen=0x9ACD32,
|
||||
|
||||
// LED RGB color that roughly approximates
|
||||
// the color of incandescent fairy lights,
|
||||
// assuming that you're using FastLED
|
||||
// color correction on your LEDs (recommended).
|
||||
FairyLight=0xFFE42D,
|
||||
// If you are using no color correction, use this
|
||||
FairyLightNCC=0xFF9D2A
|
||||
|
||||
} HTMLColorCode;
|
||||
};
|
||||
|
||||
|
||||
inline __attribute__((always_inline)) bool operator== (const CRGB& lhs, const CRGB& rhs)
|
||||
{
|
||||
return (lhs.r == rhs.r) && (lhs.g == rhs.g) && (lhs.b == rhs.b);
|
||||
}
|
||||
|
||||
inline __attribute__((always_inline)) bool operator!= (const CRGB& lhs, const CRGB& rhs)
|
||||
{
|
||||
return !(lhs == rhs);
|
||||
}
|
||||
|
||||
inline __attribute__((always_inline)) bool operator< (const CRGB& lhs, const CRGB& rhs)
|
||||
{
|
||||
uint16_t sl, sr;
|
||||
sl = lhs.r + lhs.g + lhs.b;
|
||||
sr = rhs.r + rhs.g + rhs.b;
|
||||
return sl < sr;
|
||||
}
|
||||
|
||||
inline __attribute__((always_inline)) bool operator> (const CRGB& lhs, const CRGB& rhs)
|
||||
{
|
||||
uint16_t sl, sr;
|
||||
sl = lhs.r + lhs.g + lhs.b;
|
||||
sr = rhs.r + rhs.g + rhs.b;
|
||||
return sl > sr;
|
||||
}
|
||||
|
||||
inline __attribute__((always_inline)) bool operator>= (const CRGB& lhs, const CRGB& rhs)
|
||||
{
|
||||
uint16_t sl, sr;
|
||||
sl = lhs.r + lhs.g + lhs.b;
|
||||
sr = rhs.r + rhs.g + rhs.b;
|
||||
return sl >= sr;
|
||||
}
|
||||
|
||||
inline __attribute__((always_inline)) bool operator<= (const CRGB& lhs, const CRGB& rhs)
|
||||
{
|
||||
uint16_t sl, sr;
|
||||
sl = lhs.r + lhs.g + lhs.b;
|
||||
sr = rhs.r + rhs.g + rhs.b;
|
||||
return sl <= sr;
|
||||
}
|
||||
|
||||
|
||||
__attribute__((always_inline))
|
||||
inline CRGB operator+( const CRGB& p1, const CRGB& p2)
|
||||
{
|
||||
return CRGB( qadd8( p1.r, p2.r),
|
||||
qadd8( p1.g, p2.g),
|
||||
qadd8( p1.b, p2.b));
|
||||
}
|
||||
|
||||
__attribute__((always_inline))
|
||||
inline CRGB operator-( const CRGB& p1, const CRGB& p2)
|
||||
{
|
||||
return CRGB( qsub8( p1.r, p2.r),
|
||||
qsub8( p1.g, p2.g),
|
||||
qsub8( p1.b, p2.b));
|
||||
}
|
||||
|
||||
__attribute__((always_inline))
|
||||
inline CRGB operator*( const CRGB& p1, uint8_t d)
|
||||
{
|
||||
return CRGB( qmul8( p1.r, d),
|
||||
qmul8( p1.g, d),
|
||||
qmul8( p1.b, d));
|
||||
}
|
||||
|
||||
__attribute__((always_inline))
|
||||
inline CRGB operator/( const CRGB& p1, uint8_t d)
|
||||
{
|
||||
return CRGB( p1.r/d, p1.g/d, p1.b/d);
|
||||
}
|
||||
|
||||
|
||||
__attribute__((always_inline))
|
||||
inline CRGB operator&( const CRGB& p1, const CRGB& p2)
|
||||
{
|
||||
return CRGB( p1.r < p2.r ? p1.r : p2.r,
|
||||
p1.g < p2.g ? p1.g : p2.g,
|
||||
p1.b < p2.b ? p1.b : p2.b);
|
||||
}
|
||||
|
||||
__attribute__((always_inline))
|
||||
inline CRGB operator|( const CRGB& p1, const CRGB& p2)
|
||||
{
|
||||
return CRGB( p1.r > p2.r ? p1.r : p2.r,
|
||||
p1.g > p2.g ? p1.g : p2.g,
|
||||
p1.b > p2.b ? p1.b : p2.b);
|
||||
}
|
||||
|
||||
__attribute__((always_inline))
|
||||
inline CRGB operator%( const CRGB& p1, uint8_t d)
|
||||
{
|
||||
CRGB retval( p1);
|
||||
retval.nscale8_video( d);
|
||||
return retval;
|
||||
}
|
||||
|
||||
|
||||
|
||||
/// RGB orderings, used when instantiating controllers to determine what
|
||||
/// order the controller should send RGB data out in, RGB being the default
|
||||
/// ordering.
|
||||
enum EOrder {
|
||||
RGB=0012,
|
||||
RBG=0021,
|
||||
GRB=0102,
|
||||
GBR=0120,
|
||||
BRG=0201,
|
||||
BGR=0210
|
||||
};
|
||||
|
||||
FASTLED_NAMESPACE_END
|
||||
///@}
|
||||
|
||||
#endif
|
||||
40
components/FastLED-idf/platforms.cpp
Normal file
40
components/FastLED-idf/platforms.cpp
Normal file
@ -0,0 +1,40 @@
|
||||
#define FASTLED_INTERNAL
|
||||
|
||||
|
||||
// Interrupt handlers cannot be defined in the header.
|
||||
// They must be defined as C functions, or they won't
|
||||
// be found (due to name mangling), and thus won't
|
||||
// override any default weak definition.
|
||||
#if defined(NRF52_SERIES)
|
||||
|
||||
#include "platforms/arm/nrf52/led_sysdefs_arm_nrf52.h"
|
||||
#include "platforms/arm/nrf52/arbiter_nrf52.h"
|
||||
|
||||
uint32_t isrCount;
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
// NOTE: Update platforms.cpp in root of FastLED library if this changes
|
||||
#if defined(FASTLED_NRF52_ENABLE_PWM_INSTANCE0)
|
||||
void PWM0_IRQHandler(void) { isrCount++; PWM_Arbiter<0>::isr_handler(); }
|
||||
#endif
|
||||
#if defined(FASTLED_NRF52_ENABLE_PWM_INSTANCE1)
|
||||
void PWM1_IRQHandler(void) { isrCount++; PWM_Arbiter<1>::isr_handler(); }
|
||||
#endif
|
||||
#if defined(FASTLED_NRF52_ENABLE_PWM_INSTANCE2)
|
||||
void PWM2_IRQHandler(void) { isrCount++; PWM_Arbiter<2>::isr_handler(); }
|
||||
#endif
|
||||
#if defined(FASTLED_NRF52_ENABLE_PWM_INSTANCE3)
|
||||
void PWM3_IRQHandler(void) { isrCount++; PWM_Arbiter<3>::isr_handler(); }
|
||||
#endif
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif // defined(NRF52_SERIES)
|
||||
|
||||
|
||||
|
||||
// FASTLED_NAMESPACE_BEGIN
|
||||
// FASTLED_NAMESPACE_END
|
||||
42
components/FastLED-idf/platforms.h
Normal file
42
components/FastLED-idf/platforms.h
Normal file
@ -0,0 +1,42 @@
|
||||
#ifndef __INC_PLATFORMS_H
|
||||
#define __INC_PLATFORMS_H
|
||||
|
||||
#include "FastLED.h"
|
||||
|
||||
#include "fastled_config.h"
|
||||
|
||||
#if defined(NRF51)
|
||||
#include "platforms/arm/nrf51/fastled_arm_nrf51.h"
|
||||
#elif defined(NRF52_SERIES)
|
||||
#include "platforms/arm/nrf52/fastled_arm_nrf52.h"
|
||||
#elif defined(__MK20DX128__) || defined(__MK20DX256__)
|
||||
// Include k20/T3 headers
|
||||
#include "platforms/arm/k20/fastled_arm_k20.h"
|
||||
#elif defined(__MK66FX1M0__) || defined(__MK64FX512__)
|
||||
// Include k66/T3.6 headers
|
||||
#include "platforms/arm/k66/fastled_arm_k66.h"
|
||||
#elif defined(__MKL26Z64__)
|
||||
// Include kl26/T-LC headers
|
||||
#include "platforms/arm/kl26/fastled_arm_kl26.h"
|
||||
#elif defined(__IMXRT1062__)
|
||||
// teensy4
|
||||
#include "platforms/arm/mxrt1062/fastled_arm_mxrt1062.h"
|
||||
#elif defined(__SAM3X8E__)
|
||||
// Include sam/due headers
|
||||
#include "platforms/arm/sam/fastled_arm_sam.h"
|
||||
#elif defined(STM32F10X_MD) || defined(__STM32F1__)
|
||||
#include "platforms/arm/stm32/fastled_arm_stm32.h"
|
||||
#elif defined(__SAMD21G18A__) || defined(__SAMD21J18A__) || defined(__SAMD21E17A__) || defined(__SAMD21E18A__)
|
||||
#include "platforms/arm/d21/fastled_arm_d21.h"
|
||||
#elif defined(__SAMD51G19A__) || defined(__SAMD51J19A__)
|
||||
#include "platforms/arm/d51/fastled_arm_d51.h"
|
||||
#elif defined(ESP8266)
|
||||
#include "platforms/esp/8266/fastled_esp8266.h"
|
||||
#elif defined(ESP32)
|
||||
#include "platforms/esp/32/fastled_esp32.h"
|
||||
#else
|
||||
// AVR platforms
|
||||
#include "platforms/avr/fastled_avr.h"
|
||||
#endif
|
||||
|
||||
#endif
|
||||
168
components/FastLED-idf/platforms/esp/32/clockless_block_esp32.h
Normal file
168
components/FastLED-idf/platforms/esp/32/clockless_block_esp32.h
Normal file
@ -0,0 +1,168 @@
|
||||
#ifndef __INC_CLOCKLESS_BLOCK_ESP8266_H
|
||||
#define __INC_CLOCKLESS_BLOCK_ESP8266_H
|
||||
|
||||
#define FASTLED_HAS_BLOCKLESS 1
|
||||
|
||||
#define PORT_MASK (((1<<LANES)-1) & 0x0000FFFFL)
|
||||
#define MIN(X,Y) (((X)<(Y)) ? (X):(Y))
|
||||
#define USED_LANES (MIN(LANES,4))
|
||||
#define REAL_FIRST_PIN 12
|
||||
#define LAST_PIN (12 + USED_LANES - 1)
|
||||
|
||||
FASTLED_NAMESPACE_BEGIN
|
||||
|
||||
#ifdef FASTLED_DEBUG_COUNT_FRAME_RETRIES
|
||||
extern uint32_t _frame_cnt;
|
||||
extern uint32_t _retry_cnt;
|
||||
#endif
|
||||
|
||||
template <uint8_t LANES, int FIRST_PIN, int T1, int T2, int T3, EOrder RGB_ORDER = GRB, int XTRA0 = 0, bool FLIP = false, int WAIT_TIME = 5>
|
||||
class InlineBlockClocklessController : public CPixelLEDController<RGB_ORDER, LANES, PORT_MASK> {
|
||||
typedef typename FastPin<FIRST_PIN>::port_ptr_t data_ptr_t;
|
||||
typedef typename FastPin<FIRST_PIN>::port_t data_t;
|
||||
|
||||
data_t mPinMask;
|
||||
data_ptr_t mPort;
|
||||
CMinWait<WAIT_TIME> mWait;
|
||||
public:
|
||||
virtual int size() { return CLEDController::size() * LANES; }
|
||||
|
||||
virtual void showPixels(PixelController<RGB_ORDER, LANES, PORT_MASK> & pixels) {
|
||||
// mWait.wait();
|
||||
/*uint32_t clocks = */
|
||||
int cnt=FASTLED_INTERRUPT_RETRY_COUNT;
|
||||
while(!showRGBInternal(pixels) && cnt--) {
|
||||
ets_intr_unlock();
|
||||
#ifdef FASTLED_DEBUG_COUNT_FRAME_RETRIES
|
||||
_retry_cnt++;
|
||||
#endif
|
||||
delayMicroseconds(WAIT_TIME * 10);
|
||||
ets_intr_lock();
|
||||
}
|
||||
// #if FASTLED_ALLOW_INTTERUPTS == 0
|
||||
// Adjust the timer
|
||||
// long microsTaken = CLKS_TO_MICROS(clocks);
|
||||
// MS_COUNTER += (1 + (microsTaken / 1000));
|
||||
// #endif
|
||||
|
||||
// mWait.mark();
|
||||
}
|
||||
|
||||
template<int PIN> static void initPin() {
|
||||
if(PIN >= REAL_FIRST_PIN && PIN <= LAST_PIN) {
|
||||
_ESPPIN<PIN, 1<<(PIN & 0xFF)>::setOutput();
|
||||
// FastPin<PIN>::setOutput();
|
||||
}
|
||||
}
|
||||
|
||||
virtual void init() {
|
||||
// Only supportd on pins 12-15
|
||||
// SZG: This probably won't work (check pins definitions in fastpin_esp32)
|
||||
initPin<12>();
|
||||
initPin<13>();
|
||||
initPin<14>();
|
||||
initPin<15>();
|
||||
mPinMask = FastPin<FIRST_PIN>::mask();
|
||||
mPort = FastPin<FIRST_PIN>::port();
|
||||
|
||||
// Serial.print("Mask is "); Serial.println(PORT_MASK);
|
||||
}
|
||||
|
||||
virtual uint16_t getMaxRefreshRate() const { return 400; }
|
||||
|
||||
typedef union {
|
||||
uint8_t bytes[8];
|
||||
uint16_t shorts[4];
|
||||
uint32_t raw[2];
|
||||
} Lines;
|
||||
|
||||
#define ESP_ADJUST 0 // (2*(F_CPU/24000000))
|
||||
#define ESP_ADJUST2 0
|
||||
template<int BITS,int PX> __attribute__ ((always_inline)) inline static void writeBits(register uint32_t & last_mark, register Lines & b, PixelController<RGB_ORDER, LANES, PORT_MASK> &pixels) { // , register uint32_t & b2) {
|
||||
Lines b2 = b;
|
||||
transpose8x1_noinline(b.bytes,b2.bytes);
|
||||
|
||||
register uint8_t d = pixels.template getd<PX>(pixels);
|
||||
register uint8_t scale = pixels.template getscale<PX>(pixels);
|
||||
|
||||
for(register uint32_t i = 0; i < USED_LANES; i++) {
|
||||
while((__clock_cycles() - last_mark) < (T1+T2+T3));
|
||||
last_mark = __clock_cycles();
|
||||
*FastPin<FIRST_PIN>::sport() = PORT_MASK << REAL_FIRST_PIN;
|
||||
|
||||
uint32_t nword = ((uint32_t)(~b2.bytes[7-i]) & PORT_MASK) << REAL_FIRST_PIN;
|
||||
while((__clock_cycles() - last_mark) < (T1-6));
|
||||
*FastPin<FIRST_PIN>::cport() = nword;
|
||||
|
||||
while((__clock_cycles() - last_mark) < (T1+T2));
|
||||
*FastPin<FIRST_PIN>::cport() = PORT_MASK << REAL_FIRST_PIN;
|
||||
|
||||
b.bytes[i] = pixels.template loadAndScale<PX>(pixels,i,d,scale);
|
||||
}
|
||||
|
||||
for(register uint32_t i = USED_LANES; i < 8; i++) {
|
||||
while((__clock_cycles() - last_mark) < (T1+T2+T3));
|
||||
last_mark = __clock_cycles();
|
||||
*FastPin<FIRST_PIN>::sport() = PORT_MASK << REAL_FIRST_PIN;
|
||||
|
||||
uint32_t nword = ((uint32_t)(~b2.bytes[7-i]) & PORT_MASK) << REAL_FIRST_PIN;
|
||||
while((__clock_cycles() - last_mark) < (T1-6));
|
||||
*FastPin<FIRST_PIN>::cport() = nword;
|
||||
|
||||
while((__clock_cycles() - last_mark) < (T1+T2));
|
||||
*FastPin<FIRST_PIN>::cport() = PORT_MASK << REAL_FIRST_PIN;
|
||||
}
|
||||
}
|
||||
|
||||
// This method is made static to force making register Y available to use for data on AVR - if the method is non-static, then
|
||||
// gcc will use register Y for the this pointer.
|
||||
static uint32_t showRGBInternal(PixelController<RGB_ORDER, LANES, PORT_MASK> &allpixels) {
|
||||
|
||||
// Setup the pixel controller and load/scale the first byte
|
||||
Lines b0;
|
||||
|
||||
for(int i = 0; i < USED_LANES; i++) {
|
||||
b0.bytes[i] = allpixels.loadAndScale0(i);
|
||||
}
|
||||
allpixels.preStepFirstByteDithering();
|
||||
|
||||
ets_intr_lock();
|
||||
uint32_t _start = __clock_cycles();
|
||||
uint32_t last_mark = _start;
|
||||
|
||||
while(allpixels.has(1)) {
|
||||
// Write first byte, read next byte
|
||||
writeBits<8+XTRA0,1>(last_mark, b0, allpixels);
|
||||
|
||||
// Write second byte, read 3rd byte
|
||||
writeBits<8+XTRA0,2>(last_mark, b0, allpixels);
|
||||
allpixels.advanceData();
|
||||
|
||||
// Write third byte
|
||||
writeBits<8+XTRA0,0>(last_mark, b0, allpixels);
|
||||
|
||||
#if (FASTLED_ALLOW_INTERRUPTS == 1)
|
||||
ets_intr_unlock();
|
||||
#endif
|
||||
|
||||
allpixels.stepDithering();
|
||||
|
||||
#if (FASTLED_ALLOW_INTERRUPTS == 1)
|
||||
ets_intr_lock();
|
||||
// if interrupts took longer than 45µs, punt on the current frame
|
||||
if((int32_t)(__clock_cycles()-last_mark) > 0) {
|
||||
if((int32_t)(__clock_cycles()-last_mark) > (T1+T2+T3+((WAIT_TIME-INTERRUPT_THRESHOLD)*CLKS_PER_US))) { ets_intr_unlock(); return 0; }
|
||||
}
|
||||
#endif
|
||||
};
|
||||
|
||||
ets_intr_unlock();
|
||||
#ifdef FASTLED_DEBUG_COUNT_FRAME_RETRIES
|
||||
_frame_cnt++;
|
||||
#endif
|
||||
return __clock_cycles() - _start;
|
||||
}
|
||||
};
|
||||
|
||||
FASTLED_NAMESPACE_END
|
||||
#endif
|
||||
786
components/FastLED-idf/platforms/esp/32/clockless_esp32.h.orig
Normal file
786
components/FastLED-idf/platforms/esp/32/clockless_esp32.h.orig
Normal file
@ -0,0 +1,786 @@
|
||||
/*
|
||||
* Integration into FastLED ClocklessController 2017 Thomas Basler
|
||||
*
|
||||
* Modifications Copyright (c) 2017 Martin F. Falatic
|
||||
*
|
||||
* Modifications Copyright (c) 2018 Samuel Z. Guyer
|
||||
*
|
||||
* ESP32 support is provided using the RMT peripheral device -- a unit
|
||||
* on the chip designed specifically for generating (and receiving)
|
||||
* precisely-timed digital signals. Nominally for use in infrared
|
||||
* remote controls, we use it to generate the signals for clockless
|
||||
* LED strips. The main advantage of using the RMT device is that,
|
||||
* once programmed, it generates the signal asynchronously, allowing
|
||||
* the CPU to continue executing other code. It is also not vulnerable
|
||||
* to interrupts or other timing problems that could disrupt the signal.
|
||||
*
|
||||
* The implementation strategy is borrowed from previous work and from
|
||||
* the RMT support built into the ESP32 IDF. The RMT device has 8
|
||||
* channels, which can be programmed independently to send sequences
|
||||
* of high/low bits. Memory for each channel is limited, however, so
|
||||
* in order to send a long sequence of bits, we need to continuously
|
||||
* refill the buffer until all the data is sent. To do this, we fill
|
||||
* half the buffer and then set an interrupt to go off when that half
|
||||
* is sent. Then we refill that half while the second half is being
|
||||
* sent. This strategy effectively overlaps computation (by the CPU)
|
||||
* and communication (by the RMT).
|
||||
*
|
||||
* Since the RMT device only has 8 channels, we need a strategy to
|
||||
* allow more than 8 LED controllers. Our driver assigns controllers
|
||||
* to channels on the fly, queuing up controllers as necessary until a
|
||||
* channel is free. The main showPixels routine just fires off the
|
||||
* first 8 controllers; the interrupt handler starts new controllers
|
||||
* asynchronously as previous ones finish. So, for example, it can
|
||||
* send the data for 8 controllers simultaneously, but 16 controllers
|
||||
* would take approximately twice as much time.
|
||||
*
|
||||
* There is a #define that allows a program to control the total
|
||||
* number of channels that the driver is allowed to use. It defaults
|
||||
* to 8 -- use all the channels. Setting it to 1, for example, results
|
||||
* in fully serial output:
|
||||
*
|
||||
* #define FASTLED_RMT_MAX_CHANNELS 1
|
||||
*
|
||||
* OTHER RMT APPLICATIONS
|
||||
*
|
||||
* The default FastLED driver takes over control of the RMT interrupt
|
||||
* handler, making it hard to use the RMT device for other
|
||||
* (non-FastLED) purposes. You can change it's behavior to use the ESP
|
||||
* core driver instead, allowing other RMT applications to
|
||||
* co-exist. To switch to this mode, add the following directive
|
||||
* before you include FastLED.h:
|
||||
*
|
||||
* #define FASTLED_RMT_BUILTIN_DRIVER
|
||||
*
|
||||
* There may be a performance penalty for using this mode. We need to
|
||||
* compute the RMT signal for the entire LED strip ahead of time,
|
||||
* rather than overlapping it with communication. We also need a large
|
||||
* buffer to hold the signal specification. Each bit of pixel data is
|
||||
* represented by a 32-bit pulse specification, so it is a 32X blow-up
|
||||
* in memory use.
|
||||
*
|
||||
*
|
||||
* Based on public domain code created 19 Nov 2016 by Chris Osborn <fozztexx@fozztexx.com>
|
||||
* http://insentricity.com *
|
||||
*
|
||||
*/
|
||||
/*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
* of this software and associated documentation files (the "Software"), to deal
|
||||
* in the Software without restriction, including without limitation the rights
|
||||
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
* copies of the Software, and to permit persons to whom the Software is
|
||||
* furnished to do so, subject to the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice shall be included in
|
||||
* all copies or substantial portions of the Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
||||
* THE SOFTWARE.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
|
||||
FASTLED_NAMESPACE_BEGIN
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#include "esp32-hal.h"
|
||||
#include "esp_intr.h"
|
||||
#include "driver/gpio.h"
|
||||
#include "driver/rmt.h"
|
||||
#include "driver/periph_ctrl.h"
|
||||
#include "freertos/semphr.h"
|
||||
#include "soc/rmt_struct.h"
|
||||
|
||||
#include "esp_log.h"
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
__attribute__ ((always_inline)) inline static uint32_t __clock_cycles() {
|
||||
uint32_t cyc;
|
||||
__asm__ __volatile__ ("rsr %0,ccount":"=a" (cyc));
|
||||
return cyc;
|
||||
}
|
||||
|
||||
#define FASTLED_HAS_CLOCKLESS 1
|
||||
|
||||
// -- Configuration constants
|
||||
#define DIVIDER 2 /* 4, 8 still seem to work, but timings become marginal */
|
||||
#define MAX_PULSES 32 /* A channel has a 64 "pulse" buffer - we use half per pass */
|
||||
|
||||
// -- Convert ESP32 cycles back into nanoseconds
|
||||
#define ESPCLKS_TO_NS(_CLKS) (((long)(_CLKS) * 1000L) / F_CPU_MHZ)
|
||||
|
||||
// -- Convert nanoseconds into RMT cycles
|
||||
#define F_CPU_RMT ( 80000000L)
|
||||
#define NS_PER_SEC (1000000000L)
|
||||
#define CYCLES_PER_SEC (F_CPU_RMT/DIVIDER)
|
||||
#define NS_PER_CYCLE ( NS_PER_SEC / CYCLES_PER_SEC )
|
||||
#define NS_TO_CYCLES(n) ( (n) / NS_PER_CYCLE )
|
||||
|
||||
// -- Convert ESP32 cycles to RMT cycles
|
||||
#define TO_RMT_CYCLES(_CLKS) NS_TO_CYCLES(ESPCLKS_TO_NS(_CLKS))
|
||||
|
||||
// -- Number of cycles to signal the strip to latch
|
||||
#define RMT_RESET_DURATION NS_TO_CYCLES(50000)
|
||||
|
||||
// -- Core or custom driver
|
||||
#ifndef FASTLED_RMT_BUILTIN_DRIVER
|
||||
#define FASTLED_RMT_BUILTIN_DRIVER false
|
||||
#endif
|
||||
|
||||
// -- Max number of controllers we can support
|
||||
#ifndef FASTLED_RMT_MAX_CONTROLLERS
|
||||
#define FASTLED_RMT_MAX_CONTROLLERS 32
|
||||
#endif
|
||||
|
||||
// -- Number of RMT channels to use (up to 8)
|
||||
// Redefine this value to 1 to force serial output
|
||||
#ifndef FASTLED_RMT_MAX_CHANNELS
|
||||
#define FASTLED_RMT_MAX_CHANNELS 8
|
||||
#endif
|
||||
|
||||
// -- Array of all controllers
|
||||
static CLEDController * gControllers[FASTLED_RMT_MAX_CONTROLLERS];
|
||||
|
||||
// -- Current set of active controllers, indexed by the RMT
|
||||
// channel assigned to them.
|
||||
static CLEDController * gOnChannel[FASTLED_RMT_MAX_CHANNELS];
|
||||
|
||||
static int gNumControllers = 0;
|
||||
static int gNumStarted = 0;
|
||||
static int gNumDone = 0;
|
||||
static int gNext = 0;
|
||||
|
||||
static intr_handle_t gRMT_intr_handle = NULL;
|
||||
|
||||
// -- Global semaphore for the whole show process
|
||||
// Semaphore is not given until all data has been sent
|
||||
static xSemaphoreHandle gTX_sem = NULL;
|
||||
|
||||
static bool gInitialized = false;
|
||||
|
||||
template <int DATA_PIN, int T1, int T2, int T3, EOrder RGB_ORDER = RGB, int XTRA0 = 0, bool FLIP = false, int WAIT_TIME = 5>
|
||||
class ClocklessController : public CPixelLEDController<RGB_ORDER>
|
||||
{
|
||||
// -- RMT has 8 channels, numbered 0 to 7
|
||||
rmt_channel_t mRMT_channel;
|
||||
|
||||
// -- Store the GPIO pin
|
||||
gpio_num_t mPin;
|
||||
<<<<<<< HEAD
|
||||
|
||||
// -- This instantiation forces a check on the pin choice
|
||||
FastPin<DATA_PIN> mFastPin;
|
||||
|
||||
// -- Timing values for zero and one bits, derived from T1, T2, and T3
|
||||
rmt_item32_t mZero;
|
||||
rmt_item32_t mOne;
|
||||
|
||||
=======
|
||||
|
||||
// -- Timing values for zero and one bits, derived from T1, T2, and T3
|
||||
rmt_item32_t mZero;
|
||||
rmt_item32_t mOne;
|
||||
|
||||
>>>>>>> upstream/master
|
||||
// -- State information for keeping track of where we are in the pixel data
|
||||
PixelController<RGB_ORDER> * mPixels = NULL;
|
||||
void * mPixelSpace = NULL;
|
||||
uint8_t mRGB_channel;
|
||||
uint16_t mCurPulse;
|
||||
|
||||
// -- Buffer to hold all of the pulses. For the version that uses
|
||||
// the RMT driver built into the ESP core.
|
||||
rmt_item32_t * mBuffer;
|
||||
uint16_t mBufferSize;
|
||||
|
||||
public:
|
||||
|
||||
virtual void init()
|
||||
{
|
||||
// -- Precompute rmt items corresponding to a zero bit and a one bit
|
||||
// according to the timing values given in the template instantiation
|
||||
// T1H
|
||||
mOne.level0 = 1;
|
||||
mOne.duration0 = TO_RMT_CYCLES(T1+T2);
|
||||
// T1L
|
||||
mOne.level1 = 0;
|
||||
mOne.duration1 = TO_RMT_CYCLES(T3);
|
||||
|
||||
// T0H
|
||||
mZero.level0 = 1;
|
||||
mZero.duration0 = TO_RMT_CYCLES(T1);
|
||||
// T0L
|
||||
mZero.level1 = 0;
|
||||
mZero.duration1 = TO_RMT_CYCLES(T2 + T3);
|
||||
|
||||
<<<<<<< HEAD
|
||||
gControllers[gNumControllers] = this;
|
||||
gNumControllers++;
|
||||
|
||||
mPin = gpio_num_t(DATA_PIN);
|
||||
=======
|
||||
gControllers[gNumControllers] = this;
|
||||
gNumControllers++;
|
||||
|
||||
mPin = gpio_num_t(DATA_PIN);
|
||||
>>>>>>> upstream/master
|
||||
}
|
||||
|
||||
virtual uint16_t getMaxRefreshRate() const { return 400; }
|
||||
|
||||
protected:
|
||||
|
||||
void initRMT()
|
||||
{
|
||||
<<<<<<< HEAD
|
||||
// -- Only need to do this once
|
||||
if (gInitialized) return;
|
||||
|
||||
for (int i = 0; i < FASTLED_RMT_MAX_CHANNELS; i++) {
|
||||
gOnChannel[i] = NULL;
|
||||
|
||||
// -- RMT configuration for transmission
|
||||
rmt_config_t rmt_tx;
|
||||
rmt_tx.channel = rmt_channel_t(i);
|
||||
rmt_tx.rmt_mode = RMT_MODE_TX;
|
||||
rmt_tx.gpio_num = mPin; // The particular pin will be assigned later
|
||||
rmt_tx.mem_block_num = 1;
|
||||
rmt_tx.clk_div = DIVIDER;
|
||||
rmt_tx.tx_config.loop_en = false;
|
||||
rmt_tx.tx_config.carrier_level = RMT_CARRIER_LEVEL_LOW;
|
||||
rmt_tx.tx_config.carrier_en = false;
|
||||
rmt_tx.tx_config.idle_level = RMT_IDLE_LEVEL_LOW;
|
||||
rmt_tx.tx_config.idle_output_en = true;
|
||||
|
||||
// -- Apply the configuration
|
||||
rmt_config(&rmt_tx);
|
||||
|
||||
if (FASTLED_RMT_BUILTIN_DRIVER) {
|
||||
rmt_driver_install(rmt_channel_t(i), 0, 0);
|
||||
} else {
|
||||
// -- Set up the RMT to send 1/2 of the pulse buffer and then
|
||||
// generate an interrupt. When we get this interrupt we
|
||||
// fill the other half in preparation (kind of like double-buffering)
|
||||
rmt_set_tx_thr_intr_en(rmt_channel_t(i), true, MAX_PULSES);
|
||||
}
|
||||
}
|
||||
|
||||
// -- Create a semaphore to block execution until all the controllers are done
|
||||
if (gTX_sem == NULL) {
|
||||
gTX_sem = xSemaphoreCreateBinary();
|
||||
xSemaphoreGive(gTX_sem);
|
||||
}
|
||||
|
||||
if ( ! FASTLED_RMT_BUILTIN_DRIVER) {
|
||||
// -- Allocate the interrupt if we have not done so yet. This
|
||||
// interrupt handler must work for all different kinds of
|
||||
// strips, so it delegates to the refill function for each
|
||||
// specific instantiation of ClocklessController.
|
||||
if (gRMT_intr_handle == NULL)
|
||||
esp_intr_alloc(ETS_RMT_INTR_SOURCE, 0, interruptHandler, 0, &gRMT_intr_handle);
|
||||
}
|
||||
|
||||
gInitialized = true;
|
||||
}
|
||||
|
||||
virtual void showPixels(PixelController<RGB_ORDER> & pixels)
|
||||
{
|
||||
if (gNumStarted == 0) {
|
||||
// -- First controller: make sure everything is set up
|
||||
initRMT();
|
||||
xSemaphoreTake(gTX_sem, portMAX_DELAY);
|
||||
}
|
||||
|
||||
// -- Initialize the local state, save a pointer to the pixel
|
||||
// data. We need to make a copy because pixels is a local
|
||||
// variable in the calling function, and this data structure
|
||||
// needs to outlive this call to showPixels.
|
||||
|
||||
if (mPixels != NULL) delete mPixels;
|
||||
mPixels = new PixelController<RGB_ORDER>(pixels);
|
||||
|
||||
// -- Keep track of the number of strips we've seen
|
||||
gNumStarted++;
|
||||
|
||||
// -- The last call to showPixels is the one responsible for doing
|
||||
// all of the actual worl
|
||||
if (gNumStarted == gNumControllers) {
|
||||
gNext = 0;
|
||||
|
||||
// -- First, fill all the available channels
|
||||
int channel = 0;
|
||||
while (channel < FASTLED_RMT_MAX_CHANNELS && gNext < gNumControllers) {
|
||||
startNext(channel);
|
||||
channel++;
|
||||
}
|
||||
|
||||
// -- Wait here while the rest of the data is sent. The interrupt handler
|
||||
// will keep refilling the RMT buffers until it is all sent; then it
|
||||
// gives the semaphore back.
|
||||
xSemaphoreTake(gTX_sem, portMAX_DELAY);
|
||||
xSemaphoreGive(gTX_sem);
|
||||
|
||||
// -- Reset the counters
|
||||
gNumStarted = 0;
|
||||
gNumDone = 0;
|
||||
gNext = 0;
|
||||
}
|
||||
}
|
||||
|
||||
// -- Start up the next controller
|
||||
// This method is static so that it can dispatch to the appropriate
|
||||
// startOnChannel method of the given controller.
|
||||
static void startNext(int channel)
|
||||
{
|
||||
if (gNext < gNumControllers) {
|
||||
ClocklessController * pController = static_cast<ClocklessController*>(gControllers[gNext]);
|
||||
pController->startOnChannel(channel);
|
||||
gNext++;
|
||||
}
|
||||
}
|
||||
|
||||
virtual void startOnChannel(int channel)
|
||||
{
|
||||
// -- Assign this channel and configure the RMT
|
||||
mRMT_channel = rmt_channel_t(channel);
|
||||
|
||||
// -- Store a reference to this controller, so we can get it
|
||||
// inside the interrupt handler
|
||||
gOnChannel[channel] = this;
|
||||
|
||||
// -- Assign the pin to this channel
|
||||
rmt_set_pin(mRMT_channel, RMT_MODE_TX, mPin);
|
||||
|
||||
if (FASTLED_RMT_BUILTIN_DRIVER) {
|
||||
// -- Use the built-in RMT driver to send all the data in one shot
|
||||
rmt_register_tx_end_callback(doneOnChannel, 0);
|
||||
writeAllRMTItems();
|
||||
} else {
|
||||
// -- Use our custom driver to send the data incrementally
|
||||
|
||||
// -- Turn on the interrupts
|
||||
rmt_set_tx_intr_en(mRMT_channel, true);
|
||||
|
||||
// -- Initialize the counters that keep track of where we are in
|
||||
// the pixel data.
|
||||
mCurPulse = 0;
|
||||
mRGB_channel = 0;
|
||||
|
||||
// -- Fill both halves of the buffer
|
||||
fillHalfRMTBuffer();
|
||||
fillHalfRMTBuffer();
|
||||
|
||||
// -- Turn on the interrupts
|
||||
rmt_set_tx_intr_en(mRMT_channel, true);
|
||||
|
||||
// -- Start the RMT TX operation
|
||||
rmt_tx_start(mRMT_channel, true);
|
||||
}
|
||||
}
|
||||
|
||||
static void doneOnChannel(rmt_channel_t channel, void * arg)
|
||||
{
|
||||
ClocklessController * controller = static_cast<ClocklessController*>(gOnChannel[channel]);
|
||||
portBASE_TYPE HPTaskAwoken = 0;
|
||||
|
||||
// -- Turn off output on the pin
|
||||
gpio_matrix_out(controller->mPin, 0x100, 0, 0);
|
||||
|
||||
gOnChannel[channel] = NULL;
|
||||
gNumDone++;
|
||||
|
||||
if (gNumDone == gNumControllers) {
|
||||
// -- If this is the last controller, signal that we are all done
|
||||
xSemaphoreGiveFromISR(gTX_sem, &HPTaskAwoken);
|
||||
if(HPTaskAwoken == pdTRUE) portYIELD_FROM_ISR();
|
||||
} else {
|
||||
// -- Otherwise, if there are still controllers waiting, then
|
||||
// start the next one on this channel
|
||||
if (gNext < gNumControllers)
|
||||
startNext(channel);
|
||||
}
|
||||
=======
|
||||
// -- Only need to do this once
|
||||
if (gInitialized) return;
|
||||
|
||||
for (int i = 0; i < FASTLED_RMT_MAX_CHANNELS; i++) {
|
||||
gOnChannel[i] = NULL;
|
||||
|
||||
// -- RMT configuration for transmission
|
||||
rmt_config_t rmt_tx;
|
||||
rmt_tx.channel = rmt_channel_t(i);
|
||||
rmt_tx.rmt_mode = RMT_MODE_TX;
|
||||
rmt_tx.gpio_num = mPin; // The particular pin will be assigned later
|
||||
rmt_tx.mem_block_num = 1;
|
||||
rmt_tx.clk_div = DIVIDER;
|
||||
rmt_tx.tx_config.loop_en = false;
|
||||
rmt_tx.tx_config.carrier_level = RMT_CARRIER_LEVEL_LOW;
|
||||
rmt_tx.tx_config.carrier_en = false;
|
||||
rmt_tx.tx_config.idle_level = RMT_IDLE_LEVEL_LOW;
|
||||
rmt_tx.tx_config.idle_output_en = true;
|
||||
|
||||
// -- Apply the configuration
|
||||
rmt_config(&rmt_tx);
|
||||
|
||||
if (FASTLED_RMT_BUILTIN_DRIVER) {
|
||||
rmt_driver_install(rmt_channel_t(i), 0, 0);
|
||||
} else {
|
||||
// -- Set up the RMT to send 1/2 of the pulse buffer and then
|
||||
// generate an interrupt. When we get this interrupt we
|
||||
// fill the other half in preparation (kind of like double-buffering)
|
||||
rmt_set_tx_thr_intr_en(rmt_channel_t(i), true, MAX_PULSES);
|
||||
}
|
||||
}
|
||||
|
||||
// -- Create a semaphore to block execution until all the controllers are done
|
||||
if (gTX_sem == NULL) {
|
||||
gTX_sem = xSemaphoreCreateBinary();
|
||||
xSemaphoreGive(gTX_sem);
|
||||
}
|
||||
|
||||
if ( ! FASTLED_RMT_BUILTIN_DRIVER) {
|
||||
// -- Allocate the interrupt if we have not done so yet. This
|
||||
// interrupt handler must work for all different kinds of
|
||||
// strips, so it delegates to the refill function for each
|
||||
// specific instantiation of ClocklessController.
|
||||
if (gRMT_intr_handle == NULL)
|
||||
esp_intr_alloc(ETS_RMT_INTR_SOURCE, 0, interruptHandler, 0, &gRMT_intr_handle);
|
||||
}
|
||||
|
||||
gInitialized = true;
|
||||
}
|
||||
|
||||
virtual void showPixels(PixelController<RGB_ORDER> & pixels)
|
||||
{
|
||||
if (gNumStarted == 0) {
|
||||
// -- First controller: make sure everything is set up
|
||||
initRMT();
|
||||
xSemaphoreTake(gTX_sem, portMAX_DELAY);
|
||||
}
|
||||
|
||||
// -- Initialize the local state, save a pointer to the pixel
|
||||
// data. We need to make a copy because pixels is a local
|
||||
// variable in the calling function, and this data structure
|
||||
// needs to outlive this call to showPixels.
|
||||
|
||||
if (mPixels != NULL) delete mPixels;
|
||||
mPixels = new PixelController<RGB_ORDER>(pixels);
|
||||
|
||||
// -- Keep track of the number of strips we've seen
|
||||
gNumStarted++;
|
||||
|
||||
// -- The last call to showPixels is the one responsible for doing
|
||||
// all of the actual worl
|
||||
if (gNumStarted == gNumControllers) {
|
||||
gNext = 0;
|
||||
|
||||
// -- First, fill all the available channels
|
||||
int channel = 0;
|
||||
while (channel < FASTLED_RMT_MAX_CHANNELS && gNext < gNumControllers) {
|
||||
startNext(channel);
|
||||
channel++;
|
||||
}
|
||||
|
||||
// -- Wait here while the rest of the data is sent. The interrupt handler
|
||||
// will keep refilling the RMT buffers until it is all sent; then it
|
||||
// gives the semaphore back.
|
||||
xSemaphoreTake(gTX_sem, portMAX_DELAY);
|
||||
xSemaphoreGive(gTX_sem);
|
||||
|
||||
// -- Reset the counters
|
||||
gNumStarted = 0;
|
||||
gNumDone = 0;
|
||||
gNext = 0;
|
||||
}
|
||||
}
|
||||
|
||||
// -- Start up the next controller
|
||||
// This method is static so that it can dispatch to the appropriate
|
||||
// startOnChannel method of the given controller.
|
||||
static void startNext(int channel)
|
||||
{
|
||||
if (gNext < gNumControllers) {
|
||||
ClocklessController * pController = static_cast<ClocklessController*>(gControllers[gNext]);
|
||||
pController->startOnChannel(channel);
|
||||
gNext++;
|
||||
}
|
||||
}
|
||||
|
||||
virtual void startOnChannel(int channel)
|
||||
{
|
||||
// -- Assign this channel and configure the RMT
|
||||
mRMT_channel = rmt_channel_t(channel);
|
||||
|
||||
// -- Store a reference to this controller, so we can get it
|
||||
// inside the interrupt handler
|
||||
gOnChannel[channel] = this;
|
||||
|
||||
// -- Assign the pin to this channel
|
||||
rmt_set_pin(mRMT_channel, RMT_MODE_TX, mPin);
|
||||
|
||||
if (FASTLED_RMT_BUILTIN_DRIVER) {
|
||||
// -- Use the built-in RMT driver to send all the data in one shot
|
||||
rmt_register_tx_end_callback(doneOnChannel, 0);
|
||||
writeAllRMTItems();
|
||||
} else {
|
||||
// -- Use our custom driver to send the data incrementally
|
||||
|
||||
// -- Turn on the interrupts
|
||||
rmt_set_tx_intr_en(mRMT_channel, true);
|
||||
|
||||
// -- Initialize the counters that keep track of where we are in
|
||||
// the pixel data.
|
||||
mCurPulse = 0;
|
||||
mRGB_channel = 0;
|
||||
|
||||
// -- Fill both halves of the buffer
|
||||
fillHalfRMTBuffer();
|
||||
fillHalfRMTBuffer();
|
||||
|
||||
// -- Turn on the interrupts
|
||||
rmt_set_tx_intr_en(mRMT_channel, true);
|
||||
|
||||
// -- Start the RMT TX operation
|
||||
rmt_tx_start(mRMT_channel, true);
|
||||
}
|
||||
}
|
||||
|
||||
static void doneOnChannel(rmt_channel_t channel, void * arg)
|
||||
{
|
||||
ClocklessController * controller = static_cast<ClocklessController*>(gOnChannel[channel]);
|
||||
portBASE_TYPE HPTaskAwoken = 0;
|
||||
|
||||
// -- Turn off output on the pin
|
||||
gpio_matrix_out(controller->mPin, 0x100, 0, 0);
|
||||
|
||||
gOnChannel[channel] = NULL;
|
||||
gNumDone++;
|
||||
|
||||
if (gNumDone == gNumControllers) {
|
||||
// -- If this is the last controller, signal that we are all done
|
||||
xSemaphoreGiveFromISR(gTX_sem, &HPTaskAwoken);
|
||||
if(HPTaskAwoken == pdTRUE) portYIELD_FROM_ISR();
|
||||
} else {
|
||||
// -- Otherwise, if there are still controllers waiting, then
|
||||
// start the next one on this channel
|
||||
if (gNext < gNumControllers)
|
||||
startNext(channel);
|
||||
}
|
||||
>>>>>>> upstream/master
|
||||
}
|
||||
|
||||
static IRAM_ATTR void interruptHandler(void *arg)
|
||||
{
|
||||
// -- The basic structure of this code is borrowed from the
|
||||
// interrupt handler in esp-idf/components/driver/rmt.c
|
||||
uint32_t intr_st = RMT.int_st.val;
|
||||
uint8_t channel;
|
||||
|
||||
for (channel = 0; channel < FASTLED_RMT_MAX_CHANNELS; channel++) {
|
||||
int tx_done_bit = channel * 3;
|
||||
int tx_next_bit = channel + 24;
|
||||
|
||||
if (gOnChannel[channel] != NULL) {
|
||||
|
||||
<<<<<<< HEAD
|
||||
ClocklessController * controller = static_cast<ClocklessController*>(gOnChannel[channel]);
|
||||
|
||||
// -- More to send on this channel
|
||||
if (intr_st & BIT(tx_next_bit)) {
|
||||
RMT.int_clr.val |= BIT(tx_next_bit);
|
||||
|
||||
// -- Refill the half of the buffer that we just finished,
|
||||
// allowing the other half to proceed.
|
||||
controller->fillHalfRMTBuffer();
|
||||
}
|
||||
|
||||
// -- Transmission is complete on this channel
|
||||
if (intr_st & BIT(tx_done_bit)) {
|
||||
RMT.int_clr.val |= BIT(tx_done_bit);
|
||||
doneOnChannel(rmt_channel_t(channel), 0);
|
||||
=======
|
||||
ClocklessController * controller = static_cast<ClocklessController*>(gOnChannel[channel]);
|
||||
|
||||
// -- More to send on this channel
|
||||
if (intr_st & BIT(tx_next_bit)) {
|
||||
RMT.int_clr.val |= BIT(tx_next_bit);
|
||||
|
||||
// -- Refill the half of the buffer that we just finished,
|
||||
// allowing the other half to proceed.
|
||||
controller->fillHalfRMTBuffer();
|
||||
}
|
||||
|
||||
// -- Transmission is complete on this channel
|
||||
if (intr_st & BIT(tx_done_bit)) {
|
||||
RMT.int_clr.val |= BIT(tx_done_bit);
|
||||
doneOnChannel(rmt_channel_t(channel), 0);
|
||||
>>>>>>> upstream/master
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
virtual void fillHalfRMTBuffer()
|
||||
{
|
||||
// -- Fill half of the RMT pulse buffer
|
||||
|
||||
// The buffer holds 64 total pulse items, so this loop converts
|
||||
// as many pixels as can fit in half of the buffer (MAX_PULSES =
|
||||
// 32 items). In our case, each pixel consists of three bytes,
|
||||
// each bit turns into one pulse item -- 24 items per pixel. So,
|
||||
// each half of the buffer can hold 1 and 1/3 of a pixel.
|
||||
|
||||
// The member variable mCurPulse keeps track of which of the 64
|
||||
// items we are writing. During the first call to this method it
|
||||
// fills 0-31; in the second call it fills 32-63, and then wraps
|
||||
// back around to zero.
|
||||
|
||||
// When we run out of pixel data, just fill the remaining items
|
||||
// with zero pulses.
|
||||
|
||||
uint16_t pulse_count = 0; // Ranges from 0-31 (half a buffer)
|
||||
uint32_t byteval = 0;
|
||||
uint32_t one_val = mOne.val;
|
||||
uint32_t zero_val = mZero.val;
|
||||
bool done_strip = false;
|
||||
|
||||
while (pulse_count < MAX_PULSES) {
|
||||
if (! mPixels->has(1)) {
|
||||
<<<<<<< HEAD
|
||||
if (mCurPulse > 0) {
|
||||
// -- Extend the last pulse to force the strip to latch. Honestly, I'm not
|
||||
// sure if this is really necessary.
|
||||
// RMTMEM.chan[mRMT_channel].data32[mCurPulse-1].duration1 = RMT_RESET_DURATION;
|
||||
}
|
||||
=======
|
||||
>>>>>>> upstream/master
|
||||
done_strip = true;
|
||||
break;
|
||||
}
|
||||
|
||||
// -- Cycle through the R,G, and B values in the right order
|
||||
switch (mRGB_channel) {
|
||||
case 0:
|
||||
byteval = mPixels->loadAndScale0();
|
||||
mRGB_channel = 1;
|
||||
break;
|
||||
case 1:
|
||||
byteval = mPixels->loadAndScale1();
|
||||
mRGB_channel = 2;
|
||||
break;
|
||||
case 2:
|
||||
byteval = mPixels->loadAndScale2();
|
||||
mPixels->advanceData();
|
||||
mPixels->stepDithering();
|
||||
mRGB_channel = 0;
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
|
||||
byteval <<= 24;
|
||||
// Shift bits out, MSB first, setting RMTMEM.chan[n].data32[x] to the
|
||||
// rmt_item32_t value corresponding to the buffered bit value
|
||||
for (register uint32_t j = 0; j < 8; j++) {
|
||||
uint32_t val = (byteval & 0x80000000L) ? one_val : zero_val;
|
||||
RMTMEM.chan[mRMT_channel].data32[mCurPulse].val = val;
|
||||
byteval <<= 1;
|
||||
mCurPulse++;
|
||||
pulse_count++;
|
||||
}
|
||||
<<<<<<< HEAD
|
||||
=======
|
||||
|
||||
if (done_strip)
|
||||
RMTMEM.chan[mRMT_channel].data32[mCurPulse-1].duration1 = RMT_RESET_DURATION;
|
||||
>>>>>>> upstream/master
|
||||
}
|
||||
|
||||
if (done_strip) {
|
||||
// -- And fill the remaining items with zero pulses. The zero values triggers
|
||||
// the tx_done interrupt.
|
||||
while (pulse_count < MAX_PULSES) {
|
||||
RMTMEM.chan[mRMT_channel].data32[mCurPulse].val = 0;
|
||||
mCurPulse++;
|
||||
pulse_count++;
|
||||
}
|
||||
}
|
||||
|
||||
// -- When we have filled the back half the buffer, reset the position to the first half
|
||||
if (mCurPulse >= MAX_PULSES*2)
|
||||
mCurPulse = 0;
|
||||
}
|
||||
|
||||
virtual void writeAllRMTItems()
|
||||
{
|
||||
// -- Compute the pulse values for the whole strip at once.
|
||||
// Requires a large buffer
|
||||
<<<<<<< HEAD
|
||||
mBufferSize = mPixels->size() * 3 * 8;
|
||||
=======
|
||||
mBufferSize = mPixels->size() * 3 * 8;
|
||||
>>>>>>> upstream/master
|
||||
|
||||
// TODO: need a specific number here
|
||||
if (mBuffer == NULL) {
|
||||
mBuffer = (rmt_item32_t *) calloc( mBufferSize, sizeof(rmt_item32_t));
|
||||
}
|
||||
|
||||
mCurPulse = 0;
|
||||
mRGB_channel = 0;
|
||||
uint32_t byteval = 0;
|
||||
while (mPixels->has(1)) {
|
||||
// -- Cycle through the R,G, and B values in the right order
|
||||
switch (mRGB_channel) {
|
||||
case 0:
|
||||
byteval = mPixels->loadAndScale0();
|
||||
mRGB_channel = 1;
|
||||
break;
|
||||
case 1:
|
||||
byteval = mPixels->loadAndScale1();
|
||||
mRGB_channel = 2;
|
||||
break;
|
||||
case 2:
|
||||
byteval = mPixels->loadAndScale2();
|
||||
mPixels->advanceData();
|
||||
mPixels->stepDithering();
|
||||
mRGB_channel = 0;
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
|
||||
byteval <<= 24;
|
||||
// Shift bits out, MSB first, setting RMTMEM.chan[n].data32[x] to the
|
||||
// rmt_item32_t value corresponding to the buffered bit value
|
||||
for (register uint32_t j = 0; j < 8; j++) {
|
||||
mBuffer[mCurPulse] = (byteval & 0x80000000L) ? mOne : mZero;
|
||||
byteval <<= 1;
|
||||
mCurPulse++;
|
||||
}
|
||||
}
|
||||
|
||||
mBuffer[mCurPulse-1].duration1 = RMT_RESET_DURATION;
|
||||
assert(mCurPulse == mBufferSize);
|
||||
|
||||
<<<<<<< HEAD
|
||||
rmt_write_items(mRMT_channel, mBuffer, mBufferSize, false);
|
||||
=======
|
||||
rmt_write_items(mRMT_channel, mBuffer, mBufferSize, false);
|
||||
>>>>>>> upstream/master
|
||||
}
|
||||
};
|
||||
|
||||
FASTLED_NAMESPACE_END
|
||||
767
components/FastLED-idf/platforms/esp/32/clockless_i2s_esp32.h
Normal file
767
components/FastLED-idf/platforms/esp/32/clockless_i2s_esp32.h
Normal file
@ -0,0 +1,767 @@
|
||||
/*
|
||||
* I2S Driver
|
||||
*
|
||||
* Copyright (c) 2019 Yves Bazin
|
||||
* Copyright (c) 2019 Samuel Z. Guyer
|
||||
* Derived from lots of code examples from other people.
|
||||
*
|
||||
* The I2S implementation can drive up to 24 strips in parallel, but
|
||||
* with the following limitation: all the strips must have the same
|
||||
* timing (i.e., they must all use the same chip).
|
||||
*
|
||||
* To enable the I2S driver, add the following line *before* including
|
||||
* FastLED.h (no other changes are necessary):
|
||||
*
|
||||
* #define FASTLED_ESP32_I2S true
|
||||
*
|
||||
* The overall strategy is to use the parallel mode of the I2S "audio"
|
||||
* peripheral to send up to 24 bits in parallel to 24 different pins.
|
||||
* Unlike the RMT peripheral the I2S system cannot send bits of
|
||||
* different lengths. Instead, we set the I2S data clock fairly high
|
||||
* and then encode a signal as a series of bits.
|
||||
*
|
||||
* For example, with a clock divider of 10 the data clock will be
|
||||
* 8MHz, so each bit is 125ns. The WS2812 expects a "1" bit to be
|
||||
* encoded as a HIGH signal for around 875ns, followed by LOW for
|
||||
* 375ns. Sending the following pattern results in the right shape
|
||||
* signal:
|
||||
*
|
||||
* 1111111000 WS2812 "1" bit encoded as 10 125ns pulses
|
||||
*
|
||||
* The I2S peripheral expects the bits for all 24 outputs to be packed
|
||||
* into a single 32-bit word. The complete signal is a series of these
|
||||
* 32-bit values -- one for each bit for each strip. The pixel data,
|
||||
* however, is stored "serially" as a series of RGB values separately
|
||||
* for each strip. To prepare the data we need to do three things: (1)
|
||||
* take 1 pixel from each strip, and (2) tranpose the bits so that
|
||||
* they are in the parallel form, (3) translate each data bit into the
|
||||
* bit pattern that encodes the signal for that bit. This code is in
|
||||
* the fillBuffer() method:
|
||||
*
|
||||
* 1. Read 1 pixel from each strip into an array; store this data by
|
||||
* color channel (e.g., all the red bytes, then all the green
|
||||
* bytes, then all the blue bytes). For three color channels, the
|
||||
* array is 3 X 24 X 8 bits.
|
||||
*
|
||||
* 2. Tranpose the array so that it is 3 X 8 X 24 bits. The hardware
|
||||
* wants the data in 32-bit chunks, so the actual form is 3 X 8 X
|
||||
* 32, with the low 8 bits unused.
|
||||
*
|
||||
* 3. Take each group of 24 parallel bits and "expand" them into a
|
||||
* pattern according to the encoding. For example, with a 8MHz
|
||||
* data clock, each data bit turns into 10 I2s pulses, so 24
|
||||
* parallel data bits turn into 10 X 24 pulses.
|
||||
*
|
||||
* We send data to the I2S peripheral using the DMA interface. We use
|
||||
* two DMA buffers, so that we can fill one buffer while the other
|
||||
* buffer is being sent. Each DMA buffer holds the fully-expanded
|
||||
* pulse pattern for one pixel on up to 24 strips. The exact amount of
|
||||
* memory required depends on the number of color channels and the
|
||||
* number of pulses used to encode each bit.
|
||||
*
|
||||
* We get an interrupt each time a buffer is sent; we then fill that
|
||||
* buffer while the next one is being sent. The DMA interface allows
|
||||
* us to configure the buffers as a circularly linked list, so that it
|
||||
* can automatically start on the next buffer.
|
||||
*/
|
||||
/*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
* of this software and associated documentation files (the "Software"), to deal
|
||||
* in the Software without restriction, including without limitation the rights
|
||||
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
* copies of the Software, and to permit persons to whom the Software is
|
||||
* furnished to do so, subject to the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice shall be included in
|
||||
* all copies or substantial portions of the Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
||||
* THE SOFTWARE.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
|
||||
#pragma message "NOTE: ESP32 support using I2S parallel driver. All strips must use the same chipset"
|
||||
|
||||
FASTLED_NAMESPACE_BEGIN
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#include "esp_heap_caps.h"
|
||||
#include "soc/soc.h"
|
||||
#include "soc/gpio_sig_map.h"
|
||||
#include "soc/i2s_reg.h"
|
||||
#include "soc/i2s_struct.h"
|
||||
#include "soc/io_mux_reg.h"
|
||||
#include "driver/gpio.h"
|
||||
#include "driver/periph_ctrl.h"
|
||||
#include "rom/lldesc.h"
|
||||
#include "esp_intr.h"
|
||||
#include "esp_log.h"
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
__attribute__ ((always_inline)) inline static uint32_t __clock_cycles() {
|
||||
uint32_t cyc;
|
||||
__asm__ __volatile__ ("rsr %0,ccount":"=a" (cyc));
|
||||
return cyc;
|
||||
}
|
||||
|
||||
#define FASTLED_HAS_CLOCKLESS 1
|
||||
#define NUM_COLOR_CHANNELS 3
|
||||
|
||||
// -- Choose which I2S device to use
|
||||
#ifndef I2S_DEVICE
|
||||
#define I2S_DEVICE 0
|
||||
#endif
|
||||
|
||||
// -- Max number of controllers we can support
|
||||
#ifndef FASTLED_I2S_MAX_CONTROLLERS
|
||||
#define FASTLED_I2S_MAX_CONTROLLERS 24
|
||||
#endif
|
||||
|
||||
// -- I2S clock
|
||||
#define I2S_BASE_CLK (80000000L)
|
||||
#define I2S_MAX_CLK (20000000L) //more tha a certain speed and the I2s looses some bits
|
||||
#define I2S_MAX_PULSE_PER_BIT 20 //put it higher to get more accuracy but it could decrease the refresh rate without real improvement
|
||||
// -- Convert ESP32 cycles back into nanoseconds
|
||||
#define ESPCLKS_TO_NS(_CLKS) (((long)(_CLKS) * 1000L) / F_CPU_MHZ)
|
||||
|
||||
// -- Array of all controllers
|
||||
static CLEDController * gControllers[FASTLED_I2S_MAX_CONTROLLERS];
|
||||
static int gNumControllers = 0;
|
||||
static int gNumStarted = 0;
|
||||
|
||||
// -- Global semaphore for the whole show process
|
||||
// Semaphore is not given until all data has been sent
|
||||
static xSemaphoreHandle gTX_sem = NULL;
|
||||
|
||||
// -- One-time I2S initialization
|
||||
static bool gInitialized = false;
|
||||
|
||||
// -- Interrupt handler
|
||||
static intr_handle_t gI2S_intr_handle = NULL;
|
||||
|
||||
// -- A pointer to the memory-mapped structure: I2S0 or I2S1
|
||||
static i2s_dev_t * i2s;
|
||||
|
||||
// -- I2S goes to these pins until we remap them using the GPIO matrix
|
||||
static int i2s_base_pin_index;
|
||||
|
||||
// --- I2S DMA buffers
|
||||
struct DMABuffer {
|
||||
lldesc_t descriptor;
|
||||
uint8_t * buffer;
|
||||
};
|
||||
|
||||
#define NUM_DMA_BUFFERS 2
|
||||
static DMABuffer * dmaBuffers[NUM_DMA_BUFFERS];
|
||||
|
||||
// -- Bit patterns
|
||||
// For now, we require all strips to be the same chipset, so these
|
||||
// are global variables.
|
||||
|
||||
static int gPulsesPerBit = 0;
|
||||
static uint32_t gOneBit[40] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
|
||||
static uint32_t gZeroBit[40] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
|
||||
|
||||
// -- Counters to track progress
|
||||
static int gCurBuffer = 0;
|
||||
static bool gDoneFilling = false;
|
||||
static int ones_for_one;
|
||||
static int ones_for_zero;
|
||||
|
||||
// -- Temp buffers for pixels and bits being formatted for DMA
|
||||
static uint8_t gPixelRow[NUM_COLOR_CHANNELS][32];
|
||||
static uint8_t gPixelBits[NUM_COLOR_CHANNELS][8][4];
|
||||
static int CLOCK_DIVIDER_N;
|
||||
static int CLOCK_DIVIDER_A;
|
||||
static int CLOCK_DIVIDER_B;
|
||||
|
||||
template <int DATA_PIN, int T1, int T2, int T3, EOrder RGB_ORDER = RGB, int XTRA0 = 0, bool FLIP = false, int WAIT_TIME = 5>
|
||||
class ClocklessController : public CPixelLEDController<RGB_ORDER>
|
||||
{
|
||||
// -- Store the GPIO pin
|
||||
gpio_num_t mPin;
|
||||
|
||||
// -- This instantiation forces a check on the pin choice
|
||||
FastPin<DATA_PIN> mFastPin;
|
||||
|
||||
// -- Save the pixel controller
|
||||
PixelController<RGB_ORDER> * mPixels;
|
||||
|
||||
public:
|
||||
|
||||
void init()
|
||||
{
|
||||
i2sInit();
|
||||
|
||||
// -- Allocate space to save the pixel controller
|
||||
// during parallel output
|
||||
mPixels = (PixelController<RGB_ORDER> *) malloc(sizeof(PixelController<RGB_ORDER>));
|
||||
|
||||
gControllers[gNumControllers] = this;
|
||||
int my_index = gNumControllers;
|
||||
gNumControllers++;
|
||||
|
||||
// -- Set up the pin We have to do two things: configure the
|
||||
// actual GPIO pin, and route the output from the default
|
||||
// pin (determined by the I2S device) to the pin we
|
||||
// want. We compute the default pin using the index of this
|
||||
// controller in the array. This order is crucial because
|
||||
// the bits must go into the DMA buffer in the same order.
|
||||
mPin = gpio_num_t(DATA_PIN);
|
||||
|
||||
PIN_FUNC_SELECT(GPIO_PIN_MUX_REG[DATA_PIN], PIN_FUNC_GPIO);
|
||||
gpio_set_direction(mPin, (gpio_mode_t)GPIO_MODE_DEF_OUTPUT);
|
||||
pinMode(mPin,OUTPUT);
|
||||
gpio_matrix_out(mPin, i2s_base_pin_index + my_index, false, false);
|
||||
}
|
||||
|
||||
virtual uint16_t getMaxRefreshRate() const { return 400; }
|
||||
|
||||
protected:
|
||||
|
||||
static int pgcd(int smallest,int precision,int a,int b,int c)
|
||||
{
|
||||
int pgc_=1;
|
||||
for( int i=smallest;i>0;i--)
|
||||
{
|
||||
|
||||
if( a%i<=precision && b%i<=precision && c%i<=precision)
|
||||
{
|
||||
pgc_=i;
|
||||
break;
|
||||
}
|
||||
}
|
||||
return pgc_;
|
||||
}
|
||||
|
||||
/** Compute pules/bit patterns
|
||||
*
|
||||
* This is Yves Bazin's mad code for computing the pulse pattern
|
||||
* and clock timing given the target signal given by T1, T2, and
|
||||
* T3. In general, these parameters are interpreted as follows:
|
||||
*
|
||||
* a "1" bit is encoded by setting the pin HIGH to T1+T2 ns, then LOW for T3 ns
|
||||
* a "0" bit is encoded by setting the pin HIGH to T1 ns, then LOW for T2+T3 ns
|
||||
*
|
||||
*/
|
||||
static void initBitPatterns()
|
||||
{
|
||||
// Precompute the bit patterns based on the I2S sample rate
|
||||
// Serial.println("Setting up fastled using I2S");
|
||||
|
||||
// -- First, convert back to ns from CPU clocks
|
||||
uint32_t T1ns = ESPCLKS_TO_NS(T1);
|
||||
uint32_t T2ns = ESPCLKS_TO_NS(T2);
|
||||
uint32_t T3ns = ESPCLKS_TO_NS(T3);
|
||||
|
||||
// Serial.print("T1 = "); Serial.print(T1); Serial.print(" ns "); Serial.println(T1ns);
|
||||
// Serial.print("T2 = "); Serial.print(T2); Serial.print(" ns "); Serial.println(T2ns);
|
||||
// Serial.print("T3 = "); Serial.print(T3); Serial.print(" ns "); Serial.println(T3ns);
|
||||
|
||||
/*
|
||||
We calculate the best pcgd to the timing
|
||||
ie
|
||||
WS2811 77 77 154 => 1 1 2 => nb pulses= 4
|
||||
WS2812 60 150 90 => 2 5 3 => nb pulses=10
|
||||
*/
|
||||
int smallest=0;
|
||||
if (T1>T2)
|
||||
smallest=T2;
|
||||
else
|
||||
smallest=T1;
|
||||
if(smallest>T3)
|
||||
smallest=T3;
|
||||
double freq=(double)1/(double)(T1ns + T2ns + T3ns);
|
||||
// Serial.printf("chipset frequency:%f Khz\n", 1000000L*freq);
|
||||
// Serial.printf("smallest %d\n",smallest);
|
||||
int pgc_=1;
|
||||
int precision=0;
|
||||
pgc_=pgcd(smallest,precision,T1,T2,T3);
|
||||
//Serial.printf("%f\n",I2S_MAX_CLK/(1000000000L*freq));
|
||||
while(pgc_==1 || (T1/pgc_ +T2/pgc_ +T3/pgc_)>I2S_MAX_PULSE_PER_BIT) //while(pgc_==1 || (T1/pgc_ +T2/pgc_ +T3/pgc_)>I2S_MAX_CLK/(1000000000L*freq))
|
||||
{
|
||||
precision++;
|
||||
pgc_=pgcd(smallest,precision,T1,T2,T3);
|
||||
//Serial.printf("%d %d\n",pgc_,(a+b+c)/pgc_);
|
||||
}
|
||||
pgc_=pgcd(smallest,precision,T1,T2,T3);
|
||||
// Serial.printf("pgcd %d precision:%d\n",pgc_,precision);
|
||||
// Serial.printf("nb pulse per bit:%d\n",T1/pgc_ +T2/pgc_ +T3/pgc_);
|
||||
gPulsesPerBit=(int)T1/pgc_ +(int)T2/pgc_ +(int)T3/pgc_;
|
||||
/*
|
||||
we calculate the duration of one pulse nd htre base frequency of the led
|
||||
ie WS2812B F=1/(250+625+375)=800kHz or 1250ns
|
||||
as we need 10 pulses each pulse is 125ns => frequency 800Khz*10=8MHz
|
||||
WS2811 T=320+320+641=1281ns qnd we need 4 pulses => pulse duration 320.25ns =>frequency 3.1225605Mhz
|
||||
|
||||
*/
|
||||
|
||||
freq=1000000000L*freq*gPulsesPerBit;
|
||||
// Serial.printf("needed frequency (nbpiulse per bit)*(chispset frequency):%f Mhz\n",freq/1000000);
|
||||
|
||||
/*
|
||||
we do calculate the needed N a and b
|
||||
as f=basefred/(N+b/a);
|
||||
as a is max 63 the precision for the decimal is 1/63
|
||||
|
||||
*/
|
||||
|
||||
CLOCK_DIVIDER_N=(int)((double)I2S_BASE_CLK/freq);
|
||||
double v=I2S_BASE_CLK/freq-CLOCK_DIVIDER_N;
|
||||
|
||||
double prec=(double)1/63;
|
||||
int a=1;
|
||||
int b=0;
|
||||
CLOCK_DIVIDER_A=1;
|
||||
CLOCK_DIVIDER_B=0;
|
||||
for(a=1;a<64;a++)
|
||||
{
|
||||
for(b=0;b<a;b++)
|
||||
{
|
||||
//printf("%d %d %f %f %f\n",b,a,v,(double)v*(double)a,fabsf(v-(double)b/a));
|
||||
if(fabsf(v-(double)b/a) <= prec/2)
|
||||
break;
|
||||
}
|
||||
if(fabsf(v-(double)b/a) ==0)
|
||||
{
|
||||
CLOCK_DIVIDER_A=a;
|
||||
CLOCK_DIVIDER_B=b;
|
||||
break;
|
||||
}
|
||||
if(fabsf(v-(double)b/a) < prec/2)
|
||||
{
|
||||
if (fabsf(v-(double)b/a) <fabsf(v-(double)CLOCK_DIVIDER_B/CLOCK_DIVIDER_A))
|
||||
{
|
||||
CLOCK_DIVIDER_A=a;
|
||||
CLOCK_DIVIDER_B=b;
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
//top take care of an issue with double 0.9999999999
|
||||
if(CLOCK_DIVIDER_A==CLOCK_DIVIDER_B)
|
||||
{
|
||||
CLOCK_DIVIDER_A=1;
|
||||
CLOCK_DIVIDER_B=0;
|
||||
CLOCK_DIVIDER_N++;
|
||||
}
|
||||
|
||||
//printf("%d %d %f %f %d\n",CLOCK_DIVIDER_B,CLOCK_DIVIDER_A,(double)CLOCK_DIVIDER_B/CLOCK_DIVIDER_A,v,CLOCK_DIVIDER_N);
|
||||
//Serial.printf("freq %f %f\n",freq,I2S_BASE_CLK/(CLOCK_DIVIDER_N+(double)CLOCK_DIVIDER_B/CLOCK_DIVIDER_A));
|
||||
freq=1/(CLOCK_DIVIDER_N+(double)CLOCK_DIVIDER_B/CLOCK_DIVIDER_A);
|
||||
freq=freq*I2S_BASE_CLK;
|
||||
// Serial.printf("calculted for i2s frequency:%f Mhz N:%d B:%d A:%d\n",freq/1000000,CLOCK_DIVIDER_N,CLOCK_DIVIDER_B,CLOCK_DIVIDER_A);
|
||||
double pulseduration=1000000000/freq;
|
||||
// Serial.printf("Pulse duration: %f ns\n",pulseduration);
|
||||
// gPulsesPerBit = (T1ns + T2ns + T3ns)/FASTLED_I2S_NS_PER_PULSE;
|
||||
|
||||
//Serial.print("Pulses per bit: "); Serial.println(gPulsesPerBit);
|
||||
|
||||
//int ones_for_one = ((T1ns + T2ns - 1)/FASTLED_I2S_NS_PER_PULSE) + 1;
|
||||
ones_for_one = T1/pgc_ +T2/pgc_;
|
||||
//Serial.print("One bit: target ");
|
||||
//Serial.print(T1ns+T2ns); Serial.print("ns --- ");
|
||||
//Serial.print(ones_for_one); Serial.print(" 1 bits");
|
||||
//Serial.print(" = "); Serial.print(ones_for_one * FASTLED_I2S_NS_PER_PULSE); Serial.println("ns");
|
||||
// Serial.printf("one bit : target %d ns --- %d pulses 1 bit = %f ns\n",T1ns+T2ns,ones_for_one ,ones_for_one*pulseduration);
|
||||
|
||||
|
||||
int i = 0;
|
||||
while ( i < ones_for_one ) {
|
||||
gOneBit[i] = 0xFFFFFF00;
|
||||
i++;
|
||||
}
|
||||
while ( i < gPulsesPerBit ) {
|
||||
gOneBit[i] = 0x00000000;
|
||||
i++;
|
||||
}
|
||||
|
||||
//int ones_for_zero = ((T1ns - 1)/FASTLED_I2S_NS_PER_PULSE) + 1;
|
||||
ones_for_zero =T1/pgc_ ;
|
||||
// Serial.print("Zero bit: target ");
|
||||
// Serial.print(T1ns); Serial.print("ns --- ");
|
||||
//Serial.print(ones_for_zero); Serial.print(" 1 bits");
|
||||
//Serial.print(" = "); Serial.print(ones_for_zero * FASTLED_I2S_NS_PER_PULSE); Serial.println("ns");
|
||||
// Serial.printf("Zero bit : target %d ns --- %d pulses 1 bit = %f ns\n",T1ns,ones_for_zero ,ones_for_zero*pulseduration);
|
||||
i = 0;
|
||||
while ( i < ones_for_zero ) {
|
||||
gZeroBit[i] = 0xFFFFFF00;
|
||||
i++;
|
||||
}
|
||||
while ( i < gPulsesPerBit ) {
|
||||
gZeroBit[i] = 0x00000000;
|
||||
i++;
|
||||
}
|
||||
|
||||
memset(gPixelRow, 0, NUM_COLOR_CHANNELS * 32);
|
||||
memset(gPixelBits, 0, NUM_COLOR_CHANNELS * 32);
|
||||
}
|
||||
|
||||
static DMABuffer * allocateDMABuffer(int bytes)
|
||||
{
|
||||
DMABuffer * b = (DMABuffer *)heap_caps_malloc(sizeof(DMABuffer), MALLOC_CAP_DMA);
|
||||
|
||||
b->buffer = (uint8_t *)heap_caps_malloc(bytes, MALLOC_CAP_DMA);
|
||||
memset(b->buffer, 0, bytes);
|
||||
|
||||
b->descriptor.length = bytes;
|
||||
b->descriptor.size = bytes;
|
||||
b->descriptor.owner = 1;
|
||||
b->descriptor.sosf = 1;
|
||||
b->descriptor.buf = b->buffer;
|
||||
b->descriptor.offset = 0;
|
||||
b->descriptor.empty = 0;
|
||||
b->descriptor.eof = 1;
|
||||
b->descriptor.qe.stqe_next = 0;
|
||||
|
||||
return b;
|
||||
}
|
||||
|
||||
static void i2sInit()
|
||||
{
|
||||
// -- Only need to do this once
|
||||
if (gInitialized) return;
|
||||
|
||||
// -- Construct the bit patterns for ones and zeros
|
||||
initBitPatterns();
|
||||
|
||||
// -- Choose whether to use I2S device 0 or device 1
|
||||
// Set up the various device-specific parameters
|
||||
int interruptSource;
|
||||
if (I2S_DEVICE == 0) {
|
||||
i2s = &I2S0;
|
||||
periph_module_enable(PERIPH_I2S0_MODULE);
|
||||
interruptSource = ETS_I2S0_INTR_SOURCE;
|
||||
i2s_base_pin_index = I2S0O_DATA_OUT0_IDX;
|
||||
} else {
|
||||
i2s = &I2S1;
|
||||
periph_module_enable(PERIPH_I2S1_MODULE);
|
||||
interruptSource = ETS_I2S1_INTR_SOURCE;
|
||||
i2s_base_pin_index = I2S1O_DATA_OUT0_IDX;
|
||||
}
|
||||
|
||||
// -- Reset everything
|
||||
i2sReset();
|
||||
i2sReset_DMA();
|
||||
i2sReset_FIFO();
|
||||
|
||||
// -- Main configuration
|
||||
i2s->conf.tx_msb_right = 1;
|
||||
i2s->conf.tx_mono = 0;
|
||||
i2s->conf.tx_short_sync = 0;
|
||||
i2s->conf.tx_msb_shift = 0;
|
||||
i2s->conf.tx_right_first = 1; // 0;//1;
|
||||
i2s->conf.tx_slave_mod = 0;
|
||||
|
||||
// -- Set parallel mode
|
||||
i2s->conf2.val = 0;
|
||||
i2s->conf2.lcd_en = 1;
|
||||
i2s->conf2.lcd_tx_wrx2_en = 0; // 0 for 16 or 32 parallel output
|
||||
i2s->conf2.lcd_tx_sdx2_en = 0; // HN
|
||||
|
||||
// -- Set up the clock rate and sampling
|
||||
i2s->sample_rate_conf.val = 0;
|
||||
i2s->sample_rate_conf.tx_bits_mod = 32; // Number of parallel bits/pins
|
||||
i2s->sample_rate_conf.tx_bck_div_num = 1;
|
||||
i2s->clkm_conf.val = 0;
|
||||
i2s->clkm_conf.clka_en = 0;
|
||||
|
||||
// -- Data clock is computed as Base/(div_num + (div_b/div_a))
|
||||
// Base is 80Mhz, so 80/(10 + 0/1) = 8Mhz
|
||||
// One cycle is 125ns
|
||||
i2s->clkm_conf.clkm_div_a = CLOCK_DIVIDER_A;
|
||||
i2s->clkm_conf.clkm_div_b = CLOCK_DIVIDER_B;
|
||||
i2s->clkm_conf.clkm_div_num = CLOCK_DIVIDER_N;
|
||||
|
||||
i2s->fifo_conf.val = 0;
|
||||
i2s->fifo_conf.tx_fifo_mod_force_en = 1;
|
||||
i2s->fifo_conf.tx_fifo_mod = 3; // 32-bit single channel data
|
||||
i2s->fifo_conf.tx_data_num = 32; // fifo length
|
||||
i2s->fifo_conf.dscr_en = 1; // fifo will use dma
|
||||
|
||||
i2s->conf1.val = 0;
|
||||
i2s->conf1.tx_stop_en = 0;
|
||||
i2s->conf1.tx_pcm_bypass = 1;
|
||||
|
||||
i2s->conf_chan.val = 0;
|
||||
i2s->conf_chan.tx_chan_mod = 1; // Mono mode, with tx_msb_right = 1, everything goes to right-channel
|
||||
|
||||
i2s->timing.val = 0;
|
||||
|
||||
// -- Allocate two DMA buffers
|
||||
dmaBuffers[0] = allocateDMABuffer(32 * NUM_COLOR_CHANNELS * gPulsesPerBit);
|
||||
dmaBuffers[1] = allocateDMABuffer(32 * NUM_COLOR_CHANNELS * gPulsesPerBit);
|
||||
|
||||
// -- Arrange them as a circularly linked list
|
||||
dmaBuffers[0]->descriptor.qe.stqe_next = &(dmaBuffers[1]->descriptor);
|
||||
dmaBuffers[1]->descriptor.qe.stqe_next = &(dmaBuffers[0]->descriptor);
|
||||
|
||||
// -- Allocate i2s interrupt
|
||||
SET_PERI_REG_BITS(I2S_INT_ENA_REG(I2S_DEVICE), I2S_OUT_EOF_INT_ENA_V, 1, I2S_OUT_EOF_INT_ENA_S);
|
||||
esp_err_t e = esp_intr_alloc(interruptSource, 0, // ESP_INTR_FLAG_INTRDISABLED | ESP_INTR_FLAG_LEVEL3,
|
||||
&interruptHandler, 0, &gI2S_intr_handle);
|
||||
|
||||
// -- Create a semaphore to block execution until all the controllers are done
|
||||
if (gTX_sem == NULL) {
|
||||
gTX_sem = xSemaphoreCreateBinary();
|
||||
xSemaphoreGive(gTX_sem);
|
||||
}
|
||||
|
||||
// Serial.println("Init I2S");
|
||||
gInitialized = true;
|
||||
}
|
||||
|
||||
/** Clear DMA buffer
|
||||
*
|
||||
* Yves' clever trick: initialize the bits that we know must be 0
|
||||
* or 1 regardless of what bit they encode.
|
||||
*/
|
||||
static void empty( uint32_t *buf)
|
||||
{
|
||||
for(int i=0;i<8*NUM_COLOR_CHANNELS;i++)
|
||||
{
|
||||
int offset=gPulsesPerBit*i;
|
||||
for(int j=0;j<ones_for_zero;j++)
|
||||
buf[offset+j]=0xffffffff;
|
||||
|
||||
for(int j=ones_for_one;j<gPulsesPerBit;j++)
|
||||
buf[offset+j]=0;
|
||||
}
|
||||
}
|
||||
|
||||
// -- Show pixels
|
||||
// This is the main entry point for the controller.
|
||||
virtual void showPixels(PixelController<RGB_ORDER> & pixels)
|
||||
{
|
||||
if (gNumStarted == 0) {
|
||||
// -- First controller: make sure everything is set up
|
||||
xSemaphoreTake(gTX_sem, portMAX_DELAY);
|
||||
}
|
||||
|
||||
// -- Initialize the local state, save a pointer to the pixel
|
||||
// data. We need to make a copy because pixels is a local
|
||||
// variable in the calling function, and this data structure
|
||||
// needs to outlive this call to showPixels.
|
||||
(*mPixels) = pixels;
|
||||
|
||||
// -- Keep track of the number of strips we've seen
|
||||
gNumStarted++;
|
||||
|
||||
// Serial.print("Show pixels ");
|
||||
// Serial.println(gNumStarted);
|
||||
|
||||
// -- The last call to showPixels is the one responsible for doing
|
||||
// all of the actual work
|
||||
if (gNumStarted == gNumControllers) {
|
||||
empty((uint32_t*)dmaBuffers[0]->buffer);
|
||||
empty((uint32_t*)dmaBuffers[1]->buffer);
|
||||
gCurBuffer = 0;
|
||||
gDoneFilling = false;
|
||||
|
||||
// -- Prefill both buffers
|
||||
fillBuffer();
|
||||
fillBuffer();
|
||||
|
||||
i2sStart();
|
||||
|
||||
// -- Wait here while the rest of the data is sent. The interrupt handler
|
||||
// will keep refilling the DMA buffers until it is all sent; then it
|
||||
// gives the semaphore back.
|
||||
xSemaphoreTake(gTX_sem, portMAX_DELAY);
|
||||
xSemaphoreGive(gTX_sem);
|
||||
|
||||
i2sStop();
|
||||
|
||||
// -- Reset the counters
|
||||
gNumStarted = 0;
|
||||
}
|
||||
}
|
||||
|
||||
// -- Custom interrupt handler
|
||||
static IRAM_ATTR void interruptHandler(void *arg)
|
||||
{
|
||||
if (i2s->int_st.out_eof) {
|
||||
i2s->int_clr.val = i2s->int_raw.val;
|
||||
|
||||
if ( ! gDoneFilling) {
|
||||
fillBuffer();
|
||||
} else {
|
||||
portBASE_TYPE HPTaskAwoken = 0;
|
||||
xSemaphoreGiveFromISR(gTX_sem, &HPTaskAwoken);
|
||||
if(HPTaskAwoken == pdTRUE) portYIELD_FROM_ISR();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/** Fill DMA buffer
|
||||
*
|
||||
* This is where the real work happens: take a row of pixels (one
|
||||
* from each strip), transpose and encode the bits, and store
|
||||
* them in the DMA buffer for the I2S peripheral to read.
|
||||
*/
|
||||
static void fillBuffer()
|
||||
{
|
||||
// -- Alternate between buffers
|
||||
volatile uint32_t * buf = (uint32_t *) dmaBuffers[gCurBuffer]->buffer;
|
||||
gCurBuffer = (gCurBuffer + 1) % NUM_DMA_BUFFERS;
|
||||
|
||||
// -- Get the requested pixel from each controller. Store the
|
||||
// data for each color channel in a separate array.
|
||||
uint32_t has_data_mask = 0;
|
||||
for (int i = 0; i < gNumControllers; i++) {
|
||||
// -- Store the pixels in reverse controller order starting at index 23
|
||||
// This causes the bits to come out in the right position after we
|
||||
// transpose them.
|
||||
int bit_index = 23-i;
|
||||
ClocklessController * pController = static_cast<ClocklessController*>(gControllers[i]);
|
||||
if (pController->mPixels->has(1)) {
|
||||
gPixelRow[0][bit_index] = pController->mPixels->loadAndScale0();
|
||||
gPixelRow[1][bit_index] = pController->mPixels->loadAndScale1();
|
||||
gPixelRow[2][bit_index] = pController->mPixels->loadAndScale2();
|
||||
pController->mPixels->advanceData();
|
||||
pController->mPixels->stepDithering();
|
||||
|
||||
// -- Record that this controller still has data to send
|
||||
has_data_mask |= (1 << (i+8));
|
||||
}
|
||||
}
|
||||
|
||||
// -- None of the strips has data? We are done.
|
||||
if (has_data_mask == 0) {
|
||||
gDoneFilling = true;
|
||||
return;
|
||||
}
|
||||
|
||||
// -- Transpose and encode the pixel data for the DMA buffer
|
||||
int buf_index = 0;
|
||||
for (int channel = 0; channel < NUM_COLOR_CHANNELS; channel++) {
|
||||
|
||||
// -- Tranpose each array: all the bit 7's, then all the bit 6's, ...
|
||||
transpose32(gPixelRow[channel], gPixelBits[channel][0] );
|
||||
|
||||
//Serial.print("Channel: "); Serial.print(channel); Serial.print(" ");
|
||||
for (int bitnum = 0; bitnum < 8; bitnum++) {
|
||||
uint8_t * row = (uint8_t *) (gPixelBits[channel][bitnum]);
|
||||
uint32_t bit = (row[0] << 24) | (row[1] << 16) | (row[2] << 8) | row[3];
|
||||
|
||||
/* SZG: More general, but too slow:
|
||||
for (int pulse_num = 0; pulse_num < gPulsesPerBit; pulse_num++) {
|
||||
buf[buf_index++] = has_data_mask & ( (bit & gOneBit[pulse_num]) | (~bit & gZeroBit[pulse_num]) );
|
||||
}
|
||||
*/
|
||||
|
||||
// -- Only fill in the pulses that are different between the "0" and "1" encodings
|
||||
for(int pulse_num = ones_for_zero; pulse_num < ones_for_one; pulse_num++) {
|
||||
buf[bitnum*gPulsesPerBit+channel*8*gPulsesPerBit+pulse_num] = has_data_mask & bit;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static void transpose32(uint8_t * pixels, uint8_t * bits)
|
||||
{
|
||||
transpose8rS32(& pixels[0], 1, 4, & bits[0]);
|
||||
transpose8rS32(& pixels[8], 1, 4, & bits[1]);
|
||||
transpose8rS32(& pixels[16], 1, 4, & bits[2]);
|
||||
//transpose8rS32(& pixels[24], 1, 4, & bits[3]); Can only use 24 bits
|
||||
}
|
||||
|
||||
/** Transpose 8x8 bit matrix
|
||||
* From Hacker's Delight
|
||||
*/
|
||||
static void transpose8rS32(uint8_t * A, int m, int n, uint8_t * B)
|
||||
{
|
||||
uint32_t x, y, t;
|
||||
|
||||
// Load the array and pack it into x and y.
|
||||
|
||||
x = (A[0]<<24) | (A[m]<<16) | (A[2*m]<<8) | A[3*m];
|
||||
y = (A[4*m]<<24) | (A[5*m]<<16) | (A[6*m]<<8) | A[7*m];
|
||||
|
||||
t = (x ^ (x >> 7)) & 0x00AA00AA; x = x ^ t ^ (t << 7);
|
||||
t = (y ^ (y >> 7)) & 0x00AA00AA; y = y ^ t ^ (t << 7);
|
||||
|
||||
t = (x ^ (x >>14)) & 0x0000CCCC; x = x ^ t ^ (t <<14);
|
||||
t = (y ^ (y >>14)) & 0x0000CCCC; y = y ^ t ^ (t <<14);
|
||||
|
||||
t = (x & 0xF0F0F0F0) | ((y >> 4) & 0x0F0F0F0F);
|
||||
y = ((x << 4) & 0xF0F0F0F0) | (y & 0x0F0F0F0F);
|
||||
x = t;
|
||||
|
||||
B[0]=x>>24; B[n]=x>>16; B[2*n]=x>>8; B[3*n]=x;
|
||||
B[4*n]=y>>24; B[5*n]=y>>16; B[6*n]=y>>8; B[7*n]=y;
|
||||
}
|
||||
|
||||
/** Start I2S transmission
|
||||
*/
|
||||
static void i2sStart()
|
||||
{
|
||||
// esp_intr_disable(gI2S_intr_handle);
|
||||
// Serial.println("I2S start");
|
||||
i2sReset();
|
||||
//Serial.println(dmaBuffers[0]->sampleCount());
|
||||
i2s->lc_conf.val=I2S_OUT_DATA_BURST_EN | I2S_OUTDSCR_BURST_EN | I2S_OUT_DATA_BURST_EN;
|
||||
i2s->out_link.addr = (uint32_t) & (dmaBuffers[0]->descriptor);
|
||||
i2s->out_link.start = 1;
|
||||
////vTaskDelay(5);
|
||||
i2s->int_clr.val = i2s->int_raw.val;
|
||||
// //vTaskDelay(5);
|
||||
i2s->int_ena.out_dscr_err = 1;
|
||||
//enable interrupt
|
||||
////vTaskDelay(5);
|
||||
esp_intr_enable(gI2S_intr_handle);
|
||||
// //vTaskDelay(5);
|
||||
i2s->int_ena.val = 0;
|
||||
i2s->int_ena.out_eof = 1;
|
||||
|
||||
//start transmission
|
||||
i2s->conf.tx_start = 1;
|
||||
}
|
||||
|
||||
static void i2sReset()
|
||||
{
|
||||
// Serial.println("I2S reset");
|
||||
const unsigned long lc_conf_reset_flags = I2S_IN_RST_M | I2S_OUT_RST_M | I2S_AHBM_RST_M | I2S_AHBM_FIFO_RST_M;
|
||||
i2s->lc_conf.val |= lc_conf_reset_flags;
|
||||
i2s->lc_conf.val &= ~lc_conf_reset_flags;
|
||||
|
||||
const uint32_t conf_reset_flags = I2S_RX_RESET_M | I2S_RX_FIFO_RESET_M | I2S_TX_RESET_M | I2S_TX_FIFO_RESET_M;
|
||||
i2s->conf.val |= conf_reset_flags;
|
||||
i2s->conf.val &= ~conf_reset_flags;
|
||||
}
|
||||
|
||||
static void i2sReset_DMA()
|
||||
{
|
||||
i2s->lc_conf.in_rst=1; i2s->lc_conf.in_rst=0;
|
||||
i2s->lc_conf.out_rst=1; i2s->lc_conf.out_rst=0;
|
||||
}
|
||||
|
||||
static void i2sReset_FIFO()
|
||||
{
|
||||
i2s->conf.rx_fifo_reset=1; i2s->conf.rx_fifo_reset=0;
|
||||
i2s->conf.tx_fifo_reset=1; i2s->conf.tx_fifo_reset=0;
|
||||
}
|
||||
|
||||
static void i2sStop()
|
||||
{
|
||||
// Serial.println("I2S stop");
|
||||
esp_intr_disable(gI2S_intr_handle);
|
||||
i2sReset();
|
||||
i2s->conf.rx_start = 0;
|
||||
i2s->conf.tx_start = 0;
|
||||
}
|
||||
};
|
||||
|
||||
FASTLED_NAMESPACE_END
|
||||
658
components/FastLED-idf/platforms/esp/32/clockless_rmt_esp32.h
Normal file
658
components/FastLED-idf/platforms/esp/32/clockless_rmt_esp32.h
Normal file
@ -0,0 +1,658 @@
|
||||
/*
|
||||
* Integration into FastLED ClocklessController
|
||||
* Copyright (c) 2018 Samuel Z. Guyer
|
||||
* Copyright (c) 2017 Thomas Basler
|
||||
* Copyright (c) 2017 Martin F. Falatic
|
||||
*
|
||||
* ESP32 support is provided using the RMT peripheral device -- a unit
|
||||
* on the chip designed specifically for generating (and receiving)
|
||||
* precisely-timed digital signals. Nominally for use in infrared
|
||||
* remote controls, we use it to generate the signals for clockless
|
||||
* LED strips. The main advantage of using the RMT device is that,
|
||||
* once programmed, it generates the signal asynchronously, allowing
|
||||
* the CPU to continue executing other code. It is also not vulnerable
|
||||
* to interrupts or other timing problems that could disrupt the signal.
|
||||
*
|
||||
* The implementation strategy is borrowed from previous work and from
|
||||
* the RMT support built into the ESP32 IDF. The RMT device has 8
|
||||
* channels, which can be programmed independently to send sequences
|
||||
* of high/low bits. Memory for each channel is limited, however, so
|
||||
* in order to send a long sequence of bits, we need to continuously
|
||||
* refill the buffer until all the data is sent. To do this, we fill
|
||||
* half the buffer and then set an interrupt to go off when that half
|
||||
* is sent. Then we refill that half while the second half is being
|
||||
* sent. This strategy effectively overlaps computation (by the CPU)
|
||||
* and communication (by the RMT).
|
||||
*
|
||||
* Since the RMT device only has 8 channels, we need a strategy to
|
||||
* allow more than 8 LED controllers. Our driver assigns controllers
|
||||
* to channels on the fly, queuing up controllers as necessary until a
|
||||
* channel is free. The main showPixels routine just fires off the
|
||||
* first 8 controllers; the interrupt handler starts new controllers
|
||||
* asynchronously as previous ones finish. So, for example, it can
|
||||
* send the data for 8 controllers simultaneously, but 16 controllers
|
||||
* would take approximately twice as much time.
|
||||
*
|
||||
* There is a #define that allows a program to control the total
|
||||
* number of channels that the driver is allowed to use. It defaults
|
||||
* to 8 -- use all the channels. Setting it to 1, for example, results
|
||||
* in fully serial output:
|
||||
*
|
||||
* #define FASTLED_RMT_MAX_CHANNELS 1
|
||||
*
|
||||
* OTHER RMT APPLICATIONS
|
||||
*
|
||||
* The default FastLED driver takes over control of the RMT interrupt
|
||||
* handler, making it hard to use the RMT device for other
|
||||
* (non-FastLED) purposes. You can change it's behavior to use the ESP
|
||||
* core driver instead, allowing other RMT applications to
|
||||
* co-exist. To switch to this mode, add the following directive
|
||||
* before you include FastLED.h:
|
||||
*
|
||||
* #define FASTLED_RMT_BUILTIN_DRIVER
|
||||
*
|
||||
* There may be a performance penalty for using this mode. We need to
|
||||
* compute the RMT signal for the entire LED strip ahead of time,
|
||||
* rather than overlapping it with communication. We also need a large
|
||||
* buffer to hold the signal specification. Each bit of pixel data is
|
||||
* represented by a 32-bit pulse specification, so it is a 32X blow-up
|
||||
* in memory use.
|
||||
*
|
||||
*
|
||||
* Based on public domain code created 19 Nov 2016 by Chris Osborn <fozztexx@fozztexx.com>
|
||||
* http://insentricity.com *
|
||||
*
|
||||
*/
|
||||
/*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
* of this software and associated documentation files (the "Software"), to deal
|
||||
* in the Software without restriction, including without limitation the rights
|
||||
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
* copies of the Software, and to permit persons to whom the Software is
|
||||
* furnished to do so, subject to the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice shall be included in
|
||||
* all copies or substantial portions of the Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
||||
* THE SOFTWARE.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
|
||||
FASTLED_NAMESPACE_BEGIN
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#include "esp32-hal.h"
|
||||
#include "esp_intr.h"
|
||||
#include "driver/gpio.h"
|
||||
#include "driver/rmt.h"
|
||||
#include "driver/periph_ctrl.h"
|
||||
#include "freertos/semphr.h"
|
||||
#include "soc/rmt_struct.h"
|
||||
|
||||
#include "esp_log.h"
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
__attribute__ ((always_inline)) inline static uint32_t __clock_cycles() {
|
||||
uint32_t cyc;
|
||||
__asm__ __volatile__ ("rsr %0,ccount":"=a" (cyc));
|
||||
return cyc;
|
||||
}
|
||||
|
||||
#define FASTLED_HAS_CLOCKLESS 1
|
||||
#define NUM_COLOR_CHANNELS 3
|
||||
|
||||
// -- Set to true to print debugging information about timing
|
||||
// Useful for finding out if timing is being messed up by other things
|
||||
// on the processor (WiFi, for example)
|
||||
#ifndef FASTLED_RMT_SHOW_TIMER
|
||||
#define FASTLED_RMT_SHOW_TIMER false
|
||||
#endif
|
||||
|
||||
// -- Configuration constants
|
||||
#define DIVIDER 2 /* 4, 8 still seem to work, but timings become marginal */
|
||||
#define MAX_PULSES 64 /* A channel has a 64 "pulse" buffer */
|
||||
#define PULSES_PER_FILL 24 /* One pixel's worth of pulses */
|
||||
|
||||
// -- Convert ESP32 CPU cycles to RMT device cycles, taking into account the divider
|
||||
#define F_CPU_RMT ( 80000000L)
|
||||
#define RMT_CYCLES_PER_SEC (F_CPU_RMT/DIVIDER)
|
||||
#define RMT_CYCLES_PER_ESP_CYCLE (F_CPU / RMT_CYCLES_PER_SEC)
|
||||
#define ESP_TO_RMT_CYCLES(n) ((n) / (RMT_CYCLES_PER_ESP_CYCLE))
|
||||
|
||||
// -- Number of cycles to signal the strip to latch
|
||||
#define NS_PER_CYCLE ( 1000000000L / RMT_CYCLES_PER_SEC )
|
||||
#define NS_TO_CYCLES(n) ( (n) / NS_PER_CYCLE )
|
||||
#define RMT_RESET_DURATION NS_TO_CYCLES(50000)
|
||||
|
||||
// -- Core or custom driver
|
||||
#ifndef FASTLED_RMT_BUILTIN_DRIVER
|
||||
#define FASTLED_RMT_BUILTIN_DRIVER false
|
||||
#endif
|
||||
|
||||
// -- Max number of controllers we can support
|
||||
#ifndef FASTLED_RMT_MAX_CONTROLLERS
|
||||
#define FASTLED_RMT_MAX_CONTROLLERS 32
|
||||
#endif
|
||||
|
||||
// -- Number of RMT channels to use (up to 8)
|
||||
// Redefine this value to 1 to force serial output
|
||||
#ifndef FASTLED_RMT_MAX_CHANNELS
|
||||
#define FASTLED_RMT_MAX_CHANNELS 8
|
||||
#endif
|
||||
|
||||
// -- Array of all controllers
|
||||
static CLEDController * gControllers[FASTLED_RMT_MAX_CONTROLLERS];
|
||||
|
||||
// -- Current set of active controllers, indexed by the RMT
|
||||
// channel assigned to them.
|
||||
static CLEDController * gOnChannel[FASTLED_RMT_MAX_CHANNELS];
|
||||
|
||||
static int gNumControllers = 0;
|
||||
static int gNumStarted = 0;
|
||||
static int gNumDone = 0;
|
||||
static int gNext = 0;
|
||||
|
||||
static intr_handle_t gRMT_intr_handle = NULL;
|
||||
|
||||
// -- Global semaphore for the whole show process
|
||||
// Semaphore is not given until all data has been sent
|
||||
static xSemaphoreHandle gTX_sem = NULL;
|
||||
|
||||
static bool gInitialized = false;
|
||||
|
||||
template <int DATA_PIN, int T1, int T2, int T3, EOrder RGB_ORDER = RGB, int XTRA0 = 0, bool FLIP = false, int WAIT_TIME = 5>
|
||||
class ClocklessController : public CPixelLEDController<RGB_ORDER>
|
||||
{
|
||||
// -- RMT has 8 channels, numbered 0 to 7
|
||||
rmt_channel_t mRMT_channel;
|
||||
|
||||
// -- Store the GPIO pin
|
||||
gpio_num_t mPin;
|
||||
|
||||
// -- This instantiation forces a check on the pin choice
|
||||
FastPin<DATA_PIN> mFastPin;
|
||||
|
||||
// -- Timing values for zero and one bits, derived from T1, T2, and T3
|
||||
rmt_item32_t mZero;
|
||||
rmt_item32_t mOne;
|
||||
|
||||
// -- Save the pixel controller
|
||||
PixelController<RGB_ORDER> * mPixels;
|
||||
int mCurColor;
|
||||
uint16_t mCurPulse;
|
||||
volatile uint32_t * mRMT_mem_ptr;
|
||||
|
||||
// -- Buffer to hold all of the pulses. For the version that uses
|
||||
// the RMT driver built into the ESP core.
|
||||
rmt_item32_t * mBuffer;
|
||||
uint16_t mBufferSize;
|
||||
|
||||
public:
|
||||
|
||||
void init()
|
||||
{
|
||||
// -- Allocate space to save the pixel controller
|
||||
// during parallel output
|
||||
mPixels = (PixelController<RGB_ORDER> *) malloc(sizeof(PixelController<RGB_ORDER>));
|
||||
|
||||
// -- Precompute rmt items corresponding to a zero bit and a one bit
|
||||
// according to the timing values given in the template instantiation
|
||||
// T1H
|
||||
mOne.level0 = 1;
|
||||
mOne.duration0 = ESP_TO_RMT_CYCLES(T1+T2); // TO_RMT_CYCLES(T1+T2);
|
||||
// T1L
|
||||
mOne.level1 = 0;
|
||||
mOne.duration1 = ESP_TO_RMT_CYCLES(T3); // TO_RMT_CYCLES(T3);
|
||||
|
||||
// T0H
|
||||
mZero.level0 = 1;
|
||||
mZero.duration0 = ESP_TO_RMT_CYCLES(T1); // TO_RMT_CYCLES(T1);
|
||||
// T0L
|
||||
mZero.level1 = 0;
|
||||
mZero.duration1 = ESP_TO_RMT_CYCLES(T2+T3); // TO_RMT_CYCLES(T2 + T3);
|
||||
|
||||
gControllers[gNumControllers] = this;
|
||||
gNumControllers++;
|
||||
|
||||
mPin = gpio_num_t(DATA_PIN);
|
||||
}
|
||||
|
||||
virtual uint16_t getMaxRefreshRate() const { return 400; }
|
||||
|
||||
protected:
|
||||
|
||||
void initRMT()
|
||||
{
|
||||
for (int i = 0; i < FASTLED_RMT_MAX_CHANNELS; i++) {
|
||||
gOnChannel[i] = NULL;
|
||||
|
||||
// -- RMT configuration for transmission
|
||||
rmt_config_t rmt_tx;
|
||||
rmt_tx.channel = rmt_channel_t(i);
|
||||
rmt_tx.rmt_mode = RMT_MODE_TX;
|
||||
rmt_tx.gpio_num = mPin; // The particular pin will be assigned later
|
||||
rmt_tx.mem_block_num = 1;
|
||||
rmt_tx.clk_div = DIVIDER;
|
||||
rmt_tx.tx_config.loop_en = false;
|
||||
rmt_tx.tx_config.carrier_level = RMT_CARRIER_LEVEL_LOW;
|
||||
rmt_tx.tx_config.carrier_en = false;
|
||||
rmt_tx.tx_config.idle_level = RMT_IDLE_LEVEL_LOW;
|
||||
rmt_tx.tx_config.idle_output_en = true;
|
||||
|
||||
// -- Apply the configuration
|
||||
rmt_config(&rmt_tx);
|
||||
|
||||
if (FASTLED_RMT_BUILTIN_DRIVER) {
|
||||
rmt_driver_install(rmt_channel_t(i), 0, 0);
|
||||
} else {
|
||||
// -- Set up the RMT to send 1 pixel of the pulse buffer and then
|
||||
// generate an interrupt. When we get this interrupt we
|
||||
// fill the other part in preparation (kind of like double-buffering)
|
||||
rmt_set_tx_thr_intr_en(rmt_channel_t(i), true, PULSES_PER_FILL);
|
||||
}
|
||||
}
|
||||
|
||||
// -- Create a semaphore to block execution until all the controllers are done
|
||||
if (gTX_sem == NULL) {
|
||||
gTX_sem = xSemaphoreCreateBinary();
|
||||
xSemaphoreGive(gTX_sem);
|
||||
}
|
||||
|
||||
if ( ! FASTLED_RMT_BUILTIN_DRIVER) {
|
||||
// -- Allocate the interrupt if we have not done so yet. This
|
||||
// interrupt handler must work for all different kinds of
|
||||
// strips, so it delegates to the refill function for each
|
||||
// specific instantiation of ClocklessController.
|
||||
if (gRMT_intr_handle == NULL)
|
||||
esp_intr_alloc(ETS_RMT_INTR_SOURCE, ESP_INTR_FLAG_LEVEL3, interruptHandler, 0, &gRMT_intr_handle);
|
||||
}
|
||||
|
||||
gInitialized = true;
|
||||
}
|
||||
|
||||
// -- Show pixels
|
||||
// This is the main entry point for the controller.
|
||||
virtual void IRAM_ATTR showPixels(PixelController<RGB_ORDER> & pixels)
|
||||
{
|
||||
if (gNumStarted == 0) {
|
||||
// -- First controller: make sure everything is set up
|
||||
// -- Only need to do this once
|
||||
if ( ! gInitialized) {
|
||||
initRMT();
|
||||
}
|
||||
xSemaphoreTake(gTX_sem, portMAX_DELAY);
|
||||
}
|
||||
|
||||
if (FASTLED_RMT_BUILTIN_DRIVER)
|
||||
convertAllPixelData(pixels);
|
||||
else {
|
||||
// -- Initialize the local state, save a pointer to the pixel
|
||||
// data. We need to make a copy because pixels is a local
|
||||
// variable in the calling function, and this data structure
|
||||
// needs to outlive this call to showPixels.
|
||||
(*mPixels) = pixels;
|
||||
}
|
||||
|
||||
// -- Keep track of the number of strips we've seen
|
||||
gNumStarted++;
|
||||
|
||||
// -- The last call to showPixels is the one responsible for doing
|
||||
// all of the actual worl
|
||||
if (gNumStarted == gNumControllers) {
|
||||
gNext = 0;
|
||||
|
||||
// -- First, fill all the available channels
|
||||
int channel = 0;
|
||||
while (channel < FASTLED_RMT_MAX_CHANNELS && gNext < gNumControllers) {
|
||||
startNext(channel);
|
||||
channel++;
|
||||
}
|
||||
|
||||
// -- Start them all
|
||||
for (int i = 0; i < channel; i++) {
|
||||
ClocklessController * pController = static_cast<ClocklessController*>(gControllers[i]);
|
||||
rmt_tx_start(pController->mRMT_channel, true);
|
||||
}
|
||||
|
||||
// -- Wait here while the rest of the data is sent. The interrupt handler
|
||||
// will keep refilling the RMT buffers until it is all sent; then it
|
||||
// gives the semaphore back.
|
||||
xSemaphoreTake(gTX_sem, portMAX_DELAY);
|
||||
xSemaphoreGive(gTX_sem);
|
||||
|
||||
// -- Reset the counters
|
||||
gNumStarted = 0;
|
||||
gNumDone = 0;
|
||||
gNext = 0;
|
||||
}
|
||||
}
|
||||
|
||||
// -- Convert all pixels to RMT pulses
|
||||
// This function is only used when the user chooses to use the
|
||||
// built-in RMT driver, which needs all of the RMT pulses
|
||||
// up-front.
|
||||
void convertAllPixelData(PixelController<RGB_ORDER> & pixels)
|
||||
{
|
||||
// -- Compute the pulse values for the whole strip at once.
|
||||
// Requires a large buffer
|
||||
mBufferSize = pixels.size() * 3 * 8;
|
||||
|
||||
if (mBuffer == NULL) {
|
||||
mBuffer = (rmt_item32_t *) calloc( mBufferSize, sizeof(rmt_item32_t));
|
||||
}
|
||||
|
||||
// -- Cycle through the R,G, and B values in the right order,
|
||||
// storing the pulses in the big buffer
|
||||
mCurPulse = 0;
|
||||
|
||||
uint32_t byteval;
|
||||
while (pixels.has(1)) {
|
||||
byteval = pixels.loadAndScale0();
|
||||
convertByte(byteval);
|
||||
byteval = pixels.loadAndScale1();
|
||||
convertByte(byteval);
|
||||
byteval = pixels.loadAndScale2();
|
||||
convertByte(byteval);
|
||||
pixels.advanceData();
|
||||
pixels.stepDithering();
|
||||
}
|
||||
|
||||
mBuffer[mCurPulse-1].duration1 = RMT_RESET_DURATION;
|
||||
assert(mCurPulse == mBufferSize);
|
||||
}
|
||||
|
||||
void convertByte(uint32_t byteval)
|
||||
{
|
||||
// -- Write one byte's worth of RMT pulses to the big buffer
|
||||
byteval <<= 24;
|
||||
for (register uint32_t j = 0; j < 8; j++) {
|
||||
mBuffer[mCurPulse] = (byteval & 0x80000000L) ? mOne : mZero;
|
||||
byteval <<= 1;
|
||||
mCurPulse++;
|
||||
}
|
||||
}
|
||||
|
||||
// -- Start up the next controller
|
||||
// This method is static so that it can dispatch to the
|
||||
// appropriate startOnChannel method of the given controller.
|
||||
static void IRAM_ATTR startNext(int channel)
|
||||
{
|
||||
if (gNext < gNumControllers) {
|
||||
ClocklessController * pController = static_cast<ClocklessController*>(gControllers[gNext]);
|
||||
pController->startOnChannel(channel);
|
||||
gNext++;
|
||||
}
|
||||
}
|
||||
|
||||
// -- Start this controller on the given channel
|
||||
// This function just initiates the RMT write; it does not wait
|
||||
// for it to finish.
|
||||
void IRAM_ATTR startOnChannel(int channel)
|
||||
{
|
||||
// -- Assign this channel and configure the RMT
|
||||
mRMT_channel = rmt_channel_t(channel);
|
||||
|
||||
// -- Store a reference to this controller, so we can get it
|
||||
// inside the interrupt handler
|
||||
gOnChannel[channel] = this;
|
||||
|
||||
// -- Assign the pin to this channel
|
||||
rmt_set_pin(mRMT_channel, RMT_MODE_TX, mPin);
|
||||
|
||||
if (FASTLED_RMT_BUILTIN_DRIVER) {
|
||||
// -- Use the built-in RMT driver to send all the data in one shot
|
||||
rmt_register_tx_end_callback(doneOnChannel, 0);
|
||||
rmt_write_items(mRMT_channel, mBuffer, mBufferSize, false);
|
||||
} else {
|
||||
// -- Use our custom driver to send the data incrementally
|
||||
|
||||
// -- Initialize the counters that keep track of where we are in
|
||||
// the pixel data.
|
||||
mRMT_mem_ptr = & (RMTMEM.chan[mRMT_channel].data32[0].val);
|
||||
mCurPulse = 0;
|
||||
mCurColor = 0;
|
||||
|
||||
// -- Store 2 pixels worth of data (two "buffers" full)
|
||||
fillNext();
|
||||
fillNext();
|
||||
|
||||
// -- Turn on the interrupts
|
||||
rmt_set_tx_intr_en(mRMT_channel, true);
|
||||
}
|
||||
}
|
||||
|
||||
// -- A controller is done
|
||||
// This function is called when a controller finishes writing
|
||||
// its data. It is called either by the custom interrupt
|
||||
// handler (below), or as a callback from the built-in
|
||||
// interrupt handler. It is static because we don't know which
|
||||
// controller is done until we look it up.
|
||||
static void IRAM_ATTR doneOnChannel(rmt_channel_t channel, void * arg)
|
||||
{
|
||||
ClocklessController * controller = static_cast<ClocklessController*>(gOnChannel[channel]);
|
||||
portBASE_TYPE HPTaskAwoken = 0;
|
||||
|
||||
// -- Turn off output on the pin
|
||||
gpio_matrix_out(controller->mPin, 0x100, 0, 0);
|
||||
|
||||
gOnChannel[channel] = NULL;
|
||||
gNumDone++;
|
||||
|
||||
if (gNumDone == gNumControllers) {
|
||||
// -- If this is the last controller, signal that we are all done
|
||||
xSemaphoreGiveFromISR(gTX_sem, &HPTaskAwoken);
|
||||
if(HPTaskAwoken == pdTRUE) portYIELD_FROM_ISR();
|
||||
} else {
|
||||
// -- Otherwise, if there are still controllers waiting, then
|
||||
// start the next one on this channel
|
||||
if (gNext < gNumControllers) {
|
||||
startNext(channel);
|
||||
// -- Start the RMT TX operation
|
||||
// (I'm not sure if this is necessary here)
|
||||
rmt_tx_start(controller->mRMT_channel, true);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// -- Custom interrupt handler
|
||||
// This interrupt handler handles two cases: a controller is
|
||||
// done writing its data, or a controller needs to fill the
|
||||
// next half of the RMT buffer with data.
|
||||
static void IRAM_ATTR interruptHandler(void *arg)
|
||||
{
|
||||
// -- The basic structure of this code is borrowed from the
|
||||
// interrupt handler in esp-idf/components/driver/rmt.c
|
||||
uint32_t intr_st = RMT.int_st.val;
|
||||
uint8_t channel;
|
||||
|
||||
for (channel = 0; channel < FASTLED_RMT_MAX_CHANNELS; channel++) {
|
||||
int tx_done_bit = channel * 3;
|
||||
int tx_next_bit = channel + 24;
|
||||
|
||||
if (gOnChannel[channel] != NULL) {
|
||||
|
||||
// -- More to send on this channel
|
||||
if (intr_st & BIT(tx_next_bit)) {
|
||||
RMT.int_clr.val |= BIT(tx_next_bit);
|
||||
|
||||
// -- Refill the half of the buffer that we just finished,
|
||||
// allowing the other half to proceed.
|
||||
ClocklessController * controller = static_cast<ClocklessController*>(gOnChannel[channel]);
|
||||
controller->fillNext();
|
||||
} else {
|
||||
// -- Transmission is complete on this channel
|
||||
if (intr_st & BIT(tx_done_bit)) {
|
||||
RMT.int_clr.val |= BIT(tx_done_bit);
|
||||
doneOnChannel(rmt_channel_t(channel), 0);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// -- Fill RMT buffer
|
||||
// Puts one pixel's worth of data into the next 24 slots in the RMT memory
|
||||
void IRAM_ATTR fillNext()
|
||||
{
|
||||
if (mPixels->has(1)) {
|
||||
uint32_t t1 = __clock_cycles();
|
||||
|
||||
uint32_t one_val = mOne.val;
|
||||
uint32_t zero_val = mZero.val;
|
||||
|
||||
// -- Get a pixel's worth of data
|
||||
uint8_t byte0 = mPixels->loadAndScale0();
|
||||
uint8_t byte1 = mPixels->loadAndScale1();
|
||||
uint8_t byte2 = mPixels->loadAndScale2();
|
||||
mPixels->advanceData();
|
||||
mPixels->stepDithering();
|
||||
|
||||
// -- Fill 24 slots in the RMT memory
|
||||
register uint32_t pixel = byte0 << 24 | byte1 << 16 | byte2 << 8;
|
||||
|
||||
// -- Use locals for speed
|
||||
volatile register uint32_t * pItem = mRMT_mem_ptr;
|
||||
register uint16_t curPulse = mCurPulse;
|
||||
|
||||
// Shift bits out, MSB first, setting RMTMEM.chan[n].data32[x] to the
|
||||
// rmt_item32_t value corresponding to the buffered bit value
|
||||
for (register uint32_t j = 0; j < 24; j++) {
|
||||
uint32_t val = (pixel & 0x80000000L) ? one_val : zero_val;
|
||||
*pItem++ = val;
|
||||
// Replaces: RMTMEM.chan[mRMT_channel].data32[mCurPulse].val = val;
|
||||
|
||||
pixel <<= 1;
|
||||
curPulse++;
|
||||
|
||||
if (curPulse == MAX_PULSES) {
|
||||
pItem = & (RMTMEM.chan[mRMT_channel].data32[0].val);
|
||||
curPulse = 0;
|
||||
}
|
||||
}
|
||||
|
||||
// -- Store the new values back into the object
|
||||
mCurPulse = curPulse;
|
||||
mRMT_mem_ptr = pItem;
|
||||
} else {
|
||||
// -- No more data; signal to the RMT we are done
|
||||
for (uint32_t j = 0; j < 8; j++) {
|
||||
* mRMT_mem_ptr++ = 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// NO LONGER USED
|
||||
uint8_t IRAM_ATTR getNextByte() __attribute__ ((always_inline))
|
||||
{
|
||||
uint8_t byte;
|
||||
|
||||
// -- Cycle through the color channels
|
||||
switch (mCurColor) {
|
||||
case 0:
|
||||
byte = mPixels->loadAndScale0();
|
||||
break;
|
||||
case 1:
|
||||
byte = mPixels->loadAndScale1();
|
||||
break;
|
||||
case 2:
|
||||
byte = mPixels->loadAndScale2();
|
||||
mPixels->advanceData();
|
||||
mPixels->stepDithering();
|
||||
break;
|
||||
default:
|
||||
// -- This is bad!
|
||||
byte = 0;
|
||||
}
|
||||
|
||||
mCurColor++;
|
||||
if (mCurColor == NUM_COLOR_CHANNELS) mCurColor = 0;
|
||||
|
||||
return byte;
|
||||
}
|
||||
|
||||
|
||||
// NO LONGER USED
|
||||
// -- Fill the RMT buffer
|
||||
// This function fills the next 32 slots in the RMT write
|
||||
// buffer with pixel data. It also handles the case where the
|
||||
// pixel data is exhausted, so we need to fill the RMT buffer
|
||||
// with zeros to signal that it's done.
|
||||
virtual void IRAM_ATTR fillHalfRMTBuffer()
|
||||
{
|
||||
uint32_t one_val = mOne.val;
|
||||
uint32_t zero_val = mZero.val;
|
||||
|
||||
// -- Convert (up to) 32 bits of the raw pixel data into
|
||||
// into RMT pulses that encode the zeros and ones.
|
||||
int pulses = 0;
|
||||
register uint32_t byteval;
|
||||
while (pulses < 32 && mPixels->has(1)) {
|
||||
// -- Get one byte
|
||||
// -- Cycle through the color channels
|
||||
switch (mCurColor) {
|
||||
case 0:
|
||||
byteval = mPixels->loadAndScale0();
|
||||
break;
|
||||
case 1:
|
||||
byteval = mPixels->loadAndScale1();
|
||||
break;
|
||||
case 2:
|
||||
byteval = mPixels->loadAndScale2();
|
||||
mPixels->advanceData();
|
||||
mPixels->stepDithering();
|
||||
break;
|
||||
default:
|
||||
// -- This is bad!
|
||||
byteval = 0;
|
||||
}
|
||||
|
||||
mCurColor++;
|
||||
if (mCurColor == NUM_COLOR_CHANNELS) mCurColor = 0;
|
||||
|
||||
// byteval = getNextByte();
|
||||
byteval <<= 24;
|
||||
// Shift bits out, MSB first, setting RMTMEM.chan[n].data32[x] to the
|
||||
// rmt_item32_t value corresponding to the buffered bit value
|
||||
for (register uint32_t j = 0; j < 8; j++) {
|
||||
uint32_t val = (byteval & 0x80000000L) ? one_val : zero_val;
|
||||
* mRMT_mem_ptr++ = val;
|
||||
// Replaces: RMTMEM.chan[mRMT_channel].data32[mCurPulse].val = val;
|
||||
byteval <<= 1;
|
||||
mCurPulse++;
|
||||
}
|
||||
pulses += 8;
|
||||
}
|
||||
|
||||
// -- When we reach the end of the pixel data, fill the rest of the
|
||||
// RMT buffer with 0's, which signals to the device that we're done.
|
||||
if ( ! mPixels->has(1) ) {
|
||||
while (pulses < 32) {
|
||||
* mRMT_mem_ptr++ = 0;
|
||||
// Replaces: RMTMEM.chan[mRMT_channel].data32[mCurPulse].val = 0;
|
||||
mCurPulse++;
|
||||
pulses++;
|
||||
}
|
||||
}
|
||||
|
||||
// -- When we have filled the back half the buffer, reset the position to the first half
|
||||
if (mCurPulse == MAX_PULSES) {
|
||||
mRMT_mem_ptr = & (RMTMEM.chan[mRMT_channel].data32[0].val);
|
||||
mCurPulse = 0;
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
FASTLED_NAMESPACE_END
|
||||
11
components/FastLED-idf/platforms/esp/32/fastled_esp32.h
Normal file
11
components/FastLED-idf/platforms/esp/32/fastled_esp32.h
Normal file
@ -0,0 +1,11 @@
|
||||
#pragma once
|
||||
|
||||
#include "fastpin_esp32.h"
|
||||
|
||||
#ifdef FASTLED_ESP32_I2S
|
||||
#include "clockless_i2s_esp32.h"
|
||||
#else
|
||||
#include "clockless_rmt_esp32.h"
|
||||
#endif
|
||||
|
||||
// #include "clockless_block_esp32.h"
|
||||
115
components/FastLED-idf/platforms/esp/32/fastpin_esp32.h
Normal file
115
components/FastLED-idf/platforms/esp/32/fastpin_esp32.h
Normal file
@ -0,0 +1,115 @@
|
||||
#pragma once
|
||||
|
||||
FASTLED_NAMESPACE_BEGIN
|
||||
|
||||
template<uint8_t PIN, uint32_t MASK> class _ESPPIN {
|
||||
|
||||
public:
|
||||
typedef volatile uint32_t * port_ptr_t;
|
||||
typedef uint32_t port_t;
|
||||
|
||||
inline static void setOutput() { pinMode(PIN, OUTPUT); }
|
||||
inline static void setInput() { pinMode(PIN, INPUT); }
|
||||
|
||||
inline static void hi() __attribute__ ((always_inline)) {
|
||||
if (PIN < 32) GPIO.out_w1ts = MASK;
|
||||
else GPIO.out1_w1ts.val = MASK;
|
||||
}
|
||||
|
||||
inline static void lo() __attribute__ ((always_inline)) {
|
||||
if (PIN < 32) GPIO.out_w1tc = MASK;
|
||||
else GPIO.out1_w1tc.val = MASK;
|
||||
}
|
||||
|
||||
inline static void set(register port_t val) __attribute__ ((always_inline)) {
|
||||
if (PIN < 32) GPIO.out = val;
|
||||
else GPIO.out1.val = val;
|
||||
}
|
||||
|
||||
inline static void strobe() __attribute__ ((always_inline)) { toggle(); toggle(); }
|
||||
|
||||
inline static void toggle() __attribute__ ((always_inline)) {
|
||||
if(PIN < 32) { GPIO.out ^= MASK; }
|
||||
else { GPIO.out1.val ^=MASK; }
|
||||
}
|
||||
|
||||
inline static void hi(register port_ptr_t port) __attribute__ ((always_inline)) { hi(); }
|
||||
inline static void lo(register port_ptr_t port) __attribute__ ((always_inline)) { lo(); }
|
||||
inline static void fastset(register port_ptr_t port, register port_t val) __attribute__ ((always_inline)) { *port = val; }
|
||||
|
||||
inline static port_t hival() __attribute__ ((always_inline)) {
|
||||
if (PIN < 32) return GPIO.out | MASK;
|
||||
else return GPIO.out1.val | MASK;
|
||||
}
|
||||
|
||||
inline static port_t loval() __attribute__ ((always_inline)) {
|
||||
if (PIN < 32) return GPIO.out & ~MASK;
|
||||
else return GPIO.out1.val & ~MASK;
|
||||
}
|
||||
|
||||
inline static port_ptr_t port() __attribute__ ((always_inline)) {
|
||||
if (PIN < 32) return &GPIO.out;
|
||||
else return &GPIO.out1.val;
|
||||
}
|
||||
|
||||
inline static port_ptr_t sport() __attribute__ ((always_inline)) {
|
||||
if (PIN < 32) return &GPIO.out_w1ts;
|
||||
else return &GPIO.out1_w1ts.val;
|
||||
}
|
||||
|
||||
inline static port_ptr_t cport() __attribute__ ((always_inline)) {
|
||||
if (PIN < 32) return &GPIO.out_w1tc;
|
||||
else return &GPIO.out1_w1tc.val;
|
||||
}
|
||||
|
||||
inline static port_t mask() __attribute__ ((always_inline)) { return MASK; }
|
||||
|
||||
inline static bool isset() __attribute__ ((always_inline)) {
|
||||
if (PIN < 32) return GPIO.out & MASK;
|
||||
else return GPIO.out1.val & MASK;
|
||||
}
|
||||
};
|
||||
|
||||
#define _FL_DEFPIN(PIN) template<> class FastPin<PIN> : public _ESPPIN<PIN, ((PIN<32)?((uint32_t)1 << PIN):((uint32_t)1 << (PIN-32)))> {};
|
||||
|
||||
_FL_DEFPIN(0);
|
||||
_FL_DEFPIN(1); // WARNING: Using TX causes flashiness when uploading
|
||||
_FL_DEFPIN(2);
|
||||
_FL_DEFPIN(3); // WARNING: Using RX causes flashiness when uploading
|
||||
_FL_DEFPIN(4);
|
||||
_FL_DEFPIN(5);
|
||||
|
||||
// -- These pins are not safe to use:
|
||||
// _FL_DEFPIN(6,6); _FL_DEFPIN(7,7); _FL_DEFPIN(8,8);
|
||||
// _FL_DEFPIN(9,9); _FL_DEFPIN(10,10); _FL_DEFPIN(11,11);
|
||||
|
||||
_FL_DEFPIN(12);
|
||||
_FL_DEFPIN(13);
|
||||
_FL_DEFPIN(14);
|
||||
_FL_DEFPIN(15);
|
||||
_FL_DEFPIN(16);
|
||||
_FL_DEFPIN(17);
|
||||
_FL_DEFPIN(18);
|
||||
_FL_DEFPIN(19);
|
||||
|
||||
// No pin 20 : _FL_DEFPIN(20,20);
|
||||
|
||||
_FL_DEFPIN(21); // Works, but note that GPIO21 is I2C SDA
|
||||
_FL_DEFPIN(22); // Works, but note that GPIO22 is I2C SCL
|
||||
_FL_DEFPIN(23);
|
||||
|
||||
// No pin 24 : _FL_DEFPIN(24,24);
|
||||
|
||||
_FL_DEFPIN(25);
|
||||
_FL_DEFPIN(26);
|
||||
_FL_DEFPIN(27);
|
||||
|
||||
// No pin 28-31: _FL_DEFPIN(28,28); _FL_DEFPIN(29,29); _FL_DEFPIN(30,30); _FL_DEFPIN(31,31);
|
||||
|
||||
// Need special handling for pins > 31
|
||||
_FL_DEFPIN(32);
|
||||
_FL_DEFPIN(33);
|
||||
|
||||
#define HAS_HARDWARE_PIN_SUPPORT
|
||||
|
||||
FASTLED_NAMESPACE_END
|
||||
33
components/FastLED-idf/platforms/esp/32/led_sysdefs_esp32.h
Normal file
33
components/FastLED-idf/platforms/esp/32/led_sysdefs_esp32.h
Normal file
@ -0,0 +1,33 @@
|
||||
#pragma once
|
||||
|
||||
#ifndef ESP32
|
||||
#define ESP32
|
||||
#endif
|
||||
|
||||
#define FASTLED_ESP32
|
||||
|
||||
// Use system millis timer
|
||||
#define FASTLED_HAS_MILLIS
|
||||
|
||||
typedef volatile uint32_t RoReg;
|
||||
typedef volatile uint32_t RwReg;
|
||||
typedef unsigned long prog_uint32_t;
|
||||
|
||||
|
||||
// Default to NOT using PROGMEM here
|
||||
#ifndef FASTLED_USE_PROGMEM
|
||||
# define FASTLED_USE_PROGMEM 0
|
||||
#endif
|
||||
|
||||
#ifndef FASTLED_ALLOW_INTERRUPTS
|
||||
# define FASTLED_ALLOW_INTERRUPTS 1
|
||||
# define INTERRUPT_THRESHOLD 0
|
||||
#endif
|
||||
|
||||
#define NEED_CXX_BITS
|
||||
|
||||
// These can be overridden
|
||||
# define FASTLED_ESP32_RAW_PIN_ORDER
|
||||
|
||||
// #define cli() os_intr_lock();
|
||||
// #define sei() os_intr_lock();
|
||||
@ -0,0 +1,159 @@
|
||||
#ifndef __INC_CLOCKLESS_BLOCK_ESP8266_H
|
||||
#define __INC_CLOCKLESS_BLOCK_ESP8266_H
|
||||
|
||||
#define FASTLED_HAS_BLOCKLESS 1
|
||||
|
||||
#define FIX_BITS(bits) (((bits & 0x0fL) << 12) | (bits & 0x30))
|
||||
|
||||
#define MIN(X,Y) (((X)<(Y)) ? (X):(Y))
|
||||
#define USED_LANES (MIN(LANES, 6))
|
||||
#define PORT_MASK (((1 << USED_LANES)-1) & 0x0000FFFFL)
|
||||
#define PIN_MASK FIX_BITS(PORT_MASK)
|
||||
|
||||
FASTLED_NAMESPACE_BEGIN
|
||||
|
||||
#ifdef FASTLED_DEBUG_COUNT_FRAME_RETRIES
|
||||
extern uint32_t _frame_cnt;
|
||||
extern uint32_t _retry_cnt;
|
||||
#endif
|
||||
|
||||
template <uint8_t LANES, int FIRST_PIN, int T1, int T2, int T3, EOrder RGB_ORDER = GRB, int XTRA0 = 0, bool FLIP = false, int WAIT_TIME = 50>
|
||||
class InlineBlockClocklessController : public CPixelLEDController<RGB_ORDER, LANES, PORT_MASK> {
|
||||
typedef typename FastPin<FIRST_PIN>::port_ptr_t data_ptr_t;
|
||||
typedef typename FastPin<FIRST_PIN>::port_t data_t;
|
||||
|
||||
CMinWait<WAIT_TIME> mWait;
|
||||
public:
|
||||
virtual int size() { return CLEDController::size() * LANES; }
|
||||
|
||||
virtual void showPixels(PixelController<RGB_ORDER, LANES, PORT_MASK> & pixels) {
|
||||
// mWait.wait();
|
||||
/*uint32_t clocks = */
|
||||
int cnt=FASTLED_INTERRUPT_RETRY_COUNT;
|
||||
while(!showRGBInternal(pixels) && cnt--) {
|
||||
os_intr_unlock();
|
||||
#ifdef FASTLED_DEBUG_COUNT_FRAME_RETRIES
|
||||
_retry_cnt++;
|
||||
#endif
|
||||
delayMicroseconds(WAIT_TIME * 10);
|
||||
os_intr_lock();
|
||||
}
|
||||
// #if FASTLED_ALLOW_INTTERUPTS == 0
|
||||
// Adjust the timer
|
||||
// long microsTaken = CLKS_TO_MICROS(clocks);
|
||||
// MS_COUNTER += (1 + (microsTaken / 1000));
|
||||
// #endif
|
||||
|
||||
// mWait.mark();
|
||||
}
|
||||
|
||||
template<int PIN> static void initPin() {
|
||||
_ESPPIN<PIN, 1<<(PIN & 0xFF)>::setOutput();
|
||||
}
|
||||
|
||||
virtual void init() {
|
||||
void (* funcs[])() ={initPin<12>, initPin<13>, initPin<14>, initPin<15>, initPin<4>, initPin<5>};
|
||||
|
||||
for (uint8_t i = 0; i < USED_LANES; ++i) {
|
||||
funcs[i]();
|
||||
}
|
||||
}
|
||||
|
||||
virtual uint16_t getMaxRefreshRate() const { return 400; }
|
||||
|
||||
typedef union {
|
||||
uint8_t bytes[8];
|
||||
uint16_t shorts[4];
|
||||
uint32_t raw[2];
|
||||
} Lines;
|
||||
|
||||
#define ESP_ADJUST 0 // (2*(F_CPU/24000000))
|
||||
#define ESP_ADJUST2 0
|
||||
template<int BITS,int PX> __attribute__ ((always_inline)) inline static void writeBits(register uint32_t & last_mark, register Lines & b, PixelController<RGB_ORDER, LANES, PORT_MASK> &pixels) { // , register uint32_t & b2) {
|
||||
Lines b2 = b;
|
||||
transpose8x1_noinline(b.bytes,b2.bytes);
|
||||
|
||||
register uint8_t d = pixels.template getd<PX>(pixels);
|
||||
register uint8_t scale = pixels.template getscale<PX>(pixels);
|
||||
|
||||
for(register uint32_t i = 0; i < USED_LANES; i++) {
|
||||
while((__clock_cycles() - last_mark) < (T1+T2+T3));
|
||||
last_mark = __clock_cycles();
|
||||
*FastPin<FIRST_PIN>::sport() = PIN_MASK;
|
||||
|
||||
uint32_t nword = (uint32_t)(~b2.bytes[7-i]);
|
||||
while((__clock_cycles() - last_mark) < (T1-6));
|
||||
*FastPin<FIRST_PIN>::cport() = FIX_BITS(nword);
|
||||
|
||||
while((__clock_cycles() - last_mark) < (T1+T2));
|
||||
*FastPin<FIRST_PIN>::cport() = PIN_MASK;
|
||||
|
||||
b.bytes[i] = pixels.template loadAndScale<PX>(pixels,i,d,scale);
|
||||
}
|
||||
|
||||
for(register uint32_t i = USED_LANES; i < 8; i++) {
|
||||
while((__clock_cycles() - last_mark) < (T1+T2+T3));
|
||||
last_mark = __clock_cycles();
|
||||
*FastPin<FIRST_PIN>::sport() = PIN_MASK;
|
||||
|
||||
uint32_t nword = (uint32_t)(~b2.bytes[7-i]);
|
||||
while((__clock_cycles() - last_mark) < (T1-6));
|
||||
*FastPin<FIRST_PIN>::cport() = FIX_BITS(nword);
|
||||
|
||||
while((__clock_cycles() - last_mark) < (T1+T2));
|
||||
*FastPin<FIRST_PIN>::cport() = PIN_MASK;
|
||||
}
|
||||
}
|
||||
|
||||
// This method is made static to force making register Y available to use for data on AVR - if the method is non-static, then
|
||||
// gcc will use register Y for the this pointer.
|
||||
static uint32_t ICACHE_RAM_ATTR showRGBInternal(PixelController<RGB_ORDER, LANES, PORT_MASK> &allpixels) {
|
||||
|
||||
// Setup the pixel controller and load/scale the first byte
|
||||
Lines b0;
|
||||
|
||||
for(int i = 0; i < USED_LANES; i++) {
|
||||
b0.bytes[i] = allpixels.loadAndScale0(i);
|
||||
}
|
||||
allpixels.preStepFirstByteDithering();
|
||||
|
||||
os_intr_lock();
|
||||
uint32_t _start = __clock_cycles();
|
||||
uint32_t last_mark = _start;
|
||||
|
||||
while(allpixels.has(1)) {
|
||||
// Write first byte, read next byte
|
||||
writeBits<8+XTRA0,1>(last_mark, b0, allpixels);
|
||||
|
||||
// Write second byte, read 3rd byte
|
||||
writeBits<8+XTRA0,2>(last_mark, b0, allpixels);
|
||||
allpixels.advanceData();
|
||||
|
||||
// Write third byte
|
||||
writeBits<8+XTRA0,0>(last_mark, b0, allpixels);
|
||||
|
||||
#if (FASTLED_ALLOW_INTERRUPTS == 1)
|
||||
os_intr_unlock();
|
||||
#endif
|
||||
|
||||
allpixels.stepDithering();
|
||||
|
||||
#if (FASTLED_ALLOW_INTERRUPTS == 1)
|
||||
os_intr_lock();
|
||||
// if interrupts took longer than 45µs, punt on the current frame
|
||||
if((int32_t)(__clock_cycles()-last_mark) > 0) {
|
||||
if((int32_t)(__clock_cycles()-last_mark) > (T1+T2+T3+((WAIT_TIME-INTERRUPT_THRESHOLD)*CLKS_PER_US))) { os_intr_unlock(); return 0; }
|
||||
}
|
||||
#endif
|
||||
};
|
||||
|
||||
os_intr_unlock();
|
||||
#ifdef FASTLED_DEBUG_COUNT_FRAME_RETRIES
|
||||
_frame_cnt++;
|
||||
#endif
|
||||
return __clock_cycles() - _start;
|
||||
}
|
||||
};
|
||||
|
||||
FASTLED_NAMESPACE_END
|
||||
#endif
|
||||
117
components/FastLED-idf/platforms/esp/8266/clockless_esp8266.h
Normal file
117
components/FastLED-idf/platforms/esp/8266/clockless_esp8266.h
Normal file
@ -0,0 +1,117 @@
|
||||
#pragma once
|
||||
|
||||
FASTLED_NAMESPACE_BEGIN
|
||||
|
||||
#ifdef FASTLED_DEBUG_COUNT_FRAME_RETRIES
|
||||
extern uint32_t _frame_cnt;
|
||||
extern uint32_t _retry_cnt;
|
||||
#endif
|
||||
|
||||
// Info on reading cycle counter from https://github.com/kbeckmann/nodemcu-firmware/blob/ws2812-dual/app/modules/ws2812.c
|
||||
__attribute__ ((always_inline)) inline static uint32_t __clock_cycles() {
|
||||
uint32_t cyc;
|
||||
__asm__ __volatile__ ("rsr %0,ccount":"=a" (cyc));
|
||||
return cyc;
|
||||
}
|
||||
|
||||
#define FASTLED_HAS_CLOCKLESS 1
|
||||
|
||||
template <int DATA_PIN, int T1, int T2, int T3, EOrder RGB_ORDER = RGB, int XTRA0 = 0, bool FLIP = false, int WAIT_TIME = 50>
|
||||
class ClocklessController : public CPixelLEDController<RGB_ORDER> {
|
||||
typedef typename FastPin<DATA_PIN>::port_ptr_t data_ptr_t;
|
||||
typedef typename FastPin<DATA_PIN>::port_t data_t;
|
||||
|
||||
data_t mPinMask;
|
||||
data_ptr_t mPort;
|
||||
CMinWait<WAIT_TIME> mWait;
|
||||
public:
|
||||
virtual void init() {
|
||||
FastPin<DATA_PIN>::setOutput();
|
||||
mPinMask = FastPin<DATA_PIN>::mask();
|
||||
mPort = FastPin<DATA_PIN>::port();
|
||||
}
|
||||
|
||||
virtual uint16_t getMaxRefreshRate() const { return 400; }
|
||||
|
||||
protected:
|
||||
|
||||
virtual void showPixels(PixelController<RGB_ORDER> & pixels) {
|
||||
// mWait.wait();
|
||||
int cnt = FASTLED_INTERRUPT_RETRY_COUNT;
|
||||
while((showRGBInternal(pixels)==0) && cnt--) {
|
||||
#ifdef FASTLED_DEBUG_COUNT_FRAME_RETRIES
|
||||
_retry_cnt++;
|
||||
#endif
|
||||
os_intr_unlock();
|
||||
delayMicroseconds(WAIT_TIME);
|
||||
os_intr_lock();
|
||||
}
|
||||
// mWait.mark();
|
||||
}
|
||||
|
||||
#define _ESP_ADJ (0)
|
||||
#define _ESP_ADJ2 (0)
|
||||
|
||||
template<int BITS> __attribute__ ((always_inline)) inline static void writeBits(register uint32_t & last_mark, register uint32_t b) {
|
||||
b <<= 24; b = ~b;
|
||||
for(register uint32_t i = BITS; i > 0; i--) {
|
||||
while((__clock_cycles() - last_mark) < (T1+T2+T3));
|
||||
last_mark = __clock_cycles();
|
||||
FastPin<DATA_PIN>::hi();
|
||||
|
||||
while((__clock_cycles() - last_mark) < T1);
|
||||
if(b & 0x80000000L) { FastPin<DATA_PIN>::lo(); }
|
||||
b <<= 1;
|
||||
|
||||
while((__clock_cycles() - last_mark) < (T1+T2));
|
||||
FastPin<DATA_PIN>::lo();
|
||||
}
|
||||
}
|
||||
|
||||
// This method is made static to force making register Y available to use for data on AVR - if the method is non-static, then
|
||||
// gcc will use register Y for the this pointer.
|
||||
static uint32_t ICACHE_RAM_ATTR showRGBInternal(PixelController<RGB_ORDER> pixels) {
|
||||
// Setup the pixel controller and load/scale the first byte
|
||||
pixels.preStepFirstByteDithering();
|
||||
register uint32_t b = pixels.loadAndScale0();
|
||||
pixels.preStepFirstByteDithering();
|
||||
os_intr_lock();
|
||||
uint32_t start = __clock_cycles();
|
||||
uint32_t last_mark = start;
|
||||
while(pixels.has(1)) {
|
||||
// Write first byte, read next byte
|
||||
writeBits<8+XTRA0>(last_mark, b);
|
||||
b = pixels.loadAndScale1();
|
||||
|
||||
// Write second byte, read 3rd byte
|
||||
writeBits<8+XTRA0>(last_mark, b);
|
||||
b = pixels.loadAndScale2();
|
||||
|
||||
// Write third byte, read 1st byte of next pixel
|
||||
writeBits<8+XTRA0>(last_mark, b);
|
||||
b = pixels.advanceAndLoadAndScale0();
|
||||
|
||||
#if (FASTLED_ALLOW_INTERRUPTS == 1)
|
||||
os_intr_unlock();
|
||||
#endif
|
||||
|
||||
pixels.stepDithering();
|
||||
|
||||
#if (FASTLED_ALLOW_INTERRUPTS == 1)
|
||||
os_intr_lock();
|
||||
// if interrupts took longer than 45µs, punt on the current frame
|
||||
if((int32_t)(__clock_cycles()-last_mark) > 0) {
|
||||
if((int32_t)(__clock_cycles()-last_mark) > (T1+T2+T3+((WAIT_TIME-INTERRUPT_THRESHOLD)*CLKS_PER_US))) { sei(); return 0; }
|
||||
}
|
||||
#endif
|
||||
};
|
||||
|
||||
os_intr_unlock();
|
||||
#ifdef FASTLED_DEBUG_COUNT_FRAME_RETRIES
|
||||
_frame_cnt++;
|
||||
#endif
|
||||
return __clock_cycles() - start;
|
||||
}
|
||||
};
|
||||
|
||||
FASTLED_NAMESPACE_END
|
||||
@ -0,0 +1,5 @@
|
||||
#pragma once
|
||||
|
||||
#include "fastpin_esp8266.h"
|
||||
#include "clockless_esp8266.h"
|
||||
#include "clockless_block_esp8266.h"
|
||||
101
components/FastLED-idf/platforms/esp/8266/fastpin_esp8266.h
Normal file
101
components/FastLED-idf/platforms/esp/8266/fastpin_esp8266.h
Normal file
@ -0,0 +1,101 @@
|
||||
#pragma once
|
||||
|
||||
FASTLED_NAMESPACE_BEGIN
|
||||
|
||||
struct FASTLED_ESP_IO {
|
||||
volatile uint32_t _GPO;
|
||||
volatile uint32_t _GPOS;
|
||||
volatile uint32_t _GPOC;
|
||||
};
|
||||
|
||||
#define _GPB (*(FASTLED_ESP_IO*)(0x60000000+(0x300)))
|
||||
|
||||
|
||||
template<uint8_t PIN, uint32_t MASK> class _ESPPIN {
|
||||
|
||||
public:
|
||||
typedef volatile uint32_t * port_ptr_t;
|
||||
typedef uint32_t port_t;
|
||||
|
||||
inline static void setOutput() { pinMode(PIN, OUTPUT); }
|
||||
inline static void setInput() { pinMode(PIN, INPUT); }
|
||||
|
||||
inline static void hi() __attribute__ ((always_inline)) { if(PIN < 16) { _GPB._GPOS = MASK; } else { GP16O |= MASK; } }
|
||||
inline static void lo() __attribute__ ((always_inline)) { if(PIN < 16) { _GPB._GPOC = MASK; } else { GP16O &= ~MASK; } }
|
||||
inline static void set(register port_t val) __attribute__ ((always_inline)) { if(PIN < 16) { _GPB._GPO = val; } else { GP16O = val; }}
|
||||
|
||||
inline static void strobe() __attribute__ ((always_inline)) { toggle(); toggle(); }
|
||||
|
||||
inline static void toggle() __attribute__ ((always_inline)) { if(PIN < 16) { _GPB._GPO ^= MASK; } else { GP16O ^= MASK; } }
|
||||
|
||||
inline static void hi(register port_ptr_t port) __attribute__ ((always_inline)) { hi(); }
|
||||
inline static void lo(register port_ptr_t port) __attribute__ ((always_inline)) { lo(); }
|
||||
inline static void fastset(register port_ptr_t port, register port_t val) __attribute__ ((always_inline)) { *port = val; }
|
||||
|
||||
inline static port_t hival() __attribute__ ((always_inline)) { if (PIN<16) { return GPO | MASK; } else { return GP16O | MASK; } }
|
||||
inline static port_t loval() __attribute__ ((always_inline)) { if (PIN<16) { return GPO & ~MASK; } else { return GP16O & ~MASK; } }
|
||||
inline static port_ptr_t port() __attribute__ ((always_inline)) { if(PIN<16) { return &_GPB._GPO; } else { return &GP16O; } }
|
||||
inline static port_ptr_t sport() __attribute__ ((always_inline)) { return &_GPB._GPOS; } // there is no GP160 support for this
|
||||
inline static port_ptr_t cport() __attribute__ ((always_inline)) { return &_GPB._GPOC; }
|
||||
inline static port_t mask() __attribute__ ((always_inline)) { return MASK; }
|
||||
|
||||
inline static bool isset() __attribute__ ((always_inline)) { return (PIN < 16) ? (GPO & MASK) : (GP16O & MASK); }
|
||||
};
|
||||
|
||||
#define _FL_DEFPIN(PIN, REAL_PIN) template<> class FastPin<PIN> : public _ESPPIN<REAL_PIN, (1<<(REAL_PIN & 0xFF))> {};
|
||||
|
||||
|
||||
#ifdef FASTLED_ESP8266_RAW_PIN_ORDER
|
||||
#define MAX_PIN 16
|
||||
_FL_DEFPIN(0,0); _FL_DEFPIN(1,1); _FL_DEFPIN(2,2); _FL_DEFPIN(3,3);
|
||||
_FL_DEFPIN(4,4); _FL_DEFPIN(5,5);
|
||||
|
||||
// These pins should be disabled, as they always cause WDT resets
|
||||
// _FL_DEFPIN(6,6); _FL_DEFPIN(7,7);
|
||||
// _FL_DEFPIN(8,8); _FL_DEFPIN(9,9); _FL_DEFPIN(10,10); _FL_DEFPIN(11,11);
|
||||
|
||||
_FL_DEFPIN(12,12); _FL_DEFPIN(13,13); _FL_DEFPIN(14,14); _FL_DEFPIN(15,15);
|
||||
_FL_DEFPIN(16,16);
|
||||
|
||||
#define PORTA_FIRST_PIN 12
|
||||
#elif defined(FASTLED_ESP8266_D1_PIN_ORDER)
|
||||
#define MAX_PIN 15
|
||||
_FL_DEFPIN(0,3);
|
||||
_FL_DEFPIN(1,1);
|
||||
_FL_DEFPIN(2,16);
|
||||
_FL_DEFPIN(3,5);
|
||||
_FL_DEFPIN(4,4);
|
||||
_FL_DEFPIN(5,14);
|
||||
_FL_DEFPIN(6,12);
|
||||
_FL_DEFPIN(7,13);
|
||||
_FL_DEFPIN(8,0);
|
||||
_FL_DEFPIN(9,2);
|
||||
_FL_DEFPIN(10,15);
|
||||
_FL_DEFPIN(11,13);
|
||||
_FL_DEFPIN(12,12);
|
||||
_FL_DEFPIN(13,14);
|
||||
_FL_DEFPIN(14,4);
|
||||
_FL_DEFPIN(15,5);
|
||||
|
||||
#define PORTA_FIRST_PIN 12
|
||||
|
||||
#else // if defined(FASTLED_ESP8266_NODEMCU_PIN_ORDER)
|
||||
#define MAX_PIN 10
|
||||
|
||||
// This seems to be the standard Dxx pin mapping on most of the esp boards that i've found
|
||||
_FL_DEFPIN(0,16); _FL_DEFPIN(1,5); _FL_DEFPIN(2,4); _FL_DEFPIN(3,0);
|
||||
_FL_DEFPIN(4,2); _FL_DEFPIN(5,14); _FL_DEFPIN(6,12); _FL_DEFPIN(7,13);
|
||||
_FL_DEFPIN(8,15); _FL_DEFPIN(9,3); _FL_DEFPIN(10,1);
|
||||
|
||||
#define PORTA_FIRST_PIN 6
|
||||
|
||||
// The rest of the pins - these are generally not available
|
||||
// _FL_DEFPIN(11,6);
|
||||
// _FL_DEFPIN(12,7); _FL_DEFPIN(13,8); _FL_DEFPIN(14,9); _FL_DEFPIN(15,10);
|
||||
// _FL_DEFPIN(16,11);
|
||||
|
||||
#endif
|
||||
|
||||
#define HAS_HARDWARE_PIN_SUPPORT
|
||||
|
||||
#define FASTLED_NAMESPACE_END
|
||||
@ -0,0 +1,39 @@
|
||||
#pragma once
|
||||
|
||||
#ifndef ESP8266
|
||||
#define ESP8266
|
||||
#endif
|
||||
|
||||
#define FASTLED_ESP8266
|
||||
|
||||
// Use system millis timer
|
||||
#define FASTLED_HAS_MILLIS
|
||||
|
||||
typedef volatile uint32_t RoReg;
|
||||
typedef volatile uint32_t RwReg;
|
||||
typedef uint32_t prog_uint32_t;
|
||||
|
||||
|
||||
// Default to NOT using PROGMEM here
|
||||
#ifndef FASTLED_USE_PROGMEM
|
||||
# define FASTLED_USE_PROGMEM 0
|
||||
#endif
|
||||
|
||||
#ifndef FASTLED_ALLOW_INTERRUPTS
|
||||
# define FASTLED_ALLOW_INTERRUPTS 1
|
||||
# define INTERRUPT_THRESHOLD 0
|
||||
#endif
|
||||
|
||||
#define NEED_CXX_BITS
|
||||
|
||||
// These can be overridden
|
||||
#if !defined(FASTLED_ESP8266_RAW_PIN_ORDER) && !defined(FASTLED_ESP8266_NODEMCU_PIN_ORDER) && !defined(FASTLED_ESP8266_D1_PIN_ORDER)
|
||||
# ifdef ARDUINO_ESP8266_NODEMCU
|
||||
# define FASTLED_ESP8266_NODEMCU_PIN_ORDER
|
||||
# else
|
||||
# define FASTLED_ESP8266_RAW_PIN_ORDER
|
||||
# endif
|
||||
#endif
|
||||
|
||||
// #define cli() os_intr_lock();
|
||||
// #define sei() os_intr_lock();
|
||||
185
components/FastLED-idf/power_mgt.cpp
Normal file
185
components/FastLED-idf/power_mgt.cpp
Normal file
@ -0,0 +1,185 @@
|
||||
#define FASTLED_INTERNAL
|
||||
#include "FastLED.h"
|
||||
#include "power_mgt.h"
|
||||
|
||||
FASTLED_NAMESPACE_BEGIN
|
||||
|
||||
//// POWER MANAGEMENT
|
||||
|
||||
// These power usage values are approximate, and your exact readings
|
||||
// will be slightly (10%?) different from these.
|
||||
//
|
||||
// They were arrived at by actually measuing the power draw of a number
|
||||
// of different LED strips, and a bunch of closed-loop-feedback testing
|
||||
// to make sure that if we USE these values, we stay at or under
|
||||
// the target power consumption.
|
||||
// Actual power consumption is much, much more complicated and has
|
||||
// to include things like voltage drop, etc., etc.
|
||||
// However, this is good enough for most cases, and almost certainly better
|
||||
// than no power management at all.
|
||||
//
|
||||
// You're welcome to adjust these values as needed; there may eventually be an API
|
||||
// for changing these on the fly, but it saves codespace and RAM to have them
|
||||
// be compile-time constants.
|
||||
|
||||
static const uint8_t gRed_mW = 16 * 5; // 16mA @ 5v = 80mW
|
||||
static const uint8_t gGreen_mW = 11 * 5; // 11mA @ 5v = 55mW
|
||||
static const uint8_t gBlue_mW = 15 * 5; // 15mA @ 5v = 75mW
|
||||
static const uint8_t gDark_mW = 1 * 5; // 1mA @ 5v = 5mW
|
||||
|
||||
// Alternate calibration by RAtkins via pre-PSU wattage measurments;
|
||||
// these are all probably about 20%-25% too high due to PSU heat losses,
|
||||
// but if you're measuring wattage on the PSU input side, this may
|
||||
// be a better set of calibrations. (WS2812B)
|
||||
// static const uint8_t gRed_mW = 100;
|
||||
// static const uint8_t gGreen_mW = 48;
|
||||
// static const uint8_t gBlue_mW = 100;
|
||||
// static const uint8_t gDark_mW = 12;
|
||||
|
||||
|
||||
#define POWER_LED 1
|
||||
#define POWER_DEBUG_PRINT 0
|
||||
|
||||
|
||||
// Power consumed by the MCU
|
||||
static const uint8_t gMCU_mW = 25 * 5; // 25mA @ 5v = 125 mW
|
||||
|
||||
static uint8_t gMaxPowerIndicatorLEDPinNumber = 0; // default = Arduino onboard LED pin. set to zero to skip this.
|
||||
|
||||
|
||||
uint32_t calculate_unscaled_power_mW( const CRGB* ledbuffer, uint16_t numLeds ) //25354
|
||||
{
|
||||
uint32_t red32 = 0, green32 = 0, blue32 = 0;
|
||||
const CRGB* firstled = &(ledbuffer[0]);
|
||||
uint8_t* p = (uint8_t*)(firstled);
|
||||
|
||||
uint16_t count = numLeds;
|
||||
|
||||
// This loop might benefit from an AVR assembly version -MEK
|
||||
while( count) {
|
||||
red32 += *p++;
|
||||
green32 += *p++;
|
||||
blue32 += *p++;
|
||||
count--;
|
||||
}
|
||||
|
||||
red32 *= gRed_mW;
|
||||
green32 *= gGreen_mW;
|
||||
blue32 *= gBlue_mW;
|
||||
|
||||
red32 >>= 8;
|
||||
green32 >>= 8;
|
||||
blue32 >>= 8;
|
||||
|
||||
uint32_t total = red32 + green32 + blue32 + (gDark_mW * numLeds);
|
||||
|
||||
return total;
|
||||
}
|
||||
|
||||
|
||||
uint8_t calculate_max_brightness_for_power_vmA(const CRGB* ledbuffer, uint16_t numLeds, uint8_t target_brightness, uint32_t max_power_V, uint32_t max_power_mA) {
|
||||
return calculate_max_brightness_for_power_mW(ledbuffer, numLeds, target_brightness, max_power_V * max_power_mA);
|
||||
}
|
||||
|
||||
uint8_t calculate_max_brightness_for_power_mW(const CRGB* ledbuffer, uint16_t numLeds, uint8_t target_brightness, uint32_t max_power_mW) {
|
||||
uint32_t total_mW = calculate_unscaled_power_mW( ledbuffer, numLeds);
|
||||
|
||||
uint32_t requested_power_mW = ((uint32_t)total_mW * target_brightness) / 256;
|
||||
|
||||
uint8_t recommended_brightness = target_brightness;
|
||||
if(requested_power_mW > max_power_mW) {
|
||||
recommended_brightness = (uint32_t)((uint8_t)(target_brightness) * (uint32_t)(max_power_mW)) / ((uint32_t)(requested_power_mW));
|
||||
}
|
||||
|
||||
return recommended_brightness;
|
||||
}
|
||||
|
||||
// sets brightness to
|
||||
// - no more than target_brightness
|
||||
// - no more than max_mW milliwatts
|
||||
uint8_t calculate_max_brightness_for_power_mW( uint8_t target_brightness, uint32_t max_power_mW)
|
||||
{
|
||||
uint32_t total_mW = gMCU_mW;
|
||||
|
||||
CLEDController *pCur = CLEDController::head();
|
||||
while(pCur) {
|
||||
total_mW += calculate_unscaled_power_mW( pCur->leds(), pCur->size());
|
||||
pCur = pCur->next();
|
||||
}
|
||||
|
||||
#if POWER_DEBUG_PRINT == 1
|
||||
Serial.print("power demand at full brightness mW = ");
|
||||
Serial.println( total_mW);
|
||||
#endif
|
||||
|
||||
uint32_t requested_power_mW = ((uint32_t)total_mW * target_brightness) / 256;
|
||||
#if POWER_DEBUG_PRINT == 1
|
||||
if( target_brightness != 255 ) {
|
||||
Serial.print("power demand at scaled brightness mW = ");
|
||||
Serial.println( requested_power_mW);
|
||||
}
|
||||
Serial.print("power limit mW = ");
|
||||
Serial.println( max_power_mW);
|
||||
#endif
|
||||
|
||||
if( requested_power_mW < max_power_mW) {
|
||||
#if POWER_LED > 0
|
||||
if( gMaxPowerIndicatorLEDPinNumber ) {
|
||||
Pin(gMaxPowerIndicatorLEDPinNumber).lo(); // turn the LED off
|
||||
}
|
||||
#endif
|
||||
#if POWER_DEBUG_PRINT == 1
|
||||
Serial.print("demand is under the limit");
|
||||
#endif
|
||||
return target_brightness;
|
||||
}
|
||||
|
||||
uint8_t recommended_brightness = (uint32_t)((uint8_t)(target_brightness) * (uint32_t)(max_power_mW)) / ((uint32_t)(requested_power_mW));
|
||||
#if POWER_DEBUG_PRINT == 1
|
||||
Serial.print("recommended brightness # = ");
|
||||
Serial.println( recommended_brightness);
|
||||
|
||||
uint32_t resultant_power_mW = (total_mW * recommended_brightness) / 256;
|
||||
Serial.print("resultant power demand mW = ");
|
||||
Serial.println( resultant_power_mW);
|
||||
|
||||
Serial.println();
|
||||
#endif
|
||||
|
||||
#if POWER_LED > 0
|
||||
if( gMaxPowerIndicatorLEDPinNumber ) {
|
||||
Pin(gMaxPowerIndicatorLEDPinNumber).hi(); // turn the LED on
|
||||
}
|
||||
#endif
|
||||
|
||||
return recommended_brightness;
|
||||
}
|
||||
|
||||
|
||||
void set_max_power_indicator_LED( uint8_t pinNumber)
|
||||
{
|
||||
gMaxPowerIndicatorLEDPinNumber = pinNumber;
|
||||
}
|
||||
|
||||
void set_max_power_in_volts_and_milliamps( uint8_t volts, uint32_t milliamps)
|
||||
{
|
||||
FastLED.setMaxPowerInVoltsAndMilliamps(volts, milliamps);
|
||||
}
|
||||
|
||||
void set_max_power_in_milliwatts( uint32_t powerInmW)
|
||||
{
|
||||
FastLED.setMaxPowerInMilliWatts(powerInmW);
|
||||
}
|
||||
|
||||
void show_at_max_brightness_for_power()
|
||||
{
|
||||
// power management usage is now in FastLED.show, no need for this function
|
||||
FastLED.show();
|
||||
}
|
||||
|
||||
void delay_at_max_brightness_for_power( uint16_t ms)
|
||||
{
|
||||
FastLED.delay(ms);
|
||||
}
|
||||
|
||||
FASTLED_NAMESPACE_END
|
||||
88
components/FastLED-idf/power_mgt.h
Normal file
88
components/FastLED-idf/power_mgt.h
Normal file
@ -0,0 +1,88 @@
|
||||
#ifndef POWER_MGT_H
|
||||
#define POWER_MGT_H
|
||||
|
||||
#include "FastLED.h"
|
||||
|
||||
#include "pixeltypes.h"
|
||||
|
||||
FASTLED_NAMESPACE_BEGIN
|
||||
|
||||
///@defgroup Power Power management functions
|
||||
/// functions used to limit the amount of power used by FastLED
|
||||
///@{
|
||||
|
||||
// Power Control setup functions
|
||||
//
|
||||
// Example:
|
||||
// set_max_power_in_volts_and_milliamps( 5, 400);
|
||||
//
|
||||
|
||||
/// Set the maximum power used in milliamps for a given voltage
|
||||
/// @deprecated - use FastLED.setMaxPowerInVoltsAndMilliamps()
|
||||
void set_max_power_in_volts_and_milliamps( uint8_t volts, uint32_t milliamps);
|
||||
/// Set the maximum power used in watts
|
||||
/// @deprecated - use FastLED.setMaxPowerInMilliWatts
|
||||
void set_max_power_in_milliwatts( uint32_t powerInmW);
|
||||
|
||||
/// Select a pin with an led that will be flashed to indicate that power management
|
||||
/// is pulling down the brightness
|
||||
void set_max_power_indicator_LED( uint8_t pinNumber); // zero = no indicator LED
|
||||
|
||||
|
||||
// Power Control 'show' and 'delay' functions
|
||||
//
|
||||
// These are drop-in replacements for FastLED.show() and FastLED.delay()
|
||||
// In order to use these, you have to actually replace your calls to
|
||||
// FastLED.show() and FastLED.delay() with these two functions.
|
||||
//
|
||||
// Example:
|
||||
// // was: FastLED.show();
|
||||
// // now is:
|
||||
// show_at_max_brightness_for_power();
|
||||
//
|
||||
|
||||
/// Similar to FastLED.show, but pre-adjusts brightness to keep below the power
|
||||
/// threshold.
|
||||
/// @deprecated this has now been moved to FastLED.show();
|
||||
void show_at_max_brightness_for_power();
|
||||
/// Similar to FastLED.delay, but pre-adjusts brightness to keep below the power
|
||||
/// threshold.
|
||||
/// @deprecated this has now been rolled into FastLED.delay();
|
||||
void delay_at_max_brightness_for_power( uint16_t ms);
|
||||
|
||||
|
||||
// Power Control internal helper functions
|
||||
|
||||
/// calculate_unscaled_power_mW tells you how many milliwatts the current
|
||||
/// LED data would draw at brightness = 255.
|
||||
///
|
||||
uint32_t calculate_unscaled_power_mW( const CRGB* ledbuffer, uint16_t numLeds);
|
||||
|
||||
/// calculate_max_brightness_for_power_mW tells you the highest brightness
|
||||
/// level you can use and still stay under the specified power budget for
|
||||
/// a given set of leds. It takes a pointer to an array of CRGB objects, a
|
||||
/// count, a 'target brightness' which is the brightness you'd ideally like
|
||||
/// to use, and the max power draw desired in milliwatts. The result from
|
||||
/// this function will be no higher than the target_brightess you supply, but may be lower.
|
||||
uint8_t calculate_max_brightness_for_power_mW(const CRGB* ledbuffer, uint16_t numLeds, uint8_t target_brightness, uint32_t max_power_mW);
|
||||
|
||||
/// calculate_max_brightness_for_power_mW tells you the highest brightness
|
||||
/// level you can use and still stay under the specified power budget for
|
||||
/// a given set of leds. It takes a pointer to an array of CRGB objects, a
|
||||
/// count, a 'target brightness' which is the brightness you'd ideally like
|
||||
/// to use, and the max power in volts and milliamps. The result from this
|
||||
/// function will be no higher than the target_brightess you supply, but may be lower.
|
||||
uint8_t calculate_max_brightness_for_power_vmA(const CRGB* ledbuffer, uint16_t numLeds, uint8_t target_brightness, uint32_t max_power_V, uint32_t max_power_mA);
|
||||
|
||||
/// calculate_max_brightness_for_power_mW tells you the highest brightness
|
||||
/// level you can use and still stay under the specified power budget. It
|
||||
/// takes a 'target brightness' which is the brightness you'd ideally like
|
||||
/// to use. The result from this function will be no higher than the
|
||||
/// target_brightess you supply, but may be lower.
|
||||
uint8_t calculate_max_brightness_for_power_mW( uint8_t target_brightness, uint32_t max_power_mW);
|
||||
|
||||
FASTLED_NAMESPACE_END
|
||||
///@}
|
||||
// POWER_MGT_H
|
||||
|
||||
#endif
|
||||
267
components/FastLED-idf/release_notes.md
Normal file
267
components/FastLED-idf/release_notes.md
Normal file
@ -0,0 +1,267 @@
|
||||
FastLED 3.3.3
|
||||
=============
|
||||
|
||||
* Improved support for ESP32, Teensy4, ATmega16, nRF52, and ARM STM32.
|
||||
* Added animation examples: "TwinkleFox" holiday lights, "Pride2015" moving rainbows, and "Pacifica" gentle ocean waves
|
||||
* Fixed a few bugs including a rare divide-by-zero crash
|
||||
* Cleaned up code and examples a bit
|
||||
* Said our sad farwells to FastLED founder Daniel Garcia, who we lost in a tragic accident on September 2nd, 2019. Dan's beautiful code and warm kindness have been at the heart of the library, and our community, for ten years. FastLED will continue with help from all across the FastLED world, and Dan's spirit will be with us whenever the lights shine and glow. Thank you, Dan, for everything.
|
||||
|
||||
|
||||
FastLED 3.3.2
|
||||
=============
|
||||
|
||||
* Fix APA102 compile error #870
|
||||
* Normalize pin definition macros so that we can have an .ino file that can be used to output what pin/port mappings should be for a platform
|
||||
* Add defnition for ATmega32
|
||||
|
||||
FastLED 3.3.1
|
||||
=============
|
||||
|
||||
* Fix teensy build issue
|
||||
* Bring in sam's RMT timing fix
|
||||
|
||||
FastLED 3.3.0
|
||||
==============
|
||||
* Preliminary Teensy 4 support
|
||||
* Fix #861 - power computation for OctoWS2811
|
||||
* keywords and other minor changes for compilers (#854, #845)
|
||||
* Fix some nrf52 issues (#856), #840
|
||||
|
||||
FastLED 3.2.10
|
||||
==============
|
||||
* Adafruit Metro M4 Airlift support
|
||||
* Arduino Nano 33 IOT preliminary definitions
|
||||
* Bug fixes
|
||||
|
||||
FastLED 3.2.9
|
||||
=============
|
||||
* Update ItsyBitsy support
|
||||
* Remove conflicting types courtesy of an esp8266 framework update
|
||||
* Fixes to clockless M0 code to allow for more interrupt enabled environments
|
||||
* ATTiny25 compilation fix
|
||||
* Some STM32 fixes (the platform still seems unhappy, though)
|
||||
* NRF52 support
|
||||
* Updated ESP32 support - supporting up to 24-way parallel output
|
||||
|
||||
|
||||
|
||||
FastLED 3.2.6
|
||||
=============
|
||||
|
||||
* typo fix
|
||||
|
||||
FastLED 3.2.5
|
||||
=============
|
||||
|
||||
* Fix for SAMD51 based boards (a SAMD21 optimization broke the D51 builds, now D51 is a separate platform)
|
||||
|
||||
FastLED 3.2.4
|
||||
=============
|
||||
|
||||
* fix builds for WAV boards
|
||||
|
||||
FastLED 3.2.2
|
||||
=============
|
||||
|
||||
* Perf tweak for SAMD21
|
||||
* LPD6803 support
|
||||
* Add atmega328pb support
|
||||
* Variety of minor bug/correctness/typo fixes
|
||||
* Added SM16703, GE8822, GS1903
|
||||
|
||||
FastLED 3.2.1
|
||||
=============
|
||||
* ATmega644P support
|
||||
* Adafruit Hallowwing (Thanks to Lady Ada)
|
||||
* Improved STM 32 support
|
||||
* Some user contributed cleanups
|
||||
* ESP32 APA102 output fix
|
||||
|
||||
FastLED3.2
|
||||
==========
|
||||
* ESP32 support with improved output and parallel output options (thanks Sam Guyer!)
|
||||
* various minor contributed fixes
|
||||
|
||||
FastLED 3.1.8
|
||||
=============
|
||||
* Added support for Adafruit Circuit Playground Express (Thanks to Lady Ada)
|
||||
* Improved support for Adafruit Gemma and Trinket m0 (Thanks to Lady Ada)
|
||||
* Added support for PJRC's WS2812Serial (Thanks to Paul Stoffregen)
|
||||
* Added support for ATmega328 non-picopower hardware pins (Thanks to John Whittington)
|
||||
* Fixes for ESP32 support (Thanks to Daniel Tullemans)
|
||||
* 'Makefile' compilation fix (Thanks to Nico Hood)
|
||||
|
||||
FastLED 3.1.7 (skipped)
|
||||
=======================
|
||||
|
||||
FastLED 3.1.6
|
||||
=============
|
||||
* Preliminary support for esp32
|
||||
* Variety of random bug fixes
|
||||
* 6-channel parallel output for the esp8266
|
||||
* Race condition fixes for teensy hardware SPI
|
||||
* Preliminary teensy 3.6 support
|
||||
* Various fixes falling out from "fixing" scale 8 adjustments
|
||||
* Add gemma m0 support (thanks @ladyada!)
|
||||
|
||||
FastLED 3.1.5
|
||||
=============
|
||||
* Fix due parallel output build issue
|
||||
|
||||
FastLED 3.1.4
|
||||
=============
|
||||
* fix digispark avr build issue
|
||||
|
||||
FastLED3.1.3
|
||||
===============
|
||||
|
||||
* Add SK6822 timings
|
||||
* Add ESP8266 support - note, only tested w/the arduino esp8266 build environment
|
||||
* Improvements to hsv2rgb, palette, and noise performance
|
||||
* Improvements to rgb2hsv accuracy
|
||||
* Fixed noise discontinuity
|
||||
* Add wino board support
|
||||
* Fix scale8 (so now, scale8(255,255) == 255, not 254!)
|
||||
* Add ESP8266 parallel output support
|
||||
|
||||
|
||||
FastLED3.1.1
|
||||
============
|
||||
* Enabled RFDuino/nrf51822 hardware SPI support
|
||||
* Fix edge case bug w/HSV palette blending
|
||||
* Fix power management issue w/parallel output
|
||||
* Use static_asserts for some more useful compile time errors around bad pins
|
||||
* Roll power management into FastLED.show/delay directly
|
||||
* Support for adafruit pixies on arduino type platforms that have SoftwareSerial
|
||||
* TODO: support hardware serial on platforms that have it available
|
||||
* Add UCS2903 timings
|
||||
* Preliminary CPixelView/CRGBSet code - more flexible treatment of groups of arrays
|
||||
* https://github.com/FastLED/FastLED/wiki/RGBSet-Reference
|
||||
|
||||
|
||||
FastLED3.1.0
|
||||
============
|
||||
* Added support for the following platforms
|
||||
* Arduino Zero
|
||||
* Teensy LC
|
||||
* RFDuino/nrf51822
|
||||
* Spark Core
|
||||
* Major internal code reoganization
|
||||
* Started doxygen based documentation
|
||||
* Lots of bug/performance fixes
|
||||
* Parallel output on various arm platforms
|
||||
* lots of new stuff
|
||||
|
||||
FastLED3.0.2
|
||||
============
|
||||
* possibly fix issues #67 and #90 by fixing gcc 4.8.x support
|
||||
|
||||
FastLED3.0.1
|
||||
============
|
||||
* fix issue #89 w/power management pin always being on
|
||||
|
||||
FastLED3.0
|
||||
==========
|
||||
|
||||
* Added support for the following platforms:
|
||||
* Arduino due
|
||||
* Teensy 3.1
|
||||
* Added the following LED chipsets:
|
||||
* USC1903_400
|
||||
* GW6205 / GW6205_400
|
||||
* APA102
|
||||
* APA104
|
||||
* LPD1886
|
||||
* P9813
|
||||
* SmartMatrix
|
||||
* Added multiple examples:
|
||||
* ColorPalette - show off the color palette code
|
||||
* ColorTemperature - show off the color correction code
|
||||
* Fire2012
|
||||
* Fire2012WithPalette
|
||||
* Multiple led controller examples
|
||||
* Noise
|
||||
* NoisePlayground
|
||||
* NoisePlusPalette
|
||||
* SmartMatrix - show off SmartMatrix support
|
||||
* XYMatrix - show how to use a mtrix layout of leds
|
||||
* Added color correction
|
||||
* Added dithering
|
||||
* Added power management support
|
||||
* Added support for color palettes
|
||||
* Added easing functions
|
||||
* Added fast trig functions
|
||||
* Added simplex noise functions
|
||||
* Added color utility functions
|
||||
* Fixed DMXSERIAL/DMXSIMPLE support
|
||||
* Timing adjustments for existing SPI chipsets
|
||||
* Cleaned up the code layout to make platform support easier
|
||||
* Many bug fixes
|
||||
* A number of performance/memory improvements
|
||||
* Remove Squant (takes up space!)
|
||||
|
||||
FastLED2
|
||||
========
|
||||
|
||||
## Full release of the library
|
||||
|
||||
## Release Candidate 6
|
||||
* Rename library, offically, to FastLED, move to github
|
||||
* Update keywords with all the new stuffs
|
||||
|
||||
## Release Candidate 5
|
||||
* Gemma and Trinket: supported except for global "setBrightness"
|
||||
|
||||
## Release Candidate 4
|
||||
* Added NEOPIXEL as a synonym for WS2811
|
||||
* Fix WS2811/WS2812B timings, bring it in line to exactly 1.25ns/bit.
|
||||
* Fix handling of constant color definitions (damn you, gcc!)
|
||||
|
||||
## Release Candidate 3
|
||||
* Fixed bug when Clock and Data were on the same port
|
||||
* Added ability to set pixel color directly from HSV
|
||||
* Added ability to retrieve current random16 seed
|
||||
|
||||
## Release Candidate 2
|
||||
* mostly bug fixes
|
||||
* Fix SPI macro definitions for latest teensy3 software update
|
||||
* Teensy 2 compilation fix
|
||||
* hsv2rgb_rainbow performance fix
|
||||
|
||||
## Release Candidate 1
|
||||
* New unified/simplified API for adding/using controllers
|
||||
* fleshout clockless chip support
|
||||
* add hsv (spectrum and rainbow style colors)
|
||||
* high speed memory management operations
|
||||
* library for interpolation/easing functions
|
||||
* various api changes, addition of clear and showColor functions
|
||||
* scale value applied to all show methods
|
||||
* bug fixes for SM16716
|
||||
* performance improvements, lpd8806 exceeds 22Mbit now
|
||||
* hardware def fixes
|
||||
* allow alternate rgb color orderings
|
||||
* high speed math methods
|
||||
* rich CRGB structure
|
||||
|
||||
## Preview 3
|
||||
* True hardware SPI support for teensy (up to 20Mbit output!)
|
||||
* Minor bug fixes/tweaks
|
||||
|
||||
## Preview 2
|
||||
* Rename pin class to FastPin
|
||||
* Replace latch with select, more accurate description of what it does
|
||||
* Enforce intra-frame timing for ws2801s
|
||||
* SM16716 support
|
||||
* Add #define FAST_SPI_INTERRUPTS_WRITE_PINS to make sure world is ok w/interrupts and SPI
|
||||
* Add #define FASTLED_FORCE_SOFTWARE_SPI for those times when you absolutely don't want to use hardware SPI, ev
|
||||
en if you're using the hardware SPI pins
|
||||
* Add pin definitions for the arduino megas - should fix ws2811 support
|
||||
* Add pin definitions for the leonardo - should fix spi support and pin mappings
|
||||
* Add warnings when pin definitions are missing
|
||||
* Added google+ community for fastspi users - https://plus.google.com/communities/109127054924227823508
|
||||
# Add pin definitions for Teensy++ 2.0
|
||||
|
||||
|
||||
## Preview 1
|
||||
* Initial release
|
||||
238
components/FastLED-idf/wiring.cpp
Normal file
238
components/FastLED-idf/wiring.cpp
Normal file
@ -0,0 +1,238 @@
|
||||
#define FASTLED_INTERNAL
|
||||
#include "FastLED.h"
|
||||
|
||||
FASTLED_USING_NAMESPACE
|
||||
|
||||
#if 0
|
||||
|
||||
#if defined(FASTLED_AVR) && !defined(TEENSYDUINO) && !defined(LIB8_ATTINY)
|
||||
extern "C" {
|
||||
// the prescaler is set so that timer0 ticks every 64 clock cycles, and the
|
||||
// the overflow handler is called every 256 ticks.
|
||||
#define MICROSECONDS_PER_TIMER0_OVERFLOW (clockCyclesToMicroseconds(64 * 256))
|
||||
|
||||
typedef union { unsigned long _long; uint8_t raw[4]; } tBytesForLong;
|
||||
// tBytesForLong FastLED_timer0_overflow_count;
|
||||
volatile unsigned long FastLED_timer0_overflow_count=0;
|
||||
volatile unsigned long FastLED_timer0_millis = 0;
|
||||
|
||||
LIB8STATIC void __attribute__((always_inline)) fastinc32 (volatile uint32_t & _long) {
|
||||
uint8_t b = ++((tBytesForLong&)_long).raw[0];
|
||||
if(!b) {
|
||||
b = ++((tBytesForLong&)_long).raw[1];
|
||||
if(!b) {
|
||||
b = ++((tBytesForLong&)_long).raw[2];
|
||||
if(!b) {
|
||||
++((tBytesForLong&)_long).raw[3];
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#if defined(__AVR_ATtiny24__) || defined(__AVR_ATtiny44__) || defined(__AVR_ATtiny84__)
|
||||
ISR(TIM0_OVF_vect)
|
||||
#else
|
||||
ISR(TIMER0_OVF_vect)
|
||||
#endif
|
||||
{
|
||||
fastinc32(FastLED_timer0_overflow_count);
|
||||
// FastLED_timer0_overflow_count++;
|
||||
}
|
||||
|
||||
// there are 1024 microseconds per overflow counter tick.
|
||||
unsigned long millis()
|
||||
{
|
||||
unsigned long m;
|
||||
uint8_t oldSREG = SREG;
|
||||
|
||||
// disable interrupts while we read FastLED_timer0_millis or we might get an
|
||||
// inconsistent value (e.g. in the middle of a write to FastLED_timer0_millis)
|
||||
cli();
|
||||
m = FastLED_timer0_overflow_count; //._long;
|
||||
SREG = oldSREG;
|
||||
|
||||
return (m*(MICROSECONDS_PER_TIMER0_OVERFLOW/8))/(1000/8);
|
||||
}
|
||||
|
||||
unsigned long micros() {
|
||||
unsigned long m;
|
||||
uint8_t oldSREG = SREG, t;
|
||||
|
||||
cli();
|
||||
m = FastLED_timer0_overflow_count; // ._long;
|
||||
#if defined(TCNT0)
|
||||
t = TCNT0;
|
||||
#elif defined(TCNT0L)
|
||||
t = TCNT0L;
|
||||
#else
|
||||
#error TIMER 0 not defined
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef TIFR0
|
||||
if ((TIFR0 & _BV(TOV0)) && (t < 255))
|
||||
m++;
|
||||
#else
|
||||
if ((TIFR & _BV(TOV0)) && (t < 255))
|
||||
m++;
|
||||
#endif
|
||||
|
||||
SREG = oldSREG;
|
||||
|
||||
return ((m << 8) + t) * (64 / clockCyclesPerMicrosecond());
|
||||
}
|
||||
|
||||
void delay(unsigned long ms)
|
||||
{
|
||||
uint16_t start = (uint16_t)micros();
|
||||
|
||||
while (ms > 0) {
|
||||
if (((uint16_t)micros() - start) >= 1000) {
|
||||
ms--;
|
||||
start += 1000;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#define sbi(sfr, bit) (_SFR_BYTE(sfr) |= _BV(bit))
|
||||
void init()
|
||||
{
|
||||
// this needs to be called before setup() or some functions won't
|
||||
// work there
|
||||
sei();
|
||||
|
||||
// on the ATmega168, timer 0 is also used for fast hardware pwm
|
||||
// (using phase-correct PWM would mean that timer 0 overflowed half as often
|
||||
// resulting in different millis() behavior on the ATmega8 and ATmega168)
|
||||
#if defined(TCCR0A) && defined(WGM01)
|
||||
sbi(TCCR0A, WGM01);
|
||||
sbi(TCCR0A, WGM00);
|
||||
#endif
|
||||
|
||||
// set timer 0 prescale factor to 64
|
||||
#if defined(__AVR_ATmega128__)
|
||||
// CPU specific: different values for the ATmega128
|
||||
sbi(TCCR0, CS02);
|
||||
#elif defined(TCCR0) && defined(CS01) && defined(CS00)
|
||||
// this combination is for the standard atmega8
|
||||
sbi(TCCR0, CS01);
|
||||
sbi(TCCR0, CS00);
|
||||
#elif defined(TCCR0B) && defined(CS01) && defined(CS00)
|
||||
// this combination is for the standard 168/328/1280/2560
|
||||
sbi(TCCR0B, CS01);
|
||||
sbi(TCCR0B, CS00);
|
||||
#elif defined(TCCR0A) && defined(CS01) && defined(CS00)
|
||||
// this combination is for the __AVR_ATmega645__ series
|
||||
sbi(TCCR0A, CS01);
|
||||
sbi(TCCR0A, CS00);
|
||||
#else
|
||||
#error Timer 0 prescale factor 64 not set correctly
|
||||
#endif
|
||||
|
||||
// enable timer 0 overflow interrupt
|
||||
#if defined(TIMSK) && defined(TOIE0)
|
||||
sbi(TIMSK, TOIE0);
|
||||
#elif defined(TIMSK0) && defined(TOIE0)
|
||||
sbi(TIMSK0, TOIE0);
|
||||
#else
|
||||
#error Timer 0 overflow interrupt not set correctly
|
||||
#endif
|
||||
|
||||
// timers 1 and 2 are used for phase-correct hardware pwm
|
||||
// this is better for motors as it ensures an even waveform
|
||||
// note, however, that fast pwm mode can achieve a frequency of up
|
||||
// 8 MHz (with a 16 MHz clock) at 50% duty cycle
|
||||
|
||||
#if defined(TCCR1B) && defined(CS11) && defined(CS10)
|
||||
TCCR1B = 0;
|
||||
|
||||
// set timer 1 prescale factor to 64
|
||||
sbi(TCCR1B, CS11);
|
||||
#if F_CPU >= 8000000L
|
||||
sbi(TCCR1B, CS10);
|
||||
#endif
|
||||
#elif defined(TCCR1) && defined(CS11) && defined(CS10)
|
||||
sbi(TCCR1, CS11);
|
||||
#if F_CPU >= 8000000L
|
||||
sbi(TCCR1, CS10);
|
||||
#endif
|
||||
#endif
|
||||
// put timer 1 in 8-bit phase correct pwm mode
|
||||
#if defined(TCCR1A) && defined(WGM10)
|
||||
sbi(TCCR1A, WGM10);
|
||||
#elif defined(TCCR1)
|
||||
#warning this needs to be finished
|
||||
#endif
|
||||
|
||||
// set timer 2 prescale factor to 64
|
||||
#if defined(TCCR2) && defined(CS22)
|
||||
sbi(TCCR2, CS22);
|
||||
#elif defined(TCCR2B) && defined(CS22)
|
||||
sbi(TCCR2B, CS22);
|
||||
#else
|
||||
#warning Timer 2 not finished (may not be present on this CPU)
|
||||
#endif
|
||||
|
||||
// configure timer 2 for phase correct pwm (8-bit)
|
||||
#if defined(TCCR2) && defined(WGM20)
|
||||
sbi(TCCR2, WGM20);
|
||||
#elif defined(TCCR2A) && defined(WGM20)
|
||||
sbi(TCCR2A, WGM20);
|
||||
#else
|
||||
#warning Timer 2 not finished (may not be present on this CPU)
|
||||
#endif
|
||||
|
||||
#if defined(TCCR3B) && defined(CS31) && defined(WGM30)
|
||||
sbi(TCCR3B, CS31); // set timer 3 prescale factor to 64
|
||||
sbi(TCCR3B, CS30);
|
||||
sbi(TCCR3A, WGM30); // put timer 3 in 8-bit phase correct pwm mode
|
||||
#endif
|
||||
|
||||
#if defined(TCCR4A) && defined(TCCR4B) && defined(TCCR4D) /* beginning of timer4 block for 32U4 and similar */
|
||||
sbi(TCCR4B, CS42); // set timer4 prescale factor to 64
|
||||
sbi(TCCR4B, CS41);
|
||||
sbi(TCCR4B, CS40);
|
||||
sbi(TCCR4D, WGM40); // put timer 4 in phase- and frequency-correct PWM mode
|
||||
sbi(TCCR4A, PWM4A); // enable PWM mode for comparator OCR4A
|
||||
sbi(TCCR4C, PWM4D); // enable PWM mode for comparator OCR4D
|
||||
#else /* beginning of timer4 block for ATMEGA1280 and ATMEGA2560 */
|
||||
#if defined(TCCR4B) && defined(CS41) && defined(WGM40)
|
||||
sbi(TCCR4B, CS41); // set timer 4 prescale factor to 64
|
||||
sbi(TCCR4B, CS40);
|
||||
sbi(TCCR4A, WGM40); // put timer 4 in 8-bit phase correct pwm mode
|
||||
#endif
|
||||
#endif /* end timer4 block for ATMEGA1280/2560 and similar */
|
||||
|
||||
#if defined(TCCR5B) && defined(CS51) && defined(WGM50)
|
||||
sbi(TCCR5B, CS51); // set timer 5 prescale factor to 64
|
||||
sbi(TCCR5B, CS50);
|
||||
sbi(TCCR5A, WGM50); // put timer 5 in 8-bit phase correct pwm mode
|
||||
#endif
|
||||
|
||||
#if defined(ADCSRA)
|
||||
// set a2d prescale factor to 128
|
||||
// 16 MHz / 128 = 125 KHz, inside the desired 50-200 KHz range.
|
||||
// XXX: this will not work properly for other clock speeds, and
|
||||
// this code should use F_CPU to determine the prescale factor.
|
||||
sbi(ADCSRA, ADPS2);
|
||||
sbi(ADCSRA, ADPS1);
|
||||
sbi(ADCSRA, ADPS0);
|
||||
|
||||
// enable a2d conversions
|
||||
sbi(ADCSRA, ADEN);
|
||||
#endif
|
||||
|
||||
// the bootloader connects pins 0 and 1 to the USART; disconnect them
|
||||
// here so they can be used as normal digital i/o; they will be
|
||||
// reconnected in Serial.begin()
|
||||
#if defined(UCSRB)
|
||||
UCSRB = 0;
|
||||
#elif defined(UCSR0B)
|
||||
UCSR0B = 0;
|
||||
#endif
|
||||
}
|
||||
};
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
||||
4
main/CMakeLists.txt
Normal file
4
main/CMakeLists.txt
Normal file
@ -0,0 +1,4 @@
|
||||
set(COMPONENT_SRCS "hello_world_main.c")
|
||||
set(COMPONENT_ADD_INCLUDEDIRS "")
|
||||
|
||||
register_component()
|
||||
5
main/component.mk
Normal file
5
main/component.mk
Normal file
@ -0,0 +1,5 @@
|
||||
#
|
||||
# "main" pseudo-component makefile.
|
||||
#
|
||||
# (Uses default behaviour of compiling all source files in directory, adding 'include' to include path.)
|
||||
|
||||
79
main/main.cpp
Normal file
79
main/main.cpp
Normal file
@ -0,0 +1,79 @@
|
||||
/* Hello World Example
|
||||
|
||||
This example code is in the Public Domain (or CC0 licensed, at your option.)
|
||||
|
||||
Unless required by applicable law or agreed to in writing, this
|
||||
software is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
|
||||
CONDITIONS OF ANY KIND, either express or implied.
|
||||
*/
|
||||
#include <stdio.h>
|
||||
#include "freertos/FreeRTOS.h"
|
||||
#include "freertos/task.h"
|
||||
#include "esp_system.h"
|
||||
#include "esp_spi_flash.h"
|
||||
#include "FastLED.h"
|
||||
CRGBPalette16 currentPalette;
|
||||
TBlendType currentBlending;
|
||||
|
||||
extern CRGBPalette16 myRedWhiteBluePalette;
|
||||
extern const TProgmemPalette16 IRAM_ATTR myRedWhiteBluePalette_p;
|
||||
|
||||
#include "palettes.h"
|
||||
|
||||
#define NUM_LEDS 400
|
||||
#define DATA_PIN 15
|
||||
#define BRIGHTNESS 64
|
||||
#define LED_TYPE WS2811
|
||||
#define COLOR_ORDER GRB
|
||||
CRGB leds[NUM_LEDS];
|
||||
|
||||
|
||||
extern "C" {
|
||||
void app_main();
|
||||
}
|
||||
|
||||
void ChangePalettePeriodically(){
|
||||
|
||||
uint8_t secondHand = (millis() / 1000) % 60;
|
||||
static uint8_t lastSecond = 99;
|
||||
|
||||
if( lastSecond != secondHand) {
|
||||
lastSecond = secondHand;
|
||||
if( secondHand == 0) { currentPalette = RainbowColors_p; currentBlending = LINEARBLEND; }
|
||||
if( secondHand == 10) { currentPalette = RainbowStripeColors_p; currentBlending = NOBLEND; }
|
||||
if( secondHand == 15) { currentPalette = RainbowStripeColors_p; currentBlending = LINEARBLEND; }
|
||||
if( secondHand == 20) { SetupPurpleAndGreenPalette(); currentBlending = LINEARBLEND; }
|
||||
if( secondHand == 25) { SetupTotallyRandomPalette(); currentBlending = LINEARBLEND; }
|
||||
if( secondHand == 30) { SetupBlackAndWhiteStripedPalette(); currentBlending = NOBLEND; }
|
||||
if( secondHand == 35) { SetupBlackAndWhiteStripedPalette(); currentBlending = LINEARBLEND; }
|
||||
if( secondHand == 40) { currentPalette = CloudColors_p; currentBlending = LINEARBLEND; }
|
||||
if( secondHand == 45) { currentPalette = PartyColors_p; currentBlending = LINEARBLEND; }
|
||||
if( secondHand == 50) { currentPalette = myRedWhiteBluePalette_p; currentBlending = NOBLEND; }
|
||||
if( secondHand == 55) { currentPalette = myRedWhiteBluePalette_p; currentBlending = LINEARBLEND; }
|
||||
}
|
||||
|
||||
}
|
||||
void blinkLeds(void *pvParameters){
|
||||
while(1){
|
||||
ChangePalettePeriodically();
|
||||
|
||||
static uint8_t startIndex = 0;
|
||||
startIndex = startIndex + 1; /* motion speed */
|
||||
|
||||
for( int i = 0; i < NUM_LEDS; i++) {
|
||||
leds[i] = ColorFromPalette( currentPalette, startIndex, 64, currentBlending);
|
||||
startIndex += 3;
|
||||
}
|
||||
|
||||
FastLED.show();
|
||||
delay(40);
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
|
||||
void app_main() {
|
||||
FastLED.addLeds<LED_TYPE, DATA_PIN>(leds, NUM_LEDS);
|
||||
FastLED.setMaxPowerInVoltsAndMilliamps(5,1000);
|
||||
xTaskCreatePinnedToCore(&blinkLeds, "blinkLeds", 4000, NULL, 5, NULL, 0);
|
||||
}
|
||||
69
main/palettes.h
Normal file
69
main/palettes.h
Normal file
@ -0,0 +1,69 @@
|
||||
#pragma once
|
||||
|
||||
#include "FastLED.h"
|
||||
|
||||
// This function fills the palette with totally random colors.
|
||||
void SetupTotallyRandomPalette()
|
||||
{
|
||||
for( int i = 0; i < 16; i++) {
|
||||
currentPalette[i] = CHSV( random8(), 255, random8());
|
||||
}
|
||||
}
|
||||
|
||||
// This function sets up a palette of black and white stripes,
|
||||
// using code. Since the palette is effectively an array of
|
||||
// sixteen CRGB colors, the various fill_* functions can be used
|
||||
// to set them up.
|
||||
void SetupBlackAndWhiteStripedPalette()
|
||||
{
|
||||
// 'black out' all 16 palette entries...
|
||||
fill_solid( currentPalette, 16, CRGB::Black);
|
||||
// and set every fourth one to white.
|
||||
currentPalette[0] = CRGB::White;
|
||||
currentPalette[4] = CRGB::White;
|
||||
currentPalette[8] = CRGB::White;
|
||||
currentPalette[12] = CRGB::White;
|
||||
|
||||
}
|
||||
|
||||
// This function sets up a palette of purple and green stripes.
|
||||
void SetupPurpleAndGreenPalette()
|
||||
{
|
||||
CRGB purple = CHSV( HUE_PURPLE, 255, 255);
|
||||
CRGB green = CHSV( HUE_GREEN, 255, 255);
|
||||
CRGB black = CRGB::Black;
|
||||
|
||||
currentPalette = CRGBPalette16(
|
||||
green, green, black, black,
|
||||
purple, purple, black, black,
|
||||
green, green, black, black,
|
||||
purple, purple, black, black );
|
||||
}
|
||||
|
||||
|
||||
// This example shows how to set up a static color palette
|
||||
// which is stored in PROGMEM (flash), which is almost always more
|
||||
// plentiful than RAM. A static PROGMEM palette like this
|
||||
// takes up 64 bytes of flash.
|
||||
const TProgmemPalette16 myRedWhiteBluePalette_p =
|
||||
{
|
||||
CRGB::Red,
|
||||
CRGB::Gray, // 'white' is too bright compared to red and blue
|
||||
CRGB::Blue,
|
||||
CRGB::Black,
|
||||
|
||||
CRGB::Red,
|
||||
CRGB::Gray,
|
||||
CRGB::Blue,
|
||||
CRGB::Black,
|
||||
|
||||
CRGB::Red,
|
||||
CRGB::Red,
|
||||
CRGB::Gray,
|
||||
CRGB::Gray,
|
||||
CRGB::Blue,
|
||||
CRGB::Blue,
|
||||
CRGB::Black,
|
||||
CRGB::Black
|
||||
};
|
||||
|
||||
5
partitions.csv
Normal file
5
partitions.csv
Normal file
@ -0,0 +1,5 @@
|
||||
# Name, Type, SubType, Offset, Size, Flags
|
||||
# Note: if you change the phy_init or app partition offset, make sure to change the offset in Kconfig.projbuild
|
||||
nvs, data, nvs, , 0x6000,
|
||||
phy_init, data, phy, , 0x1000,
|
||||
factory, app, factory, , 1M,
|
||||
|
580
sdkconfig
Normal file
580
sdkconfig
Normal file
@ -0,0 +1,580 @@
|
||||
#
|
||||
# Automatically generated file; DO NOT EDIT.
|
||||
# Espressif IoT Development Framework Configuration
|
||||
#
|
||||
|
||||
#
|
||||
# SDK tool configuration
|
||||
#
|
||||
CONFIG_TOOLPREFIX="xtensa-esp32-elf-"
|
||||
CONFIG_PYTHON="python"
|
||||
CONFIG_MAKE_WARN_UNDEFINED_VARIABLES=y
|
||||
|
||||
#
|
||||
# Bootloader config
|
||||
#
|
||||
CONFIG_LOG_BOOTLOADER_LEVEL_NONE=
|
||||
CONFIG_LOG_BOOTLOADER_LEVEL_ERROR=
|
||||
CONFIG_LOG_BOOTLOADER_LEVEL_WARN=
|
||||
CONFIG_LOG_BOOTLOADER_LEVEL_INFO=y
|
||||
CONFIG_LOG_BOOTLOADER_LEVEL_DEBUG=
|
||||
CONFIG_LOG_BOOTLOADER_LEVEL_VERBOSE=
|
||||
CONFIG_LOG_BOOTLOADER_LEVEL=3
|
||||
CONFIG_BOOTLOADER_VDDSDIO_BOOST_1_8V=
|
||||
CONFIG_BOOTLOADER_VDDSDIO_BOOST_1_9V=y
|
||||
CONFIG_BOOTLOADER_FACTORY_RESET=
|
||||
CONFIG_BOOTLOADER_APP_TEST=
|
||||
|
||||
#
|
||||
# Security features
|
||||
#
|
||||
CONFIG_SECURE_SIGNED_APPS_NO_SECURE_BOOT=
|
||||
CONFIG_SECURE_BOOT_ENABLED=
|
||||
CONFIG_FLASH_ENCRYPTION_ENABLED=
|
||||
|
||||
#
|
||||
# Serial flasher config
|
||||
#
|
||||
CONFIG_ESPTOOLPY_PORT="/dev/tty.usbserial-A601LPYK"
|
||||
CONFIG_ESPTOOLPY_BAUD_115200B=y
|
||||
CONFIG_ESPTOOLPY_BAUD_230400B=
|
||||
CONFIG_ESPTOOLPY_BAUD_921600B=
|
||||
CONFIG_ESPTOOLPY_BAUD_2MB=
|
||||
CONFIG_ESPTOOLPY_BAUD_OTHER=
|
||||
CONFIG_ESPTOOLPY_BAUD_OTHER_VAL=115200
|
||||
CONFIG_ESPTOOLPY_BAUD=115200
|
||||
CONFIG_ESPTOOLPY_COMPRESSED=y
|
||||
CONFIG_FLASHMODE_QIO=
|
||||
CONFIG_FLASHMODE_QOUT=
|
||||
CONFIG_FLASHMODE_DIO=y
|
||||
CONFIG_FLASHMODE_DOUT=
|
||||
CONFIG_ESPTOOLPY_FLASHMODE="dio"
|
||||
CONFIG_ESPTOOLPY_FLASHFREQ_80M=
|
||||
CONFIG_ESPTOOLPY_FLASHFREQ_40M=y
|
||||
CONFIG_ESPTOOLPY_FLASHFREQ_26M=
|
||||
CONFIG_ESPTOOLPY_FLASHFREQ_20M=
|
||||
CONFIG_ESPTOOLPY_FLASHFREQ="40m"
|
||||
CONFIG_ESPTOOLPY_FLASHSIZE_1MB=
|
||||
CONFIG_ESPTOOLPY_FLASHSIZE_2MB=y
|
||||
CONFIG_ESPTOOLPY_FLASHSIZE_4MB=
|
||||
CONFIG_ESPTOOLPY_FLASHSIZE_8MB=
|
||||
CONFIG_ESPTOOLPY_FLASHSIZE_16MB=
|
||||
CONFIG_ESPTOOLPY_FLASHSIZE="2MB"
|
||||
CONFIG_ESPTOOLPY_FLASHSIZE_DETECT=y
|
||||
CONFIG_ESPTOOLPY_BEFORE_RESET=y
|
||||
CONFIG_ESPTOOLPY_BEFORE_NORESET=
|
||||
CONFIG_ESPTOOLPY_BEFORE="default_reset"
|
||||
CONFIG_ESPTOOLPY_AFTER_RESET=y
|
||||
CONFIG_ESPTOOLPY_AFTER_NORESET=
|
||||
CONFIG_ESPTOOLPY_AFTER="hard_reset"
|
||||
CONFIG_MONITOR_BAUD_9600B=
|
||||
CONFIG_MONITOR_BAUD_57600B=
|
||||
CONFIG_MONITOR_BAUD_115200B=y
|
||||
CONFIG_MONITOR_BAUD_230400B=
|
||||
CONFIG_MONITOR_BAUD_921600B=
|
||||
CONFIG_MONITOR_BAUD_2MB=
|
||||
CONFIG_MONITOR_BAUD_OTHER=
|
||||
CONFIG_MONITOR_BAUD_OTHER_VAL=115200
|
||||
CONFIG_MONITOR_BAUD=115200
|
||||
|
||||
#
|
||||
# Partition Table
|
||||
#
|
||||
CONFIG_PARTITION_TABLE_SINGLE_APP=y
|
||||
CONFIG_PARTITION_TABLE_TWO_OTA=
|
||||
CONFIG_PARTITION_TABLE_CUSTOM=
|
||||
CONFIG_PARTITION_TABLE_CUSTOM_FILENAME="partitions.csv"
|
||||
CONFIG_PARTITION_TABLE_FILENAME="partitions_singleapp.csv"
|
||||
CONFIG_PARTITION_TABLE_OFFSET=0x8000
|
||||
CONFIG_PARTITION_TABLE_MD5=y
|
||||
|
||||
#
|
||||
# Compiler options
|
||||
#
|
||||
CONFIG_OPTIMIZATION_LEVEL_DEBUG=y
|
||||
CONFIG_OPTIMIZATION_LEVEL_RELEASE=
|
||||
CONFIG_OPTIMIZATION_ASSERTIONS_ENABLED=y
|
||||
CONFIG_OPTIMIZATION_ASSERTIONS_SILENT=
|
||||
CONFIG_OPTIMIZATION_ASSERTIONS_DISABLED=
|
||||
CONFIG_CXX_EXCEPTIONS=
|
||||
CONFIG_STACK_CHECK_NONE=y
|
||||
CONFIG_STACK_CHECK_NORM=
|
||||
CONFIG_STACK_CHECK_STRONG=
|
||||
CONFIG_STACK_CHECK_ALL=
|
||||
CONFIG_STACK_CHECK=
|
||||
CONFIG_WARN_WRITE_STRINGS=
|
||||
|
||||
#
|
||||
# Component config
|
||||
#
|
||||
|
||||
#
|
||||
# Application Level Tracing
|
||||
#
|
||||
CONFIG_ESP32_APPTRACE_DEST_TRAX=
|
||||
CONFIG_ESP32_APPTRACE_DEST_NONE=y
|
||||
CONFIG_ESP32_APPTRACE_ENABLE=
|
||||
CONFIG_ESP32_APPTRACE_LOCK_ENABLE=y
|
||||
CONFIG_AWS_IOT_SDK=
|
||||
|
||||
#
|
||||
# Bluetooth
|
||||
#
|
||||
CONFIG_BT_ENABLED=
|
||||
CONFIG_BTDM_CONTROLLER_PINNED_TO_CORE=0
|
||||
CONFIG_BT_RESERVE_DRAM=0
|
||||
|
||||
#
|
||||
# Driver configurations
|
||||
#
|
||||
|
||||
#
|
||||
# ADC configuration
|
||||
#
|
||||
CONFIG_ADC_FORCE_XPD_FSM=
|
||||
CONFIG_ADC2_DISABLE_DAC=y
|
||||
|
||||
#
|
||||
# SPI master configuration
|
||||
#
|
||||
CONFIG_SPI_MASTER_IN_IRAM=
|
||||
CONFIG_SPI_MASTER_ISR_IN_IRAM=y
|
||||
|
||||
#
|
||||
# ESP32-specific
|
||||
#
|
||||
CONFIG_ESP32_DEFAULT_CPU_FREQ_80=
|
||||
CONFIG_ESP32_DEFAULT_CPU_FREQ_160=y
|
||||
CONFIG_ESP32_DEFAULT_CPU_FREQ_240=
|
||||
CONFIG_ESP32_DEFAULT_CPU_FREQ_MHZ=160
|
||||
CONFIG_SPIRAM_SUPPORT=
|
||||
CONFIG_MEMMAP_TRACEMEM=
|
||||
CONFIG_MEMMAP_TRACEMEM_TWOBANKS=
|
||||
CONFIG_ESP32_TRAX=
|
||||
CONFIG_TRACEMEM_RESERVE_DRAM=0x0
|
||||
CONFIG_ESP32_ENABLE_COREDUMP_TO_FLASH=
|
||||
CONFIG_ESP32_ENABLE_COREDUMP_TO_UART=
|
||||
CONFIG_ESP32_ENABLE_COREDUMP_TO_NONE=y
|
||||
CONFIG_ESP32_ENABLE_COREDUMP=
|
||||
CONFIG_TWO_UNIVERSAL_MAC_ADDRESS=
|
||||
CONFIG_FOUR_UNIVERSAL_MAC_ADDRESS=y
|
||||
CONFIG_NUMBER_OF_UNIVERSAL_MAC_ADDRESS=4
|
||||
CONFIG_SYSTEM_EVENT_QUEUE_SIZE=32
|
||||
CONFIG_SYSTEM_EVENT_TASK_STACK_SIZE=2048
|
||||
CONFIG_MAIN_TASK_STACK_SIZE=3584
|
||||
CONFIG_IPC_TASK_STACK_SIZE=1024
|
||||
CONFIG_TIMER_TASK_STACK_SIZE=3584
|
||||
CONFIG_NEWLIB_STDOUT_LINE_ENDING_CRLF=y
|
||||
CONFIG_NEWLIB_STDOUT_LINE_ENDING_LF=
|
||||
CONFIG_NEWLIB_STDOUT_LINE_ENDING_CR=
|
||||
CONFIG_NEWLIB_STDIN_LINE_ENDING_CRLF=
|
||||
CONFIG_NEWLIB_STDIN_LINE_ENDING_LF=
|
||||
CONFIG_NEWLIB_STDIN_LINE_ENDING_CR=y
|
||||
CONFIG_NEWLIB_NANO_FORMAT=
|
||||
CONFIG_CONSOLE_UART_DEFAULT=y
|
||||
CONFIG_CONSOLE_UART_CUSTOM=
|
||||
CONFIG_CONSOLE_UART_NONE=
|
||||
CONFIG_CONSOLE_UART_NUM=0
|
||||
CONFIG_CONSOLE_UART_BAUDRATE=115200
|
||||
CONFIG_ULP_COPROC_ENABLED=
|
||||
CONFIG_ULP_COPROC_RESERVE_MEM=0
|
||||
CONFIG_ESP32_PANIC_PRINT_HALT=
|
||||
CONFIG_ESP32_PANIC_PRINT_REBOOT=y
|
||||
CONFIG_ESP32_PANIC_SILENT_REBOOT=
|
||||
CONFIG_ESP32_PANIC_GDBSTUB=
|
||||
CONFIG_ESP32_DEBUG_OCDAWARE=y
|
||||
CONFIG_ESP32_DEBUG_STUBS_ENABLE=y
|
||||
CONFIG_INT_WDT=y
|
||||
CONFIG_INT_WDT_TIMEOUT_MS=300
|
||||
CONFIG_INT_WDT_CHECK_CPU1=y
|
||||
CONFIG_TASK_WDT=y
|
||||
CONFIG_TASK_WDT_PANIC=
|
||||
CONFIG_TASK_WDT_TIMEOUT_S=5
|
||||
CONFIG_TASK_WDT_CHECK_IDLE_TASK_CPU0=y
|
||||
CONFIG_TASK_WDT_CHECK_IDLE_TASK_CPU1=y
|
||||
CONFIG_BROWNOUT_DET=y
|
||||
CONFIG_BROWNOUT_DET_LVL_SEL_0=y
|
||||
CONFIG_BROWNOUT_DET_LVL_SEL_1=
|
||||
CONFIG_BROWNOUT_DET_LVL_SEL_2=
|
||||
CONFIG_BROWNOUT_DET_LVL_SEL_3=
|
||||
CONFIG_BROWNOUT_DET_LVL_SEL_4=
|
||||
CONFIG_BROWNOUT_DET_LVL_SEL_5=
|
||||
CONFIG_BROWNOUT_DET_LVL_SEL_6=
|
||||
CONFIG_BROWNOUT_DET_LVL_SEL_7=
|
||||
CONFIG_BROWNOUT_DET_LVL=0
|
||||
CONFIG_ESP32_TIME_SYSCALL_USE_RTC_FRC1=y
|
||||
CONFIG_ESP32_TIME_SYSCALL_USE_RTC=
|
||||
CONFIG_ESP32_TIME_SYSCALL_USE_FRC1=
|
||||
CONFIG_ESP32_TIME_SYSCALL_USE_NONE=
|
||||
CONFIG_ESP32_RTC_CLOCK_SOURCE_INTERNAL_RC=y
|
||||
CONFIG_ESP32_RTC_CLOCK_SOURCE_EXTERNAL_CRYSTAL=
|
||||
CONFIG_ESP32_RTC_CLK_CAL_CYCLES=1024
|
||||
CONFIG_ESP32_DEEP_SLEEP_WAKEUP_DELAY=2000
|
||||
CONFIG_ESP32_XTAL_FREQ_40=y
|
||||
CONFIG_ESP32_XTAL_FREQ_26=
|
||||
CONFIG_ESP32_XTAL_FREQ_AUTO=
|
||||
CONFIG_ESP32_XTAL_FREQ=40
|
||||
CONFIG_DISABLE_BASIC_ROM_CONSOLE=
|
||||
CONFIG_NO_BLOBS=
|
||||
CONFIG_ESP_TIMER_PROFILING=
|
||||
CONFIG_COMPATIBLE_PRE_V2_1_BOOTLOADERS=
|
||||
CONFIG_ESP_ERR_TO_NAME_LOOKUP=y
|
||||
|
||||
#
|
||||
# Wi-Fi
|
||||
#
|
||||
CONFIG_ESP32_WIFI_STATIC_RX_BUFFER_NUM=10
|
||||
CONFIG_ESP32_WIFI_DYNAMIC_RX_BUFFER_NUM=32
|
||||
CONFIG_ESP32_WIFI_STATIC_TX_BUFFER=
|
||||
CONFIG_ESP32_WIFI_DYNAMIC_TX_BUFFER=y
|
||||
CONFIG_ESP32_WIFI_TX_BUFFER_TYPE=1
|
||||
CONFIG_ESP32_WIFI_DYNAMIC_TX_BUFFER_NUM=32
|
||||
CONFIG_ESP32_WIFI_CSI_ENABLED=
|
||||
CONFIG_ESP32_WIFI_AMPDU_TX_ENABLED=y
|
||||
CONFIG_ESP32_WIFI_TX_BA_WIN=6
|
||||
CONFIG_ESP32_WIFI_AMPDU_RX_ENABLED=y
|
||||
CONFIG_ESP32_WIFI_RX_BA_WIN=6
|
||||
CONFIG_ESP32_WIFI_NVS_ENABLED=y
|
||||
CONFIG_ESP32_WIFI_TASK_PINNED_TO_CORE_0=y
|
||||
CONFIG_ESP32_WIFI_TASK_PINNED_TO_CORE_1=
|
||||
CONFIG_ESP32_WIFI_SOFTAP_BEACON_MAX_LEN=752
|
||||
|
||||
#
|
||||
# PHY
|
||||
#
|
||||
CONFIG_ESP32_PHY_CALIBRATION_AND_DATA_STORAGE=y
|
||||
CONFIG_ESP32_PHY_INIT_DATA_IN_PARTITION=
|
||||
CONFIG_ESP32_PHY_MAX_WIFI_TX_POWER=20
|
||||
CONFIG_ESP32_PHY_MAX_TX_POWER=20
|
||||
|
||||
#
|
||||
# Power Management
|
||||
#
|
||||
CONFIG_PM_ENABLE=
|
||||
|
||||
#
|
||||
# ADC-Calibration
|
||||
#
|
||||
CONFIG_ADC_CAL_EFUSE_TP_ENABLE=y
|
||||
CONFIG_ADC_CAL_EFUSE_VREF_ENABLE=y
|
||||
CONFIG_ADC_CAL_LUT_ENABLE=y
|
||||
|
||||
#
|
||||
# ESP HTTP client
|
||||
#
|
||||
CONFIG_ESP_HTTP_CLIENT_ENABLE_HTTPS=y
|
||||
|
||||
#
|
||||
# Ethernet
|
||||
#
|
||||
CONFIG_DMA_RX_BUF_NUM=10
|
||||
CONFIG_DMA_TX_BUF_NUM=10
|
||||
CONFIG_EMAC_L2_TO_L3_RX_BUF_MODE=
|
||||
CONFIG_EMAC_TASK_PRIORITY=20
|
||||
|
||||
#
|
||||
# FAT Filesystem support
|
||||
#
|
||||
CONFIG_FATFS_CODEPAGE_DYNAMIC=
|
||||
CONFIG_FATFS_CODEPAGE_437=y
|
||||
CONFIG_FATFS_CODEPAGE_720=
|
||||
CONFIG_FATFS_CODEPAGE_737=
|
||||
CONFIG_FATFS_CODEPAGE_771=
|
||||
CONFIG_FATFS_CODEPAGE_775=
|
||||
CONFIG_FATFS_CODEPAGE_850=
|
||||
CONFIG_FATFS_CODEPAGE_852=
|
||||
CONFIG_FATFS_CODEPAGE_855=
|
||||
CONFIG_FATFS_CODEPAGE_857=
|
||||
CONFIG_FATFS_CODEPAGE_860=
|
||||
CONFIG_FATFS_CODEPAGE_861=
|
||||
CONFIG_FATFS_CODEPAGE_862=
|
||||
CONFIG_FATFS_CODEPAGE_863=
|
||||
CONFIG_FATFS_CODEPAGE_864=
|
||||
CONFIG_FATFS_CODEPAGE_865=
|
||||
CONFIG_FATFS_CODEPAGE_866=
|
||||
CONFIG_FATFS_CODEPAGE_869=
|
||||
CONFIG_FATFS_CODEPAGE_932=
|
||||
CONFIG_FATFS_CODEPAGE_936=
|
||||
CONFIG_FATFS_CODEPAGE_949=
|
||||
CONFIG_FATFS_CODEPAGE_950=
|
||||
CONFIG_FATFS_CODEPAGE=437
|
||||
CONFIG_FATFS_LFN_NONE=y
|
||||
CONFIG_FATFS_LFN_HEAP=
|
||||
CONFIG_FATFS_LFN_STACK=
|
||||
CONFIG_FATFS_FS_LOCK=0
|
||||
CONFIG_FATFS_TIMEOUT_MS=10000
|
||||
CONFIG_FATFS_PER_FILE_CACHE=y
|
||||
|
||||
#
|
||||
# FreeRTOS
|
||||
#
|
||||
CONFIG_FREERTOS_UNICORE=
|
||||
CONFIG_FREERTOS_CORETIMER_0=y
|
||||
CONFIG_FREERTOS_CORETIMER_1=
|
||||
CONFIG_FREERTOS_HZ=100
|
||||
CONFIG_FREERTOS_ASSERT_ON_UNTESTED_FUNCTION=y
|
||||
CONFIG_FREERTOS_CHECK_STACKOVERFLOW_NONE=
|
||||
CONFIG_FREERTOS_CHECK_STACKOVERFLOW_PTRVAL=
|
||||
CONFIG_FREERTOS_CHECK_STACKOVERFLOW_CANARY=y
|
||||
CONFIG_FREERTOS_WATCHPOINT_END_OF_STACK=
|
||||
CONFIG_FREERTOS_INTERRUPT_BACKTRACE=y
|
||||
CONFIG_FREERTOS_THREAD_LOCAL_STORAGE_POINTERS=1
|
||||
CONFIG_FREERTOS_ASSERT_FAIL_ABORT=y
|
||||
CONFIG_FREERTOS_ASSERT_FAIL_PRINT_CONTINUE=
|
||||
CONFIG_FREERTOS_ASSERT_DISABLE=
|
||||
CONFIG_FREERTOS_IDLE_TASK_STACKSIZE=1024
|
||||
CONFIG_FREERTOS_ISR_STACKSIZE=1536
|
||||
CONFIG_FREERTOS_LEGACY_HOOKS=
|
||||
CONFIG_FREERTOS_MAX_TASK_NAME_LEN=16
|
||||
CONFIG_SUPPORT_STATIC_ALLOCATION=
|
||||
CONFIG_TIMER_TASK_PRIORITY=1
|
||||
CONFIG_TIMER_TASK_STACK_DEPTH=2048
|
||||
CONFIG_TIMER_QUEUE_LENGTH=10
|
||||
CONFIG_FREERTOS_QUEUE_REGISTRY_SIZE=0
|
||||
CONFIG_FREERTOS_USE_TRACE_FACILITY=
|
||||
CONFIG_FREERTOS_GENERATE_RUN_TIME_STATS=
|
||||
CONFIG_FREERTOS_DEBUG_INTERNALS=
|
||||
|
||||
#
|
||||
# Heap memory debugging
|
||||
#
|
||||
CONFIG_HEAP_POISONING_DISABLED=y
|
||||
CONFIG_HEAP_POISONING_LIGHT=
|
||||
CONFIG_HEAP_POISONING_COMPREHENSIVE=
|
||||
CONFIG_HEAP_TRACING=
|
||||
|
||||
#
|
||||
# libsodium
|
||||
#
|
||||
CONFIG_LIBSODIUM_USE_MBEDTLS_SHA=y
|
||||
|
||||
#
|
||||
# Log output
|
||||
#
|
||||
CONFIG_LOG_DEFAULT_LEVEL_NONE=
|
||||
CONFIG_LOG_DEFAULT_LEVEL_ERROR=
|
||||
CONFIG_LOG_DEFAULT_LEVEL_WARN=
|
||||
CONFIG_LOG_DEFAULT_LEVEL_INFO=y
|
||||
CONFIG_LOG_DEFAULT_LEVEL_DEBUG=
|
||||
CONFIG_LOG_DEFAULT_LEVEL_VERBOSE=
|
||||
CONFIG_LOG_DEFAULT_LEVEL=3
|
||||
CONFIG_LOG_COLORS=y
|
||||
|
||||
#
|
||||
# LWIP
|
||||
#
|
||||
CONFIG_L2_TO_L3_COPY=
|
||||
CONFIG_LWIP_IRAM_OPTIMIZATION=
|
||||
CONFIG_LWIP_MAX_SOCKETS=10
|
||||
CONFIG_USE_ONLY_LWIP_SELECT=
|
||||
CONFIG_LWIP_SO_REUSE=y
|
||||
CONFIG_LWIP_SO_REUSE_RXTOALL=y
|
||||
CONFIG_LWIP_SO_RCVBUF=
|
||||
CONFIG_LWIP_DHCP_MAX_NTP_SERVERS=1
|
||||
CONFIG_LWIP_IP_FRAG=
|
||||
CONFIG_LWIP_IP_REASSEMBLY=
|
||||
CONFIG_LWIP_STATS=
|
||||
CONFIG_LWIP_ETHARP_TRUST_IP_MAC=
|
||||
CONFIG_ESP_GRATUITOUS_ARP=y
|
||||
CONFIG_GARP_TMR_INTERVAL=60
|
||||
CONFIG_TCPIP_RECVMBOX_SIZE=32
|
||||
CONFIG_LWIP_DHCP_DOES_ARP_CHECK=y
|
||||
|
||||
#
|
||||
# DHCP server
|
||||
#
|
||||
CONFIG_LWIP_DHCPS_LEASE_UNIT=60
|
||||
CONFIG_LWIP_DHCPS_MAX_STATION_NUM=8
|
||||
CONFIG_LWIP_AUTOIP=
|
||||
CONFIG_LWIP_NETIF_LOOPBACK=y
|
||||
CONFIG_LWIP_LOOPBACK_MAX_PBUFS=8
|
||||
|
||||
#
|
||||
# TCP
|
||||
#
|
||||
CONFIG_LWIP_MAX_ACTIVE_TCP=16
|
||||
CONFIG_LWIP_MAX_LISTENING_TCP=16
|
||||
CONFIG_TCP_MAXRTX=12
|
||||
CONFIG_TCP_SYNMAXRTX=6
|
||||
CONFIG_TCP_MSS=1436
|
||||
CONFIG_TCP_MSL=60000
|
||||
CONFIG_TCP_SND_BUF_DEFAULT=5744
|
||||
CONFIG_TCP_WND_DEFAULT=5744
|
||||
CONFIG_TCP_RECVMBOX_SIZE=6
|
||||
CONFIG_TCP_QUEUE_OOSEQ=y
|
||||
CONFIG_ESP_TCP_KEEP_CONNECTION_WHEN_IP_CHANGES=
|
||||
CONFIG_TCP_OVERSIZE_MSS=y
|
||||
CONFIG_TCP_OVERSIZE_QUARTER_MSS=
|
||||
CONFIG_TCP_OVERSIZE_DISABLE=
|
||||
|
||||
#
|
||||
# UDP
|
||||
#
|
||||
CONFIG_LWIP_MAX_UDP_PCBS=16
|
||||
CONFIG_UDP_RECVMBOX_SIZE=6
|
||||
CONFIG_TCPIP_TASK_STACK_SIZE=2048
|
||||
CONFIG_PPP_SUPPORT=
|
||||
|
||||
#
|
||||
# ICMP
|
||||
#
|
||||
CONFIG_LWIP_MULTICAST_PING=
|
||||
CONFIG_LWIP_BROADCAST_PING=
|
||||
|
||||
#
|
||||
# LWIP RAW API
|
||||
#
|
||||
CONFIG_LWIP_MAX_RAW_PCBS=16
|
||||
|
||||
#
|
||||
# mbedTLS
|
||||
#
|
||||
CONFIG_MBEDTLS_SSL_MAX_CONTENT_LEN=16384
|
||||
CONFIG_MBEDTLS_DEBUG=
|
||||
CONFIG_MBEDTLS_HARDWARE_AES=y
|
||||
CONFIG_MBEDTLS_HARDWARE_MPI=
|
||||
CONFIG_MBEDTLS_HARDWARE_SHA=
|
||||
CONFIG_MBEDTLS_HAVE_TIME=y
|
||||
CONFIG_MBEDTLS_HAVE_TIME_DATE=
|
||||
CONFIG_MBEDTLS_TLS_SERVER_AND_CLIENT=y
|
||||
CONFIG_MBEDTLS_TLS_SERVER_ONLY=
|
||||
CONFIG_MBEDTLS_TLS_CLIENT_ONLY=
|
||||
CONFIG_MBEDTLS_TLS_DISABLED=
|
||||
CONFIG_MBEDTLS_TLS_SERVER=y
|
||||
CONFIG_MBEDTLS_TLS_CLIENT=y
|
||||
CONFIG_MBEDTLS_TLS_ENABLED=y
|
||||
|
||||
#
|
||||
# TLS Key Exchange Methods
|
||||
#
|
||||
CONFIG_MBEDTLS_PSK_MODES=
|
||||
CONFIG_MBEDTLS_KEY_EXCHANGE_RSA=y
|
||||
CONFIG_MBEDTLS_KEY_EXCHANGE_DHE_RSA=y
|
||||
CONFIG_MBEDTLS_KEY_EXCHANGE_ELLIPTIC_CURVE=y
|
||||
CONFIG_MBEDTLS_KEY_EXCHANGE_ECDHE_RSA=y
|
||||
CONFIG_MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA=y
|
||||
CONFIG_MBEDTLS_KEY_EXCHANGE_ECDH_ECDSA=y
|
||||
CONFIG_MBEDTLS_KEY_EXCHANGE_ECDH_RSA=y
|
||||
CONFIG_MBEDTLS_SSL_RENEGOTIATION=y
|
||||
CONFIG_MBEDTLS_SSL_PROTO_SSL3=
|
||||
CONFIG_MBEDTLS_SSL_PROTO_TLS1=y
|
||||
CONFIG_MBEDTLS_SSL_PROTO_TLS1_1=y
|
||||
CONFIG_MBEDTLS_SSL_PROTO_TLS1_2=y
|
||||
CONFIG_MBEDTLS_SSL_PROTO_DTLS=
|
||||
CONFIG_MBEDTLS_SSL_ALPN=y
|
||||
CONFIG_MBEDTLS_SSL_SESSION_TICKETS=y
|
||||
|
||||
#
|
||||
# Symmetric Ciphers
|
||||
#
|
||||
CONFIG_MBEDTLS_AES_C=y
|
||||
CONFIG_MBEDTLS_CAMELLIA_C=
|
||||
CONFIG_MBEDTLS_DES_C=
|
||||
CONFIG_MBEDTLS_RC4_DISABLED=y
|
||||
CONFIG_MBEDTLS_RC4_ENABLED_NO_DEFAULT=
|
||||
CONFIG_MBEDTLS_RC4_ENABLED=
|
||||
CONFIG_MBEDTLS_BLOWFISH_C=
|
||||
CONFIG_MBEDTLS_XTEA_C=
|
||||
CONFIG_MBEDTLS_CCM_C=y
|
||||
CONFIG_MBEDTLS_GCM_C=y
|
||||
CONFIG_MBEDTLS_RIPEMD160_C=
|
||||
|
||||
#
|
||||
# Certificates
|
||||
#
|
||||
CONFIG_MBEDTLS_PEM_PARSE_C=y
|
||||
CONFIG_MBEDTLS_PEM_WRITE_C=y
|
||||
CONFIG_MBEDTLS_X509_CRL_PARSE_C=y
|
||||
CONFIG_MBEDTLS_X509_CSR_PARSE_C=y
|
||||
CONFIG_MBEDTLS_ECP_C=y
|
||||
CONFIG_MBEDTLS_ECDH_C=y
|
||||
CONFIG_MBEDTLS_ECDSA_C=y
|
||||
CONFIG_MBEDTLS_ECP_DP_SECP192R1_ENABLED=y
|
||||
CONFIG_MBEDTLS_ECP_DP_SECP224R1_ENABLED=y
|
||||
CONFIG_MBEDTLS_ECP_DP_SECP256R1_ENABLED=y
|
||||
CONFIG_MBEDTLS_ECP_DP_SECP384R1_ENABLED=y
|
||||
CONFIG_MBEDTLS_ECP_DP_SECP521R1_ENABLED=y
|
||||
CONFIG_MBEDTLS_ECP_DP_SECP192K1_ENABLED=y
|
||||
CONFIG_MBEDTLS_ECP_DP_SECP224K1_ENABLED=y
|
||||
CONFIG_MBEDTLS_ECP_DP_SECP256K1_ENABLED=y
|
||||
CONFIG_MBEDTLS_ECP_DP_BP256R1_ENABLED=y
|
||||
CONFIG_MBEDTLS_ECP_DP_BP384R1_ENABLED=y
|
||||
CONFIG_MBEDTLS_ECP_DP_BP512R1_ENABLED=y
|
||||
CONFIG_MBEDTLS_ECP_DP_CURVE25519_ENABLED=y
|
||||
CONFIG_MBEDTLS_ECP_NIST_OPTIM=y
|
||||
|
||||
#
|
||||
# NVS
|
||||
#
|
||||
CONFIG_MP_BLOB_SUPPORT=
|
||||
|
||||
#
|
||||
# OpenSSL
|
||||
#
|
||||
CONFIG_OPENSSL_DEBUG=
|
||||
CONFIG_OPENSSL_ASSERT_DO_NOTHING=y
|
||||
CONFIG_OPENSSL_ASSERT_EXIT=
|
||||
|
||||
#
|
||||
# PThreads
|
||||
#
|
||||
CONFIG_ESP32_PTHREAD_TASK_PRIO_DEFAULT=5
|
||||
CONFIG_ESP32_PTHREAD_TASK_STACK_SIZE_DEFAULT=3072
|
||||
|
||||
#
|
||||
# SPI Flash driver
|
||||
#
|
||||
CONFIG_SPI_FLASH_VERIFY_WRITE=
|
||||
CONFIG_SPI_FLASH_ENABLE_COUNTERS=
|
||||
CONFIG_SPI_FLASH_ROM_DRIVER_PATCH=y
|
||||
CONFIG_SPI_FLASH_WRITING_DANGEROUS_REGIONS_ABORTS=y
|
||||
CONFIG_SPI_FLASH_WRITING_DANGEROUS_REGIONS_FAILS=
|
||||
CONFIG_SPI_FLASH_WRITING_DANGEROUS_REGIONS_ALLOWED=
|
||||
|
||||
#
|
||||
# SPIFFS Configuration
|
||||
#
|
||||
CONFIG_SPIFFS_MAX_PARTITIONS=3
|
||||
|
||||
#
|
||||
# SPIFFS Cache Configuration
|
||||
#
|
||||
CONFIG_SPIFFS_CACHE=y
|
||||
CONFIG_SPIFFS_CACHE_WR=y
|
||||
CONFIG_SPIFFS_CACHE_STATS=
|
||||
CONFIG_SPIFFS_PAGE_CHECK=y
|
||||
CONFIG_SPIFFS_GC_MAX_RUNS=10
|
||||
CONFIG_SPIFFS_GC_STATS=
|
||||
CONFIG_SPIFFS_PAGE_SIZE=256
|
||||
CONFIG_SPIFFS_OBJ_NAME_LEN=32
|
||||
CONFIG_SPIFFS_USE_MAGIC=y
|
||||
CONFIG_SPIFFS_USE_MAGIC_LENGTH=y
|
||||
CONFIG_SPIFFS_META_LENGTH=4
|
||||
CONFIG_SPIFFS_USE_MTIME=y
|
||||
|
||||
#
|
||||
# Debug Configuration
|
||||
#
|
||||
CONFIG_SPIFFS_DBG=
|
||||
CONFIG_SPIFFS_API_DBG=
|
||||
CONFIG_SPIFFS_GC_DBG=
|
||||
CONFIG_SPIFFS_CACHE_DBG=
|
||||
CONFIG_SPIFFS_CHECK_DBG=
|
||||
CONFIG_SPIFFS_TEST_VISUALISATION=
|
||||
|
||||
#
|
||||
# tcpip adapter
|
||||
#
|
||||
CONFIG_IP_LOST_TIMER_INTERVAL=120
|
||||
|
||||
#
|
||||
# Virtual file system
|
||||
#
|
||||
CONFIG_SUPPRESS_SELECT_DEBUG_OUTPUT=y
|
||||
|
||||
#
|
||||
# Wear Levelling
|
||||
#
|
||||
CONFIG_WL_SECTOR_SIZE_512=
|
||||
CONFIG_WL_SECTOR_SIZE_4096=y
|
||||
CONFIG_WL_SECTOR_SIZE=4096
|
||||
Reference in New Issue
Block a user