lba.gitea/FastLED
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge pull request #1461 from nielsnl68/NoRegister

Browse Source 
Update all REGISTER to FASTLED_REGISTER
This commit is contained in:
Sam Guyer 2023-05-29 14:12:49 -04:00 committed by GitHub
commit 647c1733b7
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
48 changed files with 303 additions and 299 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
src/chipsets.h
View File

@ -90,7 +90,7 @@ class LPD8806Controller : public CPixelLEDController<RGB_ORDER> {
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 uint8_t adjust(FASTLED_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));
}
@ -185,7 +185,7 @@ protected:
startBoundary();
while(pixels.has(1)) {
REGISTER uint16_t command;
FASTLED_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
@ -361,7 +361,7 @@ class P9813Controller : public CPixelLEDController<RGB_ORDER> {
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);
FASTLED_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);
}

8
src/cpp_compat.h
View File

@ -22,9 +22,13 @@
#endif
#if __cplusplus < 201703L
#define REGISTER register
#define FASTLED_REGISTER register
#else
#define REGISTER
#ifdef FASTLED_REGISTER
#undef FASTLED_REGISTER
#endif
#define FASTLED_REGISTER
#endif
#endif

44
src/fastpin.h
View File

@ -76,19 +76,19 @@ public:
/// Set the same pin on another port to `HIGH`
/// @param port the port to modify
inline void hi(REGISTER port_ptr_t port) __attribute__ ((always_inline)) { *port |= mPinMask; }
inline void hi(FASTLED_REGISTER port_ptr_t port) __attribute__ ((always_inline)) { *port |= mPinMask; }
/// Set the same pin on another port to `LOW`
/// @param port the port to modify
inline void lo(REGISTER port_ptr_t port) __attribute__ ((always_inline)) { *port &= ~mPinMask; }
inline void lo(FASTLED_REGISTER port_ptr_t port) __attribute__ ((always_inline)) { *port &= ~mPinMask; }
/// Set the state of the output register
/// @param val the state to set the output register to
/// @note This function is not limited to the current pin! It modifies the entire register.
inline void set(REGISTER port_t val) __attribute__ ((always_inline)) { *mPort = val; }
inline void set(FASTLED_REGISTER port_t val) __attribute__ ((always_inline)) { *mPort = val; }
/// Set the state of a port
/// @param port the port to modify
/// @param val the state to set the port to
inline void fastset(REGISTER port_ptr_t port, REGISTER port_t val) __attribute__((always_inline)) { *port = val; }
inline void fastset(FASTLED_REGISTER port_ptr_t port, FASTLED_REGISTER port_t val) __attribute__ ((always_inline)) { *port = val; }
/// Gets the state of the port with this pin `HIGH`
port_t hival() __attribute__ ((always_inline)) { return *mPort | mPinMask; }
@ -154,11 +154,11 @@ public:
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 hi(FASTLED_REGISTER port_ptr_t port) __attribute__ ((always_inline)) { *port |= mPinMask; }
inline void lo(FASTLED_REGISTER port_ptr_t port) __attribute__ ((always_inline)) { *port &= ~mPinMask; }
inline void set(FASTLED_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; }
inline void fastset(FASTLED_REGISTER port_ptr_t port, FASTLED_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; }
@ -229,15 +229,15 @@ public:
/// @copydoc Pin::toggle()
inline static void toggle() __attribute__ ((always_inline)) { *sInPort = sPinMask; }
/// @copydoc Pin::hi(REGISTER port_ptr_t)
inline static void hi(REGISTER port_ptr_t port) __attribute__ ((always_inline)) { *port |= sPinMask; }
/// @copydoc Pin::lo(REGISTER port_ptr_t)
inline static void lo(REGISTER port_ptr_t port) __attribute__ ((always_inline)) { *port &= ~sPinMask; }
/// @copydoc Pin::set(REGISTER port_t)
inline static void set(REGISTER port_t val) __attribute__ ((always_inline)) { *sPort = val; }
/// @copydoc Pin::hi(FASTLED_REGISTER port_ptr_t)
inline static void hi(FASTLED_REGISTER port_ptr_t port) __attribute__ ((always_inline)) { *port |= sPinMask; }
/// @copydoc Pin::lo(FASTLED_REGISTER port_ptr_t)
inline static void lo(FASTLED_REGISTER port_ptr_t port) __attribute__ ((always_inline)) { *port &= ~sPinMask; }
/// @copydoc Pin::set(FASTLED_REGISTER port_t)
inline static void set(FASTLED_REGISTER port_t val) __attribute__ ((always_inline)) { *sPort = val; }
/// @copydoc Pin::fastset()
inline static void fastset(REGISTER port_ptr_t port, REGISTER port_t val) __attribute__ ((always_inline)) { *port = val; }
inline static void fastset(FASTLED_REGISTER port_ptr_t port, FASTLED_REGISTER port_t val) __attribute__ ((always_inline)) { *port = val; }
/// @copydoc Pin::hival()
static port_t hival() __attribute__ ((always_inline)) { return *sPort | sPinMask; }
@ -282,15 +282,15 @@ public:
/// @copydoc Pin::toggle()
inline static void toggle() __attribute__ ((always_inline)) { }
/// @copydoc Pin::hi(REGISTER port_ptr_t)
inline static void hi(REGISTER port_ptr_t port) __attribute__ ((always_inline)) { }
/// @copydoc Pin::lo(REGISTER port_ptr_t)
inline static void lo(REGISTER port_ptr_t port) __attribute__ ((always_inline)) { }
/// @copydoc Pin::set(REGISTER port_t)
inline static void set(REGISTER port_t val) __attribute__ ((always_inline)) { }
/// @copydoc Pin::hi(FASTLED_REGISTER port_ptr_t)
inline static void hi(FASTLED_REGISTER port_ptr_t port) __attribute__ ((always_inline)) { }
/// @copydoc Pin::lo(FASTLED_REGISTER port_ptr_t)
inline static void lo(FASTLED_REGISTER port_ptr_t port) __attribute__ ((always_inline)) { }
/// @copydoc Pin::set(FASTLED_REGISTER port_t)
inline static void set(FASTLED_REGISTER port_t val) __attribute__ ((always_inline)) { }
/// @copydoc Pin::fastset()
inline static void fastset(REGISTER port_ptr_t port, REGISTER port_t val) __attribute__ ((always_inline)) { }
inline static void fastset(FASTLED_REGISTER port_ptr_t port, FASTLED_REGISTER port_t val) __attribute__ ((always_inline)) { }
/// @copydoc Pin::hival()
static port_t hival() __attribute__ ((always_inline)) { return 0; }

64
src/fastspi_bitbang.h
View File

@ -259,26 +259,26 @@ public:
writeByte(value);
}
#else
REGISTER data_ptr_t datapin = FastPin<DATA_PIN>::port();
FASTLED_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();
FASTLED_REGISTER clock_ptr_t clockpin = FastPin<CLOCK_PIN>::port();
FASTLED_REGISTER data_t datahi = FastPin<DATA_PIN>::hival();
FASTLED_REGISTER data_t datalo = FastPin<DATA_PIN>::loval();
FASTLED_REGISTER clock_t clockhi = FastPin<CLOCK_PIN>::hival();
FASTLED_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();
FASTLED_REGISTER data_t datahi_clockhi = FastPin<DATA_PIN>::hival() | FastPin<CLOCK_PIN>::mask();
FASTLED_REGISTER data_t datalo_clockhi = FastPin<DATA_PIN>::loval() | FastPin<CLOCK_PIN>::mask();
FASTLED_REGISTER data_t datahi_clocklo = FastPin<DATA_PIN>::hival() & ~FastPin<CLOCK_PIN>::mask();
FASTLED_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);
@ -292,7 +292,7 @@ public:
/// @param data pointer to data to write
/// @param len number of bytes to write
/// @todo Need to type this better so that explicit casts into the call aren't required.
template <class D> void writeBytes(REGISTER uint8_t *data, int len) {
template <class D> void writeBytes(FASTLED_REGISTER uint8_t *data, int len) {
select();
#ifdef FAST_SPI_INTERRUPTS_WRITE_PINS
uint8_t *end = data + len;
@ -300,16 +300,16 @@ public:
writeByte(D::adjust(*data++));
}
#else
REGISTER clock_ptr_t clockpin = FastPin<CLOCK_PIN>::port();
REGISTER data_ptr_t datapin = FastPin<DATA_PIN>::port();
FASTLED_REGISTER clock_ptr_t clockpin = FastPin<CLOCK_PIN>::port();
FASTLED_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();
FASTLED_REGISTER data_t datahi = FastPin<DATA_PIN>::hival();
FASTLED_REGISTER data_t datalo = FastPin<DATA_PIN>::loval();
FASTLED_REGISTER clock_t clockhi = FastPin<CLOCK_PIN>::hival();
FASTLED_REGISTER clock_t clocklo = FastPin<CLOCK_PIN>::loval();
uint8_t *end = data + len;
while(data != end) {
@ -319,10 +319,10 @@ public:
} 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();
FASTLED_REGISTER data_t datahi_clockhi = FastPin<DATA_PIN>::hival() | FastPin<CLOCK_PIN>::mask();
FASTLED_REGISTER data_t datalo_clockhi = FastPin<DATA_PIN>::loval() | FastPin<CLOCK_PIN>::mask();
FASTLED_REGISTER data_t datahi_clocklo = FastPin<DATA_PIN>::hival() & ~FastPin<CLOCK_PIN>::mask();
FASTLED_REGISTER data_t datalo_clocklo = FastPin<DATA_PIN>::loval() & ~FastPin<CLOCK_PIN>::mask();
uint8_t *end = data + len;
@ -339,7 +339,7 @@ public:
/// Write an array of data to the SPI interface.
/// @param data pointer to data to write
/// @param len number of bytes to write
void writeBytes(REGISTER uint8_t *data, int len) { writeBytes<DATA_NOP>(data, len); }
void writeBytes(FASTLED_REGISTER uint8_t *data, int len) { writeBytes<DATA_NOP>(data, len); }
/// Write LED pixel data to the SPI interface.
@ -368,16 +368,16 @@ public:
#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();
FASTLED_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();
FASTLED_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();
FASTLED_REGISTER data_t datahi = FastPin<DATA_PIN>::hival();
FASTLED_REGISTER data_t datalo = FastPin<DATA_PIN>::loval();
FASTLED_REGISTER clock_t clockhi = FastPin<CLOCK_PIN>::hival();
FASTLED_REGISTER clock_t clocklo = FastPin<CLOCK_PIN>::loval();
while(pixels.has(1)) {
if(FLAGS & FLAG_START_BIT) {
@ -392,10 +392,10 @@ public:
} 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();
FASTLED_REGISTER data_t datahi_clockhi = FastPin<DATA_PIN>::hival() | FastPin<CLOCK_PIN>::mask();
FASTLED_REGISTER data_t datalo_clockhi = FastPin<DATA_PIN>::loval() | FastPin<CLOCK_PIN>::mask();
FASTLED_REGISTER data_t datahi_clocklo = FastPin<DATA_PIN>::hival() & ~FastPin<CLOCK_PIN>::mask();
FASTLED_REGISTER data_t datalo_clocklo = FastPin<DATA_PIN>::loval() & ~FastPin<CLOCK_PIN>::mask();
while(pixels.has(1)) {
if(FLAGS & FLAG_START_BIT) {

4
src/fastspi_ref.h
View File

@ -55,7 +55,7 @@ public:
}
/// 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) {
template <class D> void writeBytes(FASTLED_REGISTER uint8_t *data, int len) {
uint8_t *end = data + len;
select();
// could be optimized to write 16bit words out instead of 8bit bytes
@ -68,7 +68,7 @@ public:
}
/// 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); }
void writeBytes(FASTLED_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 */ }

4
src/fastspi_types.h
View File

@ -35,13 +35,13 @@ class DATA_NOP {
public:
/// Hook called to adjust a byte of data before writing it to the output.
/// In this dummy version, no adjustment is made.
static __attribute__((always_inline)) inline uint8_t adjust(REGISTER uint8_t data) { return data; }
static __attribute__((always_inline)) inline uint8_t adjust(FASTLED_REGISTER uint8_t data) { return data; }
/// @copybrief adjust(register uint8_t)
/// @param data input byte
/// @param scale scale value
/// @returns input byte rescaled using ::scale8(uint8_t, uint8_t)
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 uint8_t adjust(FASTLED_REGISTER uint8_t data, FASTLED_REGISTER uint8_t scale) { return scale8(data, scale); }
/// Hook called after a block of data is written to the output.
/// In this dummy version, no action is performed.

8
src/platforms/apollo3/clockless_apollo3.h
View File

@ -84,9 +84,9 @@ protected:
mWait.mark();
}
template<int BITS> __attribute__ ((always_inline)) inline static void writeBits(REGISTER uint32_t & next_mark, REGISTER uint8_t & b) {
template<int BITS> __attribute__ ((always_inline)) inline static void writeBits(FASTLED_REGISTER uint32_t & next_mark, FASTLED_REGISTER uint8_t & b) {
// SysTick counts down (not up) and is 24-bit
for(REGISTER uint32_t i = BITS-1; i > 0; i--) { // We could speed this up by using Bit Banding
for(FASTLED_REGISTER uint32_t i = BITS-1; i > 0; i--) { // We could speed this up by using Bit Banding
while(__am_hal_systick_count() > next_mark) { ; } // Wait for the remainder of this cycle to complete
// Calculate next_mark (the time of the next DATA_PIN transition) by subtracting T1+T2+T3
// SysTick counts down (not up) and is 24-bit
@ -126,14 +126,14 @@ protected:
// Setup the pixel controller and load/scale the first byte
pixels.preStepFirstByteDithering();
REGISTER uint8_t b = pixels.loadAndScale0();
FASTLED_REGISTER uint8_t b = pixels.loadAndScale0();
cli();
// Calculate next_mark (the time of the next DATA_PIN transition) by subtracting T1+T2+T3
// SysTick counts down (not up) and is 24-bit
// The subtraction could underflow (wrap round) so let's mask the result to 24 bits
REGISTER uint32_t next_mark = (__am_hal_systick_count() - (T1+T2+T3)) & 0xFFFFFFUL;
FASTLED_REGISTER uint32_t next_mark = (__am_hal_systick_count() - (T1+T2+T3)) & 0xFFFFFFUL;
while(pixels.has(1)) { // Keep going for as long as we have pixels
pixels.stepDithering();

8
src/platforms/apollo3/fastpin_apollo3.h
View File

@ -20,15 +20,15 @@ public:
inline static void hi() __attribute__ ((always_inline)) { am_hal_gpio_fastgpio_set(PAD); }
inline static void lo() __attribute__ ((always_inline)) { am_hal_gpio_fastgpio_clr(PAD); }
inline static void set(REGISTER port_t val) __attribute__ ((always_inline)) { if(val) { am_hal_gpio_fastgpio_set(PAD); } else { am_hal_gpio_fastgpio_clr(PAD); } }
inline static void set(FASTLED_REGISTER port_t val) __attribute__ ((always_inline)) { if(val) { am_hal_gpio_fastgpio_set(PAD); } else { am_hal_gpio_fastgpio_clr(PAD); } }
inline static void strobe() __attribute__ ((always_inline)) { toggle(); toggle(); }
inline static void toggle() __attribute__ ((always_inline)) { if( am_hal_gpio_fastgpio_read(PAD)) { lo(); } else { hi(); } }
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)) { set(val); }
inline static void hi(FASTLED_REGISTER port_ptr_t port) __attribute__ ((always_inline)) { hi(); }
inline static void lo(FASTLED_REGISTER port_ptr_t port) __attribute__ ((always_inline)) { lo(); }
inline static void fastset(FASTLED_REGISTER port_ptr_t port, FASTLED_REGISTER port_t val) __attribute__ ((always_inline)) { set(val); }
inline static port_t hival() __attribute__ ((always_inline)) { return 0; }
inline static port_t loval() __attribute__ ((always_inline)) { return 0; }

4
src/platforms/apollo3/fastspi_apollo3.h
View File

@ -72,7 +72,7 @@ public:
}
// 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) {
template <class D> void writeBytes(FASTLED_REGISTER uint8_t *data, int len) {
uint8_t *end = data + len;
select();
// could be optimized to write 16bit words out instead of 8bit bytes
@ -85,7 +85,7 @@ public:
}
// 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); }
void writeBytes(FASTLED_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) {

18
src/platforms/arm/common/m0clockless.h
View File

@ -13,17 +13,17 @@ struct M0ClocklessData {
template<int HI_OFFSET, int LO_OFFSET, int T1, int T2, int T3, EOrder RGB_ORDER, int WAIT_TIME>int
showLedData(volatile uint32_t *_port, uint32_t _bitmask, const uint8_t *_leds, uint32_t num_leds, struct M0ClocklessData *pData) {
// Lo register variables
REGISTER uint32_t scratch=0;
REGISTER struct M0ClocklessData *base = pData;
REGISTER volatile uint32_t *port = _port;
REGISTER uint32_t d=0;
REGISTER uint32_t counter=num_leds;
REGISTER uint32_t bn=0;
REGISTER uint32_t b=0;
REGISTER uint32_t bitmask = _bitmask;
FASTLED_REGISTER uint32_t scratch=0;
FASTLED_REGISTER struct M0ClocklessData *base = pData;
FASTLED_REGISTER volatile uint32_t *port = _port;
FASTLED_REGISTER uint32_t d=0;
FASTLED_REGISTER uint32_t counter=num_leds;
FASTLED_REGISTER uint32_t bn=0;
FASTLED_REGISTER uint32_t b=0;
FASTLED_REGISTER uint32_t bitmask = _bitmask;
// high register variable
REGISTER const uint8_t *leds = _leds;
FASTLED_REGISTER const uint8_t *leds = _leds;
#if (FASTLED_SCALE8_FIXED == 1)
++pData->s[0];
++pData->s[1];

8
src/platforms/arm/d21/fastpin_arm_d21.h
View File

@ -36,15 +36,15 @@ public:
inline static void hi() __attribute__ ((always_inline)) { PORT_IOBUS->Group[_GRP].OUTSET.reg = _MASK; }
inline static void lo() __attribute__ ((always_inline)) { PORT_IOBUS->Group[_GRP].OUTCLR.reg = _MASK; }
inline static void set(REGISTER port_t val) __attribute__ ((always_inline)) { PORT_IOBUS->Group[_GRP].OUT.reg = val; }
inline static void set(FASTLED_REGISTER port_t val) __attribute__ ((always_inline)) { PORT_IOBUS->Group[_GRP].OUT.reg = val; }
inline static void strobe() __attribute__ ((always_inline)) { toggle(); toggle(); }
inline static void toggle() __attribute__ ((always_inline)) { PORT_IOBUS->Group[_GRP].OUTTGL.reg = _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 void hi(FASTLED_REGISTER port_ptr_t port) __attribute__ ((always_inline)) { hi(); }
inline static void lo(FASTLED_REGISTER port_ptr_t port) __attribute__ ((always_inline)) { lo(); }
inline static void fastset(FASTLED_REGISTER port_ptr_t port, FASTLED_REGISTER port_t val) __attribute__ ((always_inline)) { *port = val; }
inline static port_t hival() __attribute__ ((always_inline)) { return PORT_IOBUS->Group[_GRP].OUT.reg | _MASK; }
inline static port_t loval() __attribute__ ((always_inline)) { return PORT_IOBUS->Group[_GRP].OUT.reg & ~_MASK; }

12
src/platforms/arm/d51/clockless_arm_d51.h
View File

@ -42,8 +42,8 @@ protected:
mWait.mark();
}
template<int BITS> __attribute__ ((always_inline)) inline static void writeBits(REGISTER uint32_t & next_mark, REGISTER data_ptr_t port, REGISTER data_t hi, REGISTER data_t lo, REGISTER uint8_t & b) {
for(REGISTER uint32_t i = BITS-1; i > 0; --i) {
template<int BITS> __attribute__ ((always_inline)) inline static void writeBits(FASTLED_REGISTER uint32_t & next_mark, FASTLED_REGISTER data_ptr_t port, FASTLED_REGISTER data_t hi, FASTLED_REGISTER data_t lo, FASTLED_REGISTER uint8_t & b) {
for(FASTLED_REGISTER uint32_t i = BITS-1; i > 0; --i) {
while(ARM_DWT_CYCCNT < next_mark);
next_mark = ARM_DWT_CYCCNT + (T1+T2+T3);
FastPin<DATA_PIN>::fastset(port, hi);
@ -78,14 +78,14 @@ protected:
ARM_DWT_CTRL |= ARM_DWT_CTRL_CYCCNTENA;
ARM_DWT_CYCCNT = 0;
REGISTER data_ptr_t port = FastPin<DATA_PIN>::port();
REGISTER data_t hi = *port | FastPin<DATA_PIN>::mask();
REGISTER data_t lo = *port & ~FastPin<DATA_PIN>::mask();
FASTLED_REGISTER data_ptr_t port = FastPin<DATA_PIN>::port();
FASTLED_REGISTER data_t hi = *port | FastPin<DATA_PIN>::mask();
FASTLED_REGISTER data_t lo = *port & ~FastPin<DATA_PIN>::mask();
*port = lo;
// Setup the pixel controller and load/scale the first byte
pixels.preStepFirstByteDithering();
REGISTER uint8_t b = pixels.loadAndScale0();
FASTLED_REGISTER uint8_t b = pixels.loadAndScale0();
cli();
uint32_t next_mark = ARM_DWT_CYCCNT + (T1+T2+T3);

8
src/platforms/arm/d51/fastpin_arm_d51.h
View File

@ -36,15 +36,15 @@ public:
inline static void hi() __attribute__ ((always_inline)) { PORT->Group[_GRP].OUTSET.reg = _MASK; }
inline static void lo() __attribute__ ((always_inline)) { PORT->Group[_GRP].OUTCLR.reg = _MASK; }
inline static void set(REGISTER port_t val) __attribute__ ((always_inline)) { PORT->Group[_GRP].OUT.reg = val; }
inline static void set(FASTLED_REGISTER port_t val) __attribute__ ((always_inline)) { PORT->Group[_GRP].OUT.reg = val; }
inline static void strobe() __attribute__ ((always_inline)) { toggle(); toggle(); }
inline static void toggle() __attribute__ ((always_inline)) { PORT->Group[_GRP].OUTTGL.reg = _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 void hi(FASTLED_REGISTER port_ptr_t port) __attribute__ ((always_inline)) { hi(); }
inline static void lo(FASTLED_REGISTER port_ptr_t port) __attribute__ ((always_inline)) { lo(); }
inline static void fastset(FASTLED_REGISTER port_ptr_t port, FASTLED_REGISTER port_t val) __attribute__ ((always_inline)) { *port = val; }
inline static port_t hival() __attribute__ ((always_inline)) { return PORT->Group[_GRP].OUT.reg | _MASK; }
inline static port_t loval() __attribute__ ((always_inline)) { return PORT->Group[_GRP].OUT.reg & ~_MASK; }

12
src/platforms/arm/k20/clockless_arm_k20.h
View File

@ -37,8 +37,8 @@ protected:
mWait.mark();
}
template<int BITS> __attribute__ ((always_inline)) inline static void writeBits(REGISTER uint32_t & next_mark, REGISTER data_ptr_t port, REGISTER data_t hi, REGISTER data_t lo, REGISTER uint8_t & b) {
for(REGISTER uint32_t i = BITS-1; i > 0; --i) {
template<int BITS> __attribute__ ((always_inline)) inline static void writeBits(FASTLED_REGISTER uint32_t & next_mark, FASTLED_REGISTER data_ptr_t port, FASTLED_REGISTER data_t hi, FASTLED_REGISTER data_t lo, FASTLED_REGISTER uint8_t & b) {
for(FASTLED_REGISTER uint32_t i = BITS-1; i > 0; --i) {
while(ARM_DWT_CYCCNT < next_mark);
next_mark = ARM_DWT_CYCCNT + (T1+T2+T3);
FastPin<DATA_PIN>::fastset(port, hi);
@ -73,14 +73,14 @@ protected:
ARM_DWT_CTRL |= ARM_DWT_CTRL_CYCCNTENA;
ARM_DWT_CYCCNT = 0;
REGISTER data_ptr_t port = FastPin<DATA_PIN>::port();
REGISTER data_t hi = *port | FastPin<DATA_PIN>::mask();
REGISTER data_t lo = *port & ~FastPin<DATA_PIN>::mask();
FASTLED_REGISTER data_ptr_t port = FastPin<DATA_PIN>::port();
FASTLED_REGISTER data_t hi = *port | FastPin<DATA_PIN>::mask();
FASTLED_REGISTER data_t lo = *port & ~FastPin<DATA_PIN>::mask();
*port = lo;
// Setup the pixel controller and load/scale the first byte
pixels.preStepFirstByteDithering();
REGISTER uint8_t b = pixels.loadAndScale0();
FASTLED_REGISTER uint8_t b = pixels.loadAndScale0();
cli();
uint32_t next_mark = ARM_DWT_CYCCNT + (T1+T2+T3);

26
src/platforms/arm/k20/clockless_block_arm_k20.h
View File

@ -83,18 +83,18 @@ public:
uint32_t raw[3];
} Lines;
template<int BITS,int PX> __attribute__ ((always_inline)) inline static void writeBits(REGISTER uint32_t & next_mark, REGISTER Lines & b, PixelController<RGB_ORDER, LANES, PORT_MASK> &pixels) { // , REGISTER uint32_t & b2) {
REGISTER Lines b2;
template<int BITS,int PX> __attribute__ ((always_inline)) inline static void writeBits(FASTLED_REGISTER uint32_t & next_mark, FASTLED_REGISTER Lines & b, PixelController<RGB_ORDER, LANES, PORT_MASK> &pixels) { // , FASTLED_REGISTER uint32_t & b2) {
FASTLED_REGISTER Lines b2;
if(USED_LANES>8) {
transpose8<1,2>(b.bytes,b2.bytes);
transpose8<1,2>(b.bytes+8,b2.bytes+1);
} else {
transpose8x1(b.bytes,b2.bytes);
}
REGISTER uint8_t d = pixels.template getd<PX>(pixels);
REGISTER uint8_t scale = pixels.template getscale<PX>(pixels);
FASTLED_REGISTER uint8_t d = pixels.template getd<PX>(pixels);
FASTLED_REGISTER uint8_t scale = pixels.template getscale<PX>(pixels);
for(REGISTER uint32_t i = 0; i < (USED_LANES/2); ++i) {
for(FASTLED_REGISTER uint32_t i = 0; i < (USED_LANES/2); ++i) {
while(ARM_DWT_CYCCNT < next_mark);
next_mark = ARM_DWT_CYCCNT + (T1+T2+T3)-3;
*FastPin<FIRST_PIN>::sport() = PORT_MASK;
@ -118,7 +118,7 @@ public:
b.bytes[USED_LANES-1] = pixels.template loadAndScale<PX>(pixels,USED_LANES-1,d,scale);
}
for(REGISTER uint32_t i = USED_LANES/2; i < 8; ++i) {
for(FASTLED_REGISTER uint32_t i = USED_LANES/2; i < 8; ++i) {
while(ARM_DWT_CYCCNT < next_mark);
next_mark = ARM_DWT_CYCCNT + (T1+T2+T3)-3;
*FastPin<FIRST_PIN>::sport() = PORT_MASK;
@ -148,7 +148,7 @@ public:
// Setup the pixel controller and load/scale the first byte
allpixels.preStepFirstByteDithering();
REGISTER Lines b0;
FASTLED_REGISTER Lines b0;
allpixels.preStepFirstByteDithering();
for(int i = 0; i < USED_LANES; ++i) {
@ -245,14 +245,14 @@ public:
uint32_t raw[4];
} Lines;
template<int BITS,int PX> __attribute__ ((always_inline)) inline static void writeBits(REGISTER uint32_t & next_mark, REGISTER Lines & b, PixelController<RGB_ORDER,LANES, PMASK> &pixels) { // , REGISTER uint32_t & b2) {
REGISTER Lines b2;
template<int BITS,int PX> __attribute__ ((always_inline)) inline static void writeBits(FASTLED_REGISTER uint32_t & next_mark, FASTLED_REGISTER Lines & b, PixelController<RGB_ORDER,LANES, PMASK> &pixels) { // , FASTLED_REGISTER uint32_t & b2) {
FASTLED_REGISTER Lines b2;
transpose8x1(b.bytes,b2.bytes);
transpose8x1(b.bytes+8,b2.bytes+8);
REGISTER uint8_t d = pixels.template getd<PX>(pixels);
REGISTER uint8_t scale = pixels.template getscale<PX>(pixels);
FASTLED_REGISTER uint8_t d = pixels.template getd<PX>(pixels);
FASTLED_REGISTER uint8_t scale = pixels.template getscale<PX>(pixels);
for(REGISTER uint32_t i = 0; (i < LANES) && (i < 8); ++i) {
for(FASTLED_REGISTER uint32_t i = 0; (i < LANES) && (i < 8); ++i) {
while(ARM_DWT_CYCCNT < next_mark);
next_mark = ARM_DWT_CYCCNT + (T1+T2+T3)-3;
*FastPin<PORTD_FIRST_PIN>::sport() = PMASK_LO;
@ -285,7 +285,7 @@ public:
// Setup the pixel controller and load/scale the first byte
allpixels.preStepFirstByteDithering();
REGISTER Lines b0;
FASTLED_REGISTER Lines b0;
allpixels.preStepFirstByteDithering();
for(int i = 0; i < LANES; ++i) {

16
src/platforms/arm/k20/fastpin_arm_k20.h
View File

@ -25,15 +25,15 @@ public:
inline static void hi() __attribute__ ((always_inline)) { _PSOR::r() = _MASK; }
inline static void lo() __attribute__ ((always_inline)) { _PCOR::r() = _MASK; }
inline static void set(REGISTER port_t val) __attribute__ ((always_inline)) { _PDOR::r() = val; }
inline static void set(FASTLED_REGISTER port_t val) __attribute__ ((always_inline)) { _PDOR::r() = val; }
inline static void strobe() __attribute__ ((always_inline)) { toggle(); toggle(); }
inline static void toggle() __attribute__ ((always_inline)) { _PTOR::r() = _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 void hi(FASTLED_REGISTER port_ptr_t port) __attribute__ ((always_inline)) { hi(); }
inline static void lo(FASTLED_REGISTER port_ptr_t port) __attribute__ ((always_inline)) { lo(); }
inline static void fastset(FASTLED_REGISTER port_ptr_t port, FASTLED_REGISTER port_t val) __attribute__ ((always_inline)) { *port = val; }
inline static port_t hival() __attribute__ ((always_inline)) { return _PDOR::r() | _MASK; }
inline static port_t loval() __attribute__ ((always_inline)) { return _PDOR::r() & ~_MASK; }
@ -55,15 +55,15 @@ public:
inline static void hi() __attribute__ ((always_inline)) { *_PDOR::template rx<_BIT>() = 1; }
inline static void lo() __attribute__ ((always_inline)) { *_PDOR::template rx<_BIT>() = 0; }
inline static void set(REGISTER port_t val) __attribute__ ((always_inline)) { *_PDOR::template rx<_BIT>() = val; }
inline static void set(FASTLED_REGISTER port_t val) __attribute__ ((always_inline)) { *_PDOR::template rx<_BIT>() = val; }
inline static void strobe() __attribute__ ((always_inline)) { toggle(); toggle(); }
inline static void toggle() __attribute__ ((always_inline)) { *_PTOR::template rx<_BIT>() = 1; }
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)) { *_PDOR::template rx<_BIT>() = val; }
inline static void hi(FASTLED_REGISTER port_ptr_t port) __attribute__ ((always_inline)) { hi(); }
inline static void lo(FASTLED_REGISTER port_ptr_t port) __attribute__ ((always_inline)) { lo(); }
inline static void fastset(FASTLED_REGISTER port_ptr_t port, FASTLED_REGISTER port_t val) __attribute__ ((always_inline)) { *_PDOR::template rx<_BIT>() = val; }
inline static port_t hival() __attribute__ ((always_inline)) { return 1; }
inline static port_t loval() __attribute__ ((always_inline)) { return 0; }

4
src/platforms/arm/k20/fastspi_arm_k20.h
View File

@ -389,7 +389,7 @@ public:
}
// Write a block of n uint8_ts out
template <class D> void writeBytes(REGISTER uint8_t *data, int len) {
template <class D> void writeBytes(FASTLED_REGISTER uint8_t *data, int len) {
uint8_t *end = data + len;
select();
// could be optimized to write 16bit words out instead of 8bit bytes
@ -401,7 +401,7 @@ public:
release();
}
void writeBytes(REGISTER uint8_t *data, int len) { writeBytes<DATA_NOP>(data, len); }
void writeBytes(FASTLED_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 and/or end of each grouping

12
src/platforms/arm/k66/clockless_arm_k66.h
View File

@ -37,8 +37,8 @@ protected:
mWait.mark();
}
template<int BITS> __attribute__ ((always_inline)) inline static void writeBits(REGISTER uint32_t & next_mark, REGISTER data_ptr_t port, REGISTER data_t hi, REGISTER data_t lo, REGISTER uint8_t & b) {
for(REGISTER uint32_t i = BITS-1; i > 0; --i) {
template<int BITS> __attribute__ ((always_inline)) inline static void writeBits(FASTLED_REGISTER uint32_t & next_mark, FASTLED_REGISTER data_ptr_t port, FASTLED_REGISTER data_t hi, FASTLED_REGISTER data_t lo, FASTLED_REGISTER uint8_t & b) {
for(FASTLED_REGISTER uint32_t i = BITS-1; i > 0; --i) {
while(ARM_DWT_CYCCNT < next_mark);
next_mark = ARM_DWT_CYCCNT + (T1+T2+T3);
FastPin<DATA_PIN>::fastset(port, hi);
@ -73,14 +73,14 @@ protected:
ARM_DWT_CTRL |= ARM_DWT_CTRL_CYCCNTENA;
ARM_DWT_CYCCNT = 0;
REGISTER data_ptr_t port = FastPin<DATA_PIN>::port();
REGISTER data_t hi = *port | FastPin<DATA_PIN>::mask();
REGISTER data_t lo = *port & ~FastPin<DATA_PIN>::mask();
FASTLED_REGISTER data_ptr_t port = FastPin<DATA_PIN>::port();
FASTLED_REGISTER data_t hi = *port | FastPin<DATA_PIN>::mask();
FASTLED_REGISTER data_t lo = *port & ~FastPin<DATA_PIN>::mask();
*port = lo;
// Setup the pixel controller and load/scale the first byte
pixels.preStepFirstByteDithering();
REGISTER uint8_t b = pixels.loadAndScale0();
FASTLED_REGISTER uint8_t b = pixels.loadAndScale0();
cli();
uint32_t next_mark = ARM_DWT_CYCCNT + (T1+T2+T3);

26
src/platforms/arm/k66/clockless_block_arm_k66.h
View File

@ -97,18 +97,18 @@ public:
uint32_t raw[3];
} Lines;
template<int BITS,int PX> __attribute__ ((always_inline)) inline static void writeBits(REGISTER uint32_t & next_mark, REGISTER Lines & b, PixelController<RGB_ORDER, LANES, LANE_MASK> &pixels) { // , REGISTER uint32_t & b2) {
REGISTER Lines b2;
template<int BITS,int PX> __attribute__ ((always_inline)) inline static void writeBits(FASTLED_REGISTER uint32_t & next_mark, FASTLED_REGISTER Lines & b, PixelController<RGB_ORDER, LANES, LANE_MASK> &pixels) { // , FASTLED_REGISTER uint32_t & b2) {
FASTLED_REGISTER Lines b2;
if(USED_LANES>8) {
transpose8<1,2>(b.bytes,b2.bytes);
transpose8<1,2>(b.bytes+8,b2.bytes+1);
} else {
transpose8x1(b.bytes,b2.bytes);
}
REGISTER uint8_t d = pixels.template getd<PX>(pixels);
REGISTER uint8_t scale = pixels.template getscale<PX>(pixels);
FASTLED_REGISTER uint8_t d = pixels.template getd<PX>(pixels);
FASTLED_REGISTER uint8_t scale = pixels.template getscale<PX>(pixels);
for(REGISTER uint32_t i = 0; i < (USED_LANES/2); ++i) {
for(FASTLED_REGISTER uint32_t i = 0; i < (USED_LANES/2); ++i) {
while(ARM_DWT_CYCCNT < next_mark);
next_mark = ARM_DWT_CYCCNT + (T1+T2+T3)-3;
*FastPin<FIRST_PIN>::sport() = PORT_MASK;
@ -132,7 +132,7 @@ public:
b.bytes[USED_LANES-1] = pixels.template loadAndScale<PX>(pixels,USED_LANES-1,d,scale);
}
for(REGISTER uint32_t i = USED_LANES/2; i < 8; ++i) {
for(FASTLED_REGISTER uint32_t i = USED_LANES/2; i < 8; ++i) {
while(ARM_DWT_CYCCNT < next_mark);
next_mark = ARM_DWT_CYCCNT + (T1+T2+T3)-3;
*FastPin<FIRST_PIN>::sport() = PORT_MASK;
@ -162,7 +162,7 @@ public:
// Setup the pixel controller and load/scale the first byte
allpixels.preStepFirstByteDithering();
REGISTER Lines b0;
FASTLED_REGISTER Lines b0;
allpixels.preStepFirstByteDithering();
for(int i = 0; i < USED_LANES; ++i) {
@ -259,14 +259,14 @@ public:
uint32_t raw[4];
} Lines;
template<int BITS,int PX> __attribute__ ((always_inline)) inline static void writeBits(REGISTER uint32_t & next_mark, REGISTER Lines & b, PixelController<RGB_ORDER,LANES, PMASK> &pixels) { // , REGISTER uint32_t & b2) {
REGISTER Lines b2;
template<int BITS,int PX> __attribute__ ((always_inline)) inline static void writeBits(FASTLED_REGISTER uint32_t & next_mark, FASTLED_REGISTER Lines & b, PixelController<RGB_ORDER,LANES, PMASK> &pixels) { // , FASTLED_REGISTER uint32_t & b2) {
FASTLED_REGISTER Lines b2;
transpose8x1(b.bytes,b2.bytes);
transpose8x1(b.bytes+8,b2.bytes+8);
REGISTER uint8_t d = pixels.template getd<PX>(pixels);
REGISTER uint8_t scale = pixels.template getscale<PX>(pixels);
FASTLED_REGISTER uint8_t d = pixels.template getd<PX>(pixels);
FASTLED_REGISTER uint8_t scale = pixels.template getscale<PX>(pixels);
for(REGISTER uint32_t i = 0; (i < LANES) && (i < 8); ++i) {
for(FASTLED_REGISTER uint32_t i = 0; (i < LANES) && (i < 8); ++i) {
while(ARM_DWT_CYCCNT < next_mark);
next_mark = ARM_DWT_CYCCNT + (T1+T2+T3)-3;
*FastPin<PORTD_FIRST_PIN>::sport() = PMASK_LO;
@ -298,7 +298,7 @@ public:
// Setup the pixel controller and load/scale the first byte
allpixels.preStepFirstByteDithering();
REGISTER Lines b0;
FASTLED_REGISTER Lines b0;
allpixels.preStepFirstByteDithering();
for(int i = 0; i < LANES; ++i) {

16
src/platforms/arm/k66/fastpin_arm_k66.h
View File

@ -25,15 +25,15 @@ public:
inline static void hi() __attribute__ ((always_inline)) { _PSOR::r() = _MASK; }
inline static void lo() __attribute__ ((always_inline)) { _PCOR::r() = _MASK; }
inline static void set(REGISTER port_t val) __attribute__ ((always_inline)) { _PDOR::r() = val; }
inline static void set(FASTLED_REGISTER port_t val) __attribute__ ((always_inline)) { _PDOR::r() = val; }
inline static void strobe() __attribute__ ((always_inline)) { toggle(); toggle(); }
inline static void toggle() __attribute__ ((always_inline)) { _PTOR::r() = _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 void hi(FASTLED_REGISTER port_ptr_t port) __attribute__ ((always_inline)) { hi(); }
inline static void lo(FASTLED_REGISTER port_ptr_t port) __attribute__ ((always_inline)) { lo(); }
inline static void fastset(FASTLED_REGISTER port_ptr_t port, FASTLED_REGISTER port_t val) __attribute__ ((always_inline)) { *port = val; }
inline static port_t hival() __attribute__ ((always_inline)) { return _PDOR::r() | _MASK; }
inline static port_t loval() __attribute__ ((always_inline)) { return _PDOR::r() & ~_MASK; }
@ -55,15 +55,15 @@ public:
inline static void hi() __attribute__ ((always_inline)) { *_PDOR::template rx<_BIT>() = 1; }
inline static void lo() __attribute__ ((always_inline)) { *_PDOR::template rx<_BIT>() = 0; }
inline static void set(REGISTER port_t val) __attribute__ ((always_inline)) { *_PDOR::template rx<_BIT>() = val; }
inline static void set(FASTLED_REGISTER port_t val) __attribute__ ((always_inline)) { *_PDOR::template rx<_BIT>() = val; }
inline static void strobe() __attribute__ ((always_inline)) { toggle(); toggle(); }
inline static void toggle() __attribute__ ((always_inline)) { *_PTOR::template rx<_BIT>() = 1; }
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)) { *_PDOR::template rx<_BIT>() = val; }
inline static void hi(FASTLED_REGISTER port_ptr_t port) __attribute__ ((always_inline)) { hi(); }
inline static void lo(FASTLED_REGISTER port_ptr_t port) __attribute__ ((always_inline)) { lo(); }
inline static void fastset(FASTLED_REGISTER port_ptr_t port, FASTLED_REGISTER port_t val) __attribute__ ((always_inline)) { *_PDOR::template rx<_BIT>() = val; }
inline static port_t hival() __attribute__ ((always_inline)) { return 1; }
inline static port_t loval() __attribute__ ((always_inline)) { return 0; }

4
src/platforms/arm/k66/fastspi_arm_k66.h
View File

@ -393,7 +393,7 @@ public:
}
// Write a block of n uint8_ts out
template <class D> void writeBytes(REGISTER uint8_t *data, int len) {
template <class D> void writeBytes(FASTLED_REGISTER uint8_t *data, int len) {
uint8_t *end = data + len;
select();
// could be optimized to write 16bit words out instead of 8bit bytes
@ -405,7 +405,7 @@ public:
release();
}
void writeBytes(REGISTER uint8_t *data, int len) { writeBytes<DATA_NOP>(data, len); }
void writeBytes(FASTLED_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 and/or end of each grouping

8
src/platforms/arm/kl26/fastpin_arm_kl26.h
View File

@ -25,15 +25,15 @@ public:
inline static void hi() __attribute__ ((always_inline)) { _PSOR::r() = _MASK; }
inline static void lo() __attribute__ ((always_inline)) { _PCOR::r() = _MASK; }
inline static void set(REGISTER port_t val) __attribute__ ((always_inline)) { _PDOR::r() = val; }
inline static void set(FASTLED_REGISTER port_t val) __attribute__ ((always_inline)) { _PDOR::r() = val; }
inline static void strobe() __attribute__ ((always_inline)) { toggle(); toggle(); }
inline static void toggle() __attribute__ ((always_inline)) { _PTOR::r() = _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 void hi(FASTLED_REGISTER port_ptr_t port) __attribute__ ((always_inline)) { hi(); }
inline static void lo(FASTLED_REGISTER port_ptr_t port) __attribute__ ((always_inline)) { lo(); }
inline static void fastset(FASTLED_REGISTER port_ptr_t port, FASTLED_REGISTER port_t val) __attribute__ ((always_inline)) { *port = val; }
inline static port_t hival() __attribute__ ((always_inline)) { return _PDOR::r() | _MASK; }
inline static port_t loval() __attribute__ ((always_inline)) { return _PDOR::r() & ~_MASK; }

4
src/platforms/arm/kl26/fastspi_arm_kl26.h
View File

@ -206,7 +206,7 @@ public:
}
// A full cycle of writing a raw block of data out, including select, release, and waiting
template <class D> void writeBytes(REGISTER uint8_t *data, int len) {
template <class D> void writeBytes(FASTLED_REGISTER uint8_t *data, int len) {
setSPIRate();
uint8_t *end = data + len;
select();
@ -219,7 +219,7 @@ public:
release();
}
void writeBytes(REGISTER uint8_t *data, int len) { writeBytes<DATA_NOP>(data, len); }
void writeBytes(FASTLED_REGISTER uint8_t *data, int len) { writeBytes<DATA_NOP>(data, len); }
template <uint8_t FLAGS, class D, EOrder RGB_ORDER> void writePixels(PixelController<RGB_ORDER> pixels) {

6
src/platforms/arm/mxrt1062/block_clockless_arm_mxrt1062.h
View File

@ -116,15 +116,15 @@ public:
} _outlines;
template<int BITS,int PX> __attribute__ ((always_inline)) inline void writeBits(REGISTER uint32_t & next_mark, REGISTER _outlines & b, PixelController<RGB_ORDER, LANES, __FL_T4_MASK> &pixels) {
template<int BITS,int PX> __attribute__ ((always_inline)) inline void writeBits(FASTLED_REGISTER uint32_t & next_mark, FASTLED_REGISTER _outlines & b, PixelController<RGB_ORDER, LANES, __FL_T4_MASK> &pixels) {
_outlines b2;
transpose8x1(b.bg[3], b2.bg[3]);
transpose8x1(b.bg[2], b2.bg[2]);
transpose8x1(b.bg[1], b2.bg[1]);
transpose8x1(b.bg[0], b2.bg[0]);
REGISTER uint8_t d = pixels.template getd<PX>(pixels);
REGISTER uint8_t scale = pixels.template getscale<PX>(pixels);
FASTLED_REGISTER uint8_t d = pixels.template getd<PX>(pixels);
FASTLED_REGISTER uint8_t scale = pixels.template getscale<PX>(pixels);
int x = 0;
for(uint32_t i = 8; i > 0;) {

6
src/platforms/arm/mxrt1062/clockless_arm_mxrt1062.h
View File

@ -50,8 +50,8 @@ protected:
mWait.mark();
}
template<int BITS> __attribute__ ((always_inline)) inline void writeBits(REGISTER uint32_t & next_mark, REGISTER uint32_t & b) {
for(REGISTER uint32_t i = BITS-1; i > 0; --i) {
template<int BITS> __attribute__ ((always_inline)) inline void writeBits(FASTLED_REGISTER uint32_t & next_mark, FASTLED_REGISTER uint32_t & b) {
for(FASTLED_REGISTER uint32_t i = BITS-1; i > 0; --i) {
while(ARM_DWT_CYCCNT < next_mark);
next_mark = ARM_DWT_CYCCNT + off[0];
FastPin<DATA_PIN>::hi();
@ -83,7 +83,7 @@ protected:
// Setup the pixel controller and load/scale the first byte
pixels.preStepFirstByteDithering();
REGISTER uint32_t b = pixels.loadAndScale0();
FASTLED_REGISTER uint32_t b = pixels.loadAndScale0();
cli();

8
src/platforms/arm/mxrt1062/fastpin_arm_mxrt1062.h
View File

@ -23,15 +23,15 @@ public:
inline static void hi() __attribute__ ((always_inline)) { _GPIO_DR_SET::r() = _MASK; }
inline static void lo() __attribute__ ((always_inline)) { _GPIO_DR_CLEAR::r() = _MASK; }
inline static void set(REGISTER port_t val) __attribute__ ((always_inline)) { _GPIO_DR::r() = val; }
inline static void set(FASTLED_REGISTER port_t val) __attribute__ ((always_inline)) { _GPIO_DR::r() = val; }
inline static void strobe() __attribute__ ((always_inline)) { toggle(); toggle(); }
inline static void toggle() __attribute__ ((always_inline)) { _GPIO_DR_TOGGLE::r() = _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 void hi(FASTLED_REGISTER port_ptr_t port) __attribute__ ((always_inline)) { hi(); }
inline static void lo(FASTLED_REGISTER port_ptr_t port) __attribute__ ((always_inline)) { lo(); }
inline static void fastset(FASTLED_REGISTER port_ptr_t port, FASTLED_REGISTER port_t val) __attribute__ ((always_inline)) { *port = val; }
inline static port_t hival() __attribute__ ((always_inline)) { return _GPIO_DR::r() | _MASK; }
inline static port_t loval() __attribute__ ((always_inline)) { return _GPIO_DR::r() & ~_MASK; }

6
src/platforms/arm/mxrt1062/fastspi_arm_mxrt1062.h
View File

@ -82,7 +82,7 @@ public:
}
// 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) {
template <class D> void writeBytes(FASTLED_REGISTER uint8_t *data, int len) {
uint8_t *end = data + len;
select();
// could be optimized to write 16bit words out instead of 8bit bytes
@ -95,13 +95,13 @@ public:
}
// 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); }
void writeBytes(FASTLED_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 void writeBit(uint8_t b) {
m_bitData = (m_bitData<<1) | ((b&(1<<BIT)) != 0);
// If this is the 8th bit we've collected, just write it out raw
REGISTER uint32_t bc = m_bitCount;
FASTLED_REGISTER uint32_t bc = m_bitCount;
bc = (bc + 1) & 0x07;
if (!bc) {
m_bitCount = 0;

16
src/platforms/arm/nrf51/fastpin_arm_nrf51.h
View File

@ -17,15 +17,15 @@ public:
inline static void hi() __attribute__ ((always_inline)) { _OUTSET::r() = _MASK; }
inline static void lo() __attribute__ ((always_inline)) { _OUTCLR::r() = _MASK; }
inline static void set(REGISTER port_t val) __attribute__ ((always_inline)) { _OUT::r() = val; }
inline static void set(FASTLED_REGISTER port_t val) __attribute__ ((always_inline)) { _OUT::r() = val; }
inline static void strobe() __attribute__ ((always_inline)) { toggle(); toggle(); }
inline static void toggle() __attribute__ ((always_inline)) { _OUT::r() ^= _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 void hi(FASTLED_REGISTER port_ptr_t port) __attribute__ ((always_inline)) { hi(); }
inline static void lo(FASTLED_REGISTER port_ptr_t port) __attribute__ ((always_inline)) { lo(); }
inline static void fastset(FASTLED_REGISTER port_ptr_t port, FASTLED_REGISTER port_t val) __attribute__ ((always_inline)) { *port = val; }
inline static port_t hival() __attribute__ ((always_inline)) { return _OUT::r() | _MASK; }
inline static port_t loval() __attribute__ ((always_inline)) { return _OUT::r() & ~_MASK; }
@ -79,15 +79,15 @@ public:
inline static void hi() __attribute__ ((always_inline)) { FL_NRF_GPIO->OUTSET = _MASK; }
inline static void lo() __attribute__ ((always_inline)) { FL_NRF_GPIO->OUTCLR= _MASK; }
inline static void set(REGISTER port_t val) __attribute__ ((always_inline)) { FL_NRF_GPIO->OUT = val; }
inline static void set(FASTLED_REGISTER port_t val) __attribute__ ((always_inline)) { FL_NRF_GPIO->OUT = val; }
inline static void strobe() __attribute__ ((always_inline)) { toggle(); toggle(); }
inline static void toggle() __attribute__ ((always_inline)) { FL_NRF_GPIO->OUT ^= _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 void hi(FASTLED_REGISTER port_ptr_t port) __attribute__ ((always_inline)) { hi(); }
inline static void lo(FASTLED_REGISTER port_ptr_t port) __attribute__ ((always_inline)) { lo(); }
inline static void fastset(FASTLED_REGISTER port_ptr_t port, FASTLED_REGISTER port_t val) __attribute__ ((always_inline)) { *port = val; }
inline static port_t hival() __attribute__ ((always_inline)) { return FL_NRF_GPIO->OUT | _MASK; }
inline static port_t loval() __attribute__ ((always_inline)) { return FL_NRF_GPIO->OUT & ~_MASK; }

8
src/platforms/arm/nrf52/fastpin_arm_nrf52.h
View File

@ -125,10 +125,10 @@ public:
FASTLED_NRF52_INLINE_ATTRIBUTE static port_ptr_t cport() { return &((reinterpret_cast<NRF_GPIO_Type*>(_PORT::r()))->OUTCLR); } // gets raw pointer to SET DIRECTION GPIO port
FASTLED_NRF52_INLINE_ATTRIBUTE static port_ptr_t sport() { return &((reinterpret_cast<NRF_GPIO_Type*>(_PORT::r()))->OUTSET); } // gets raw pointer to CLEAR DIRECTION GPIO port
FASTLED_NRF52_INLINE_ATTRIBUTE static port_t mask() { return _MASK; } // gets the value of _MASK
FASTLED_NRF52_INLINE_ATTRIBUTE static void hi (REGISTER port_ptr_t port) { hi(); } // sets _MASK in the SET OUTPUT register (output set high)
FASTLED_NRF52_INLINE_ATTRIBUTE static void lo (REGISTER port_ptr_t port) { lo(); } // sets _MASK in the CLEAR OUTPUT register (output set low)
FASTLED_NRF52_INLINE_ATTRIBUTE static void set(REGISTER port_t val ) { (reinterpret_cast<NRF_GPIO_Type*>(_PORT::r()))->OUT = val; } // sets entire port's value (optimization used by FastLED)
FASTLED_NRF52_INLINE_ATTRIBUTE static void fastset(REGISTER port_ptr_t port, REGISTER port_t val) { *port = val; }
FASTLED_NRF52_INLINE_ATTRIBUTE static void hi (FASTLED_REGISTER port_ptr_t port) { hi(); } // sets _MASK in the SET OUTPUT register (output set high)
FASTLED_NRF52_INLINE_ATTRIBUTE static void lo (FASTLED_REGISTER port_ptr_t port) { lo(); } // sets _MASK in the CLEAR OUTPUT register (output set low)
FASTLED_NRF52_INLINE_ATTRIBUTE static void set(FASTLED_REGISTER port_t val ) { (reinterpret_cast<NRF_GPIO_Type*>(_PORT::r()))->OUT = val; } // sets entire port's value (optimization used by FastLED)
FASTLED_NRF52_INLINE_ATTRIBUTE static void fastset(FASTLED_REGISTER port_ptr_t port, FASTLED_REGISTER port_t val) { *port = val; }
constexpr static uint32_t nrf_pin2() { return NRF_GPIO_PIN_MAP(_PORT_NUMBER, _PIN_NUMBER); }
constexpr static bool LowSpeedOnlyRecommended() {
// Caller must always determine if high speed use if allowed on a given pin,

8
src/platforms/arm/rp2040/fastpin_arm_rp2040.h
View File

@ -25,15 +25,15 @@ public:
inline static void hi() __attribute__ ((always_inline)) { sio_hw->gpio_set = _MASK; }
inline static void lo() __attribute__ ((always_inline)) { sio_hw->gpio_clr = _MASK; }
inline static void set(register port_t val) __attribute__ ((always_inline)) { sio_hw->gpio_out = val; }
inline static void set(FASTLED_REGISTER port_t val) __attribute__ ((always_inline)) { sio_hw->gpio_out = val; }
inline static void strobe() __attribute__ ((always_inline)) { toggle(); toggle(); }
inline static void toggle() __attribute__ ((always_inline)) { sio_hw->gpio_togl = _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 void hi(FASTLED_REGISTER port_ptr_t port) __attribute__ ((always_inline)) { hi(); }
inline static void lo(FASTLED_REGISTER port_ptr_t port) __attribute__ ((always_inline)) { lo(); }
inline static void fastset(FASTLED_REGISTER port_ptr_t port, FASTLED_REGISTER port_t val) __attribute__ ((always_inline)) { *port = val; }
inline static port_t hival() __attribute__ ((always_inline)) { return sio_hw->gpio_out | _MASK; }
inline static port_t loval() __attribute__ ((always_inline)) { return sio_hw->gpio_out & ~_MASK; }

6
src/platforms/arm/sam/clockless_arm_sam.h
View File

@ -42,13 +42,13 @@ protected:
mWait.mark();
}
template<int BITS> __attribute__ ((always_inline)) inline static void writeBits(REGISTER uint32_t & next_mark, REGISTER data_ptr_t port, REGISTER uint8_t & b) {
template<int BITS> __attribute__ ((always_inline)) inline static void writeBits(FASTLED_REGISTER uint32_t & next_mark, FASTLED_REGISTER data_ptr_t port, FASTLED_REGISTER uint8_t & b) {
// Make sure we don't slot into a wrapping spot, this will delay up to 12.5µs for WS2812
// bool bShift=0;
// while(VAL < (TOTAL*10)) { bShift=true; }
// if(bShift) { next_mark = (VAL-TOTAL); };
for(REGISTER uint32_t i = BITS; i > 0; --i) {
for(FASTLED_REGISTER uint32_t i = BITS; i > 0; --i) {
// wait to start the bit, then set the pin high
while(DUE_TIMER_VAL < next_mark);
next_mark = (DUE_TIMER_VAL+TOTAL);
@ -76,7 +76,7 @@ protected:
pmc_enable_periph_clk(DUE_TIMER_ID);
TC_Start(DUE_TIMER,DUE_TIMER_CHANNEL);
REGISTER data_ptr_t port asm("r7") = FastPinBB<DATA_PIN>::port(); FORCE_REFERENCE(port);
FASTLED_REGISTER data_ptr_t port asm("r7") = FastPinBB<DATA_PIN>::port(); FORCE_REFERENCE(port);
*port = 0;
// Setup the pixel controller and load/scale the first byte

6
src/platforms/arm/sam/clockless_block_arm_sam.h
View File

@ -140,12 +140,12 @@ public:
return DUE_TIMER_VAL;
}
template<int BITS,int PX> __attribute__ ((always_inline)) inline static void writeBits(REGISTER uint32_t & next_mark, REGISTER Lines & b, Lines & b3, PixelController<RGB_ORDER,LANES, PORT_MASK> &pixels) { // , REGISTER uint32_t & b2) {
template<int BITS,int PX> __attribute__ ((always_inline)) inline static void writeBits(FASTLED_REGISTER uint32_t & next_mark, FASTLED_REGISTER Lines & b, Lines & b3, PixelController<RGB_ORDER,LANES, PORT_MASK> &pixels) { // , FASTLED_REGISTER uint32_t & b2) {
Lines b2;
transpose8x1(b.bytes,b2.bytes);
REGISTER uint8_t d = pixels.template getd<PX>(pixels);
REGISTER uint8_t scale = pixels.template getscale<PX>(pixels);
FASTLED_REGISTER uint8_t d = pixels.template getd<PX>(pixels);
FASTLED_REGISTER uint8_t scale = pixels.template getscale<PX>(pixels);
for(uint32_t i = 0; (i < LANES) && (i<8); i++) {
while(DUE_TIMER_VAL < next_mark);

16
src/platforms/arm/sam/fastpin_arm_sam.h
View File

@ -25,15 +25,15 @@ public:
inline static void hi() __attribute__ ((always_inline)) { _PSOR::r() = _MASK; }
inline static void lo() __attribute__ ((always_inline)) { _PCOR::r() = _MASK; }
inline static void set(REGISTER port_t val) __attribute__ ((always_inline)) { _PDOR::r() = val; }
inline static void set(FASTLED_REGISTER port_t val) __attribute__ ((always_inline)) { _PDOR::r() = val; }
inline static void strobe() __attribute__ ((always_inline)) { toggle(); toggle(); }
inline static void toggle() __attribute__ ((always_inline)) { _PDOR::r() ^= _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 void hi(FASTLED_REGISTER port_ptr_t port) __attribute__ ((always_inline)) { hi(); }
inline static void lo(FASTLED_REGISTER port_ptr_t port) __attribute__ ((always_inline)) { lo(); }
inline static void fastset(FASTLED_REGISTER port_ptr_t port, FASTLED_REGISTER port_t val) __attribute__ ((always_inline)) { *port = val; }
inline static port_t hival() __attribute__ ((always_inline)) { return _PDOR::r() | _MASK; }
inline static port_t loval() __attribute__ ((always_inline)) { return _PDOR::r() & ~_MASK; }
@ -56,15 +56,15 @@ public:
inline static void hi() __attribute__ ((always_inline)) { *_PDOR::template rx<_BIT>() = 1; }
inline static void lo() __attribute__ ((always_inline)) { *_PDOR::template rx<_BIT>() = 0; }
inline static void set(REGISTER port_t val) __attribute__ ((always_inline)) { *_PDOR::template rx<_BIT>() = val; }
inline static void set(FASTLED_REGISTER port_t val) __attribute__ ((always_inline)) { *_PDOR::template rx<_BIT>() = val; }
inline static void strobe() __attribute__ ((always_inline)) { toggle(); toggle(); }
inline static void toggle() __attribute__ ((always_inline)) { *_PDOR::template rx<_BIT>() ^= 1; }
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 void hi(FASTLED_REGISTER port_ptr_t port) __attribute__ ((always_inline)) { hi(); }
inline static void lo(FASTLED_REGISTER port_ptr_t port) __attribute__ ((always_inline)) { lo(); }
inline static void fastset(FASTLED_REGISTER port_ptr_t port, FASTLED_REGISTER port_t val) __attribute__ ((always_inline)) { *port = val; }
inline static port_t hival() __attribute__ ((always_inline)) { return 1; }
inline static port_t loval() __attribute__ ((always_inline)) { return 0; }

6
src/platforms/arm/sam/fastspi_arm_sam.h
View File

@ -19,7 +19,7 @@ class SAMHardwareSPIOutput {
void disableSPI() { m_SPI->SPI_CR = SPI_CR_SPIDIS; }
void resetSPI() { m_SPI->SPI_CR = SPI_CR_SWRST; }
static inline void readyTransferBits(REGISTER uint32_t bits) {
static inline void readyTransferBits(FASTLED_REGISTER uint32_t bits) {
bits -= 8;
// don't change the number of transfer bits while data is still being transferred from TDR to the shift register
waitForEmpty();
@ -98,7 +98,7 @@ public:
select(); writeBytesValueRaw(value, len); release();
}
template <class D> void writeBytes(REGISTER uint8_t *data, int len) {
template <class D> void writeBytes(FASTLED_REGISTER uint8_t *data, int len) {
uint8_t *end = data + len;
select();
// could be optimized to write 16bit words out instead of 8bit bytes
@ -110,7 +110,7 @@ public:
release();
}
void writeBytes(REGISTER uint8_t *data, int len) { writeBytes<DATA_NOP>(data, len); }
void writeBytes(FASTLED_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
// not the most efficient mechanism in the world - but should be enough for sm16716 and friends

12
src/platforms/arm/stm32/clockless_arm_stm32.h
View File

@ -44,8 +44,8 @@ protected:
#define _CYCCNT (*(volatile uint32_t*)(0xE0001004UL))
template<int BITS> __attribute__ ((always_inline)) inline static void writeBits(REGISTER uint32_t & next_mark, REGISTER data_ptr_t port, REGISTER data_t hi, REGISTER data_t lo, REGISTER uint8_t & b) {
for(REGISTER uint32_t i = BITS-1; i > 0; --i) {
template<int BITS> __attribute__ ((always_inline)) inline static void writeBits(FASTLED_REGISTER uint32_t & next_mark, FASTLED_REGISTER data_ptr_t port, FASTLED_REGISTER data_t hi, FASTLED_REGISTER data_t lo, FASTLED_REGISTER uint8_t & b) {
for(FASTLED_REGISTER uint32_t i = BITS-1; i > 0; --i) {
while(_CYCCNT < (T1+T2+T3-ADJ));
FastPin<DATA_PIN>::fastset(port, hi);
_CYCCNT = 4;
@ -80,14 +80,14 @@ protected:
DWT->CTRL |= DWT_CTRL_CYCCNTENA_Msk;
DWT->CYCCNT = 0;
REGISTER data_ptr_t port = FastPin<DATA_PIN>::port();
REGISTER data_t hi = *port | FastPin<DATA_PIN>::mask();;
REGISTER data_t lo = *port & ~FastPin<DATA_PIN>::mask();;
FASTLED_REGISTER data_ptr_t port = FastPin<DATA_PIN>::port();
FASTLED_REGISTER data_t hi = *port | FastPin<DATA_PIN>::mask();;
FASTLED_REGISTER data_t lo = *port & ~FastPin<DATA_PIN>::mask();;
*port = lo;
// Setup the pixel controller and load/scale the first byte
pixels.preStepFirstByteDithering();
REGISTER uint8_t b = pixels.loadAndScale0();
FASTLED_REGISTER uint8_t b = pixels.loadAndScale0();
cli();

8
src/platforms/arm/stm32/fastpin_arm_stm32.h
View File

@ -43,15 +43,15 @@ public:
inline static void lo() __attribute__ ((always_inline)) { _GPIO::r()->BRR = _MASK; }
// inline static void lo() __attribute__ ((always_inline)) { _GPIO::r()->BSRR = (_MASK<<16); }
#endif
inline static void set(REGISTER port_t val) __attribute__ ((always_inline)) { _GPIO::r()->ODR = val; }
inline static void set(FASTLED_REGISTER port_t val) __attribute__ ((always_inline)) { _GPIO::r()->ODR = val; }
inline static void strobe() __attribute__ ((always_inline)) { toggle(); toggle(); }
inline static void toggle() __attribute__ ((always_inline)) { if(_GPIO::r()->ODR & _MASK) { lo(); } else { hi(); } }
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 void hi(FASTLED_REGISTER port_ptr_t port) __attribute__ ((always_inline)) { hi(); }
inline static void lo(FASTLED_REGISTER port_ptr_t port) __attribute__ ((always_inline)) { lo(); }
inline static void fastset(FASTLED_REGISTER port_ptr_t port, FASTLED_REGISTER port_t val) __attribute__ ((always_inline)) { *port = val; }
inline static port_t hival() __attribute__ ((always_inline)) { return _GPIO::r()->ODR | _MASK; }
inline static port_t loval() __attribute__ ((always_inline)) { return _GPIO::r()->ODR & ~_MASK; }

64
src/platforms/avr/clockless_trinket.h
View File

@ -25,9 +25,9 @@ FASTLED_NAMESPACE_BEGIN
#define US_PER_TICK (64 / (F_CPU/1000000))
// Variations on the functions in delay.h - w/a loop var passed in to preserve registers across calls by the optimizer/compiler
template<int CYCLES> inline void _dc(REGISTER uint8_t & loopvar);
template<int CYCLES> inline void _dc(FASTLED_REGISTER uint8_t & loopvar);
template<int _LOOP, int PAD> __attribute__((always_inline)) inline void _dc_AVR(REGISTER uint8_t & loopvar) {
template<int _LOOP, int PAD> __attribute__((always_inline)) inline void _dc_AVR(FASTLED_REGISTER uint8_t & loopvar) {
_dc<PAD>(loopvar);
// The convolution in here is to ensure that the state of the carry flag coming into the delay loop is preserved
asm __volatile__ ( "BRCS L_PC%=\n\t"
@ -38,40 +38,40 @@ template<int _LOOP, int PAD> __attribute__((always_inline)) inline void _dc_AVR(
[loopvar] "+a" (loopvar) : [_LOOP] "M" (_LOOP) : );
}
template<int CYCLES> __attribute__((always_inline)) inline void _dc(REGISTER uint8_t & loopvar) {
template<int CYCLES> __attribute__((always_inline)) inline void _dc(FASTLED_REGISTER uint8_t & loopvar) {
_dc_AVR<CYCLES/6,CYCLES%6>(loopvar);
}
template<> __attribute__((always_inline)) inline void _dc<-6>(REGISTER uint8_t & ) {}
template<> __attribute__((always_inline)) inline void _dc<-5>(REGISTER uint8_t & ) {}
template<> __attribute__((always_inline)) inline void _dc<-4>(REGISTER uint8_t & ) {}
template<> __attribute__((always_inline)) inline void _dc<-3>(REGISTER uint8_t & ) {}
template<> __attribute__((always_inline)) inline void _dc<-2>(REGISTER uint8_t & ) {}
template<> __attribute__((always_inline)) inline void _dc<-1>(REGISTER uint8_t & ) {}
template<> __attribute__((always_inline)) inline void _dc< 0>(REGISTER uint8_t & ) {}
template<> __attribute__((always_inline)) inline void _dc< 1>(REGISTER uint8_t & ) {asm __volatile__("mov r0,r0":::);}
template<> __attribute__((always_inline)) inline void _dc<-6>(FASTLED_REGISTER uint8_t & ) {}
template<> __attribute__((always_inline)) inline void _dc<-5>(FASTLED_REGISTER uint8_t & ) {}
template<> __attribute__((always_inline)) inline void _dc<-4>(FASTLED_REGISTER uint8_t & ) {}
template<> __attribute__((always_inline)) inline void _dc<-3>(FASTLED_REGISTER uint8_t & ) {}
template<> __attribute__((always_inline)) inline void _dc<-2>(FASTLED_REGISTER uint8_t & ) {}
template<> __attribute__((always_inline)) inline void _dc<-1>(FASTLED_REGISTER uint8_t & ) {}
template<> __attribute__((always_inline)) inline void _dc< 0>(FASTLED_REGISTER uint8_t & ) {}
template<> __attribute__((always_inline)) inline void _dc< 1>(FASTLED_REGISTER uint8_t & ) {asm __volatile__("mov r0,r0":::);}
#if defined(__LGT8F__)
template<> __attribute__((always_inline)) inline void _dc< 2>(REGISTER uint8_t & loopvar) { _dc<1>(loopvar); _dc<1>(loopvar); }
template<> __attribute__((always_inline)) inline void _dc< 2>(FASTLED_REGISTER uint8_t & loopvar) { _dc<1>(loopvar); _dc<1>(loopvar); }
#else
template<> __attribute__((always_inline)) inline void _dc< 2>(REGISTER uint8_t & ) {asm __volatile__("rjmp .+0":::);}
template<> __attribute__((always_inline)) inline void _dc< 2>(FASTLED_REGISTER uint8_t & ) {asm __volatile__("rjmp .+0":::);}
#endif
template<> __attribute__((always_inline)) inline void _dc< 3>(REGISTER uint8_t & loopvar) { _dc<2>(loopvar); _dc<1>(loopvar); }
template<> __attribute__((always_inline)) inline void _dc< 4>(REGISTER uint8_t & loopvar) { _dc<2>(loopvar); _dc<2>(loopvar); }
template<> __attribute__((always_inline)) inline void _dc< 5>(REGISTER uint8_t & loopvar) { _dc<2>(loopvar); _dc<3>(loopvar); }
template<> __attribute__((always_inline)) inline void _dc< 6>(REGISTER uint8_t & loopvar) { _dc<2>(loopvar); _dc<2>(loopvar); _dc<2>(loopvar);}
template<> __attribute__((always_inline)) inline void _dc< 7>(REGISTER uint8_t & loopvar) { _dc<4>(loopvar); _dc<3>(loopvar); }
template<> __attribute__((always_inline)) inline void _dc< 8>(REGISTER uint8_t & loopvar) { _dc<4>(loopvar); _dc<4>(loopvar); }
template<> __attribute__((always_inline)) inline void _dc< 9>(REGISTER uint8_t & loopvar) { _dc<5>(loopvar); _dc<4>(loopvar); }
template<> __attribute__((always_inline)) inline void _dc<10>(REGISTER uint8_t & loopvar) { _dc<6>(loopvar); _dc<4>(loopvar); }
template<> __attribute__((always_inline)) inline void _dc<11>(REGISTER uint8_t & loopvar) { _dc<10>(loopvar); _dc<1>(loopvar); }
template<> __attribute__((always_inline)) inline void _dc<12>(REGISTER uint8_t & loopvar) { _dc<10>(loopvar); _dc<2>(loopvar); }
template<> __attribute__((always_inline)) inline void _dc<13>(REGISTER uint8_t & loopvar) { _dc<10>(loopvar); _dc<3>(loopvar); }
template<> __attribute__((always_inline)) inline void _dc<14>(REGISTER uint8_t & loopvar) { _dc<10>(loopvar); _dc<4>(loopvar); }
template<> __attribute__((always_inline)) inline void _dc<15>(REGISTER uint8_t & loopvar) { _dc<10>(loopvar); _dc<5>(loopvar); }
template<> __attribute__((always_inline)) inline void _dc<16>(REGISTER uint8_t & loopvar) { _dc<10>(loopvar); _dc<6>(loopvar); }
template<> __attribute__((always_inline)) inline void _dc<17>(REGISTER uint8_t & loopvar) { _dc<10>(loopvar); _dc<7>(loopvar); }
template<> __attribute__((always_inline)) inline void _dc<18>(REGISTER uint8_t & loopvar) { _dc<10>(loopvar); _dc<8>(loopvar); }
template<> __attribute__((always_inline)) inline void _dc<19>(REGISTER uint8_t & loopvar) { _dc<10>(loopvar); _dc<9>(loopvar); }
template<> __attribute__((always_inline)) inline void _dc<20>(REGISTER uint8_t & loopvar) { _dc<10>(loopvar); _dc<10>(loopvar); }
template<> __attribute__((always_inline)) inline void _dc< 3>(FASTLED_REGISTER uint8_t & loopvar) { _dc<2>(loopvar); _dc<1>(loopvar); }
template<> __attribute__((always_inline)) inline void _dc< 4>(FASTLED_REGISTER uint8_t & loopvar) { _dc<2>(loopvar); _dc<2>(loopvar); }
template<> __attribute__((always_inline)) inline void _dc< 5>(FASTLED_REGISTER uint8_t & loopvar) { _dc<2>(loopvar); _dc<3>(loopvar); }
template<> __attribute__((always_inline)) inline void _dc< 6>(FASTLED_REGISTER uint8_t & loopvar) { _dc<2>(loopvar); _dc<2>(loopvar); _dc<2>(loopvar);}
template<> __attribute__((always_inline)) inline void _dc< 7>(FASTLED_REGISTER uint8_t & loopvar) { _dc<4>(loopvar); _dc<3>(loopvar); }
template<> __attribute__((always_inline)) inline void _dc< 8>(FASTLED_REGISTER uint8_t & loopvar) { _dc<4>(loopvar); _dc<4>(loopvar); }
template<> __attribute__((always_inline)) inline void _dc< 9>(FASTLED_REGISTER uint8_t & loopvar) { _dc<5>(loopvar); _dc<4>(loopvar); }
template<> __attribute__((always_inline)) inline void _dc<10>(FASTLED_REGISTER uint8_t & loopvar) { _dc<6>(loopvar); _dc<4>(loopvar); }
template<> __attribute__((always_inline)) inline void _dc<11>(FASTLED_REGISTER uint8_t & loopvar) { _dc<10>(loopvar); _dc<1>(loopvar); }
template<> __attribute__((always_inline)) inline void _dc<12>(FASTLED_REGISTER uint8_t & loopvar) { _dc<10>(loopvar); _dc<2>(loopvar); }
template<> __attribute__((always_inline)) inline void _dc<13>(FASTLED_REGISTER uint8_t & loopvar) { _dc<10>(loopvar); _dc<3>(loopvar); }
template<> __attribute__((always_inline)) inline void _dc<14>(FASTLED_REGISTER uint8_t & loopvar) { _dc<10>(loopvar); _dc<4>(loopvar); }
template<> __attribute__((always_inline)) inline void _dc<15>(FASTLED_REGISTER uint8_t & loopvar) { _dc<10>(loopvar); _dc<5>(loopvar); }
template<> __attribute__((always_inline)) inline void _dc<16>(FASTLED_REGISTER uint8_t & loopvar) { _dc<10>(loopvar); _dc<6>(loopvar); }
template<> __attribute__((always_inline)) inline void _dc<17>(FASTLED_REGISTER uint8_t & loopvar) { _dc<10>(loopvar); _dc<7>(loopvar); }
template<> __attribute__((always_inline)) inline void _dc<18>(FASTLED_REGISTER uint8_t & loopvar) { _dc<10>(loopvar); _dc<8>(loopvar); }
template<> __attribute__((always_inline)) inline void _dc<19>(FASTLED_REGISTER uint8_t & loopvar) { _dc<10>(loopvar); _dc<9>(loopvar); }
template<> __attribute__((always_inline)) inline void _dc<20>(FASTLED_REGISTER uint8_t & loopvar) { _dc<10>(loopvar); _dc<10>(loopvar); }
#define DINTPIN(T,ADJ,PINADJ) (T-(PINADJ+ADJ)>0) ? _dc<T-(PINADJ+ADJ)>(loopvar) : _dc<0>(loopvar);
#define DINT(T,ADJ) if(AVR_PIN_CYCLES(DATA_PIN)==1) { DINTPIN(T,ADJ,1) } else { DINTPIN(T,ADJ,2); }
@ -363,7 +363,7 @@ protected:
data_t mask = FastPin<DATA_PIN>::mask();
uint8_t scale_base = 0;
// REGISTER uint8_t *end = data + nLeds;
// FASTLED_REGISTER uint8_t *end = data + nLeds;
data_t hi = *port | mask;
data_t lo = *port & ~mask;
*port = lo;

8
src/platforms/avr/fastpin_avr.h
View File

@ -24,15 +24,15 @@ public:
inline static void hi() __attribute__ ((always_inline)) { _PORT::r() |= _MASK; }
inline static void lo() __attribute__ ((always_inline)) { _PORT::r() &= ~_MASK; }
inline static void set(REGISTER uint8_t val) __attribute__ ((always_inline)) { _PORT::r() = val; }
inline static void set(FASTLED_REGISTER uint8_t val) __attribute__ ((always_inline)) { _PORT::r() = val; }
inline static void strobe() __attribute__ ((always_inline)) { toggle(); toggle(); }
inline static void toggle() __attribute__ ((always_inline)) { _PIN::r() = _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 uint8_t val) __attribute__ ((always_inline)) { set(val); }
inline static void hi(FASTLED_REGISTER port_ptr_t /*port*/) __attribute__ ((always_inline)) { hi(); }
inline static void lo(FASTLED_REGISTER port_ptr_t /*port*/) __attribute__ ((always_inline)) { lo(); }
inline static void fastset(FASTLED_REGISTER port_ptr_t /*port*/, FASTLED_REGISTER uint8_t val) __attribute__ ((always_inline)) { set(val); }
inline static port_t hival() __attribute__ ((always_inline)) { return _PORT::r() | _MASK; }
inline static port_t loval() __attribute__ ((always_inline)) { return _PORT::r() & ~_MASK; }

20
src/platforms/avr/fastspi_avr.h
View File

@ -125,7 +125,7 @@ public:
}
// Write a block of n uint8_ts out
template <class D> void writeBytes(REGISTER uint8_t *data, int len) {
template <class D> void writeBytes(FASTLED_REGISTER uint8_t *data, int len) {
//setSPIRate();
uint8_t *end = data + len;
select();
@ -136,7 +136,7 @@ public:
release();
}
void writeBytes(REGISTER uint8_t *data, int len) { writeBytes<DATA_NOP>(data, len); }
void writeBytes(FASTLED_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 and/or end of each grouping
@ -271,7 +271,7 @@ public:
}
// Write a block of n uint8_ts out
template <class D> void writeBytes(REGISTER uint8_t *data, int len) {
template <class D> void writeBytes(FASTLED_REGISTER uint8_t *data, int len) {
//setSPIRate();
uint8_t *end = data + len;
select();
@ -282,7 +282,7 @@ public:
release();
}
void writeBytes(REGISTER uint8_t *data, int len) { writeBytes<DATA_NOP>(data, len); }
void writeBytes(FASTLED_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 and/or end of each grouping
@ -432,7 +432,7 @@ public:
}
// Write a block of n uint8_ts out
template <class D> void writeBytes(REGISTER uint8_t *data, int len) {
template <class D> void writeBytes(FASTLED_REGISTER uint8_t *data, int len) {
//setSPIRate();
uint8_t *end = data + len;
select();
@ -443,7 +443,7 @@ public:
release();
}
void writeBytes(REGISTER uint8_t *data, int len) { writeBytes<DATA_NOP>(data, len); }
void writeBytes(FASTLED_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 and/or end of each grouping
@ -612,7 +612,7 @@ public:
}
// Write a block of n uint8_ts out
template <class D> void writeBytes(REGISTER uint8_t *data, int len) {
template <class D> void writeBytes(FASTLED_REGISTER uint8_t *data, int len) {
//setSPIRate();
uint8_t *end = data + len;
select();
@ -623,7 +623,7 @@ public:
release();
}
void writeBytes(REGISTER uint8_t *data, int len) { writeBytes<DATA_NOP>(data, len); }
void writeBytes(FASTLED_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 and/or end of each grouping
@ -790,7 +790,7 @@ public:
}
// Write a block of n uint8_ts out
template <class D> void writeBytes(REGISTER uint8_t *data, int len) {
template <class D> void writeBytes(FASTLED_REGISTER uint8_t *data, int len) {
//setSPIRate();
uint8_t *end = data + len;
select();
@ -801,7 +801,7 @@ public:
release();
}
void writeBytes(REGISTER uint8_t *data, int len) { writeBytes<DATA_NOP>(data, len); }
void writeBytes(FASTLED_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 and/or end of each grouping

10
src/platforms/esp/32/clockless_block_esp32.h
View File

@ -82,14 +82,14 @@ public:
#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) {
template<int BITS,int PX> __attribute__ ((always_inline)) inline static void writeBits(FASTLED_REGISTER uint32_t & last_mark, FASTLED_REGISTER Lines & b, PixelController<RGB_ORDER, LANES, PORT_MASK> &pixels) { // , FASTLED_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);
FASTLED_REGISTER uint8_t d = pixels.template getd<PX>(pixels);
FASTLED_REGISTER uint8_t scale = pixels.template getscale<PX>(pixels);
for(REGISTER uint32_t i = 0; i < USED_LANES; ++i) {
for(FASTLED_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;
@ -104,7 +104,7 @@ public:
b.bytes[i] = pixels.template loadAndScale<PX>(pixels,i,d,scale);
}
for(REGISTER uint32_t i = USED_LANES; i < 8; ++i) {
for(FASTLED_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;

14
src/platforms/esp/32/clockless_rmt_esp32.cpp
View File

@ -488,22 +488,22 @@ void IRAM_ATTR ESP32RMTController::fillNext(bool check_time)
mLastFill = now;
// -- Get the zero and one values into local variables
REGISTER uint32_t one_val = mOne.val;
REGISTER uint32_t zero_val = mZero.val;
FASTLED_REGISTER uint32_t one_val = mOne.val;
FASTLED_REGISTER uint32_t zero_val = mZero.val;
// -- Use locals for speed
volatile REGISTER uint32_t * pItem = mRMT_mem_ptr;
volatile FASTLED_REGISTER uint32_t * pItem = mRMT_mem_ptr;
for (REGISTER int i = 0; i < PULSES_PER_FILL/8; i++) {
for (FASTLED_REGISTER int i = 0; i < PULSES_PER_FILL/8; i++) {
if (mCur < mSize) {
// -- Get the next four bytes of pixel data
REGISTER uint32_t pixeldata = mPixelData[mCur] << 24;
FASTLED_REGISTER uint32_t pixeldata = mPixelData[mCur] << 24;
mCur++;
// 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++) {
for (FASTLED_REGISTER uint32_t j = 0; j < 8; j++) {
*pItem++ = (pixeldata & 0x80000000L) ? one_val : zero_val;
// Replaces: RMTMEM.chan[mRMT_channel].data32[mCurPulse].val = val;
@ -547,7 +547,7 @@ void ESP32RMTController::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++) {
for (FASTLED_REGISTER uint32_t j = 0; j < 8; j++) {
mBuffer[mCurPulse] = (byteval & 0x80000000L) ? mOne : mZero;
byteval <<= 1;
mCurPulse++;

8
src/platforms/esp/32/fastpin_esp32.h
View File

@ -33,7 +33,7 @@ public:
*cport() = MASK;
}
inline static void set(REGISTER port_t val) __attribute__ ((always_inline)) {
inline static void set(FASTLED_REGISTER port_t val) __attribute__ ((always_inline)) {
*port() = val;
}
@ -43,9 +43,9 @@ public:
*port() ^= 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 void hi(FASTLED_REGISTER port_ptr_t port) __attribute__ ((always_inline)) { hi(); }
inline static void lo(FASTLED_REGISTER port_ptr_t port) __attribute__ ((always_inline)) { lo(); }
inline static void fastset(FASTLED_REGISTER port_ptr_t port, FASTLED_REGISTER port_t val) __attribute__ ((always_inline)) { *port = val; }
inline static port_t hival() __attribute__ ((always_inline)) {
return (*port()) | MASK;

4
src/platforms/esp/32/fastspi_esp32.h
View File

@ -138,7 +138,7 @@ public:
// 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) {
template <class D> void writeBytes(FASTLED_REGISTER uint8_t *data, int len) {
select();
uint8_t *end = data + len;
while(data != end) {
@ -149,7 +149,7 @@ public:
}
// 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); }
void writeBytes(FASTLED_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 void writeBit(uint8_t b) {

10
src/platforms/esp/8266/clockless_block_esp8266.h
View File

@ -70,14 +70,14 @@ public:
#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) {
template<int BITS,int PX> __attribute__ ((always_inline)) inline static void writeBits(FASTLED_REGISTER uint32_t & last_mark, FASTLED_REGISTER Lines & b, PixelController<RGB_ORDER, LANES, PORT_MASK> &pixels) { // , FASTLED_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);
FASTLED_REGISTER uint8_t d = pixels.template getd<PX>(pixels);
FASTLED_REGISTER uint8_t scale = pixels.template getscale<PX>(pixels);
for(REGISTER uint32_t i = 0; i < USED_LANES; ++i) {
for(FASTLED_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;
@ -92,7 +92,7 @@ public:
b.bytes[i] = pixels.template loadAndScale<PX>(pixels,i,d,scale);
}
for(REGISTER uint32_t i = USED_LANES; i < 8; ++i) {
for(FASTLED_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;

12
src/platforms/esp/8266/clockless_esp8266.h
View File

@ -50,14 +50,14 @@ protected:
#define _ESP_ADJ (0)
#define _ESP_ADJ2 (0)
template<int BITS> __attribute__ ((always_inline)) inline static bool writeBits(REGISTER uint32_t & last_mark, REGISTER uint32_t b) {
template<int BITS> __attribute__ ((always_inline)) inline static bool writeBits(FASTLED_REGISTER uint32_t & last_mark, FASTLED_REGISTER uint32_t b) {
b <<= 24; b = ~b;
for(REGISTER uint32_t i = BITS; i > 0; --i) {
for(FASTLED_REGISTER uint32_t i = BITS; i > 0; --i) {
while((__clock_cycles() - last_mark) < (T1+T2+T3)) {
// the current compiler does like just a ; to end of THIS while loop
// altrough this change make no sense because below are more of the same while loops without
// compiler warning.
;
// although this change make no sense because below are more of the same while loops without
// compiler warning.
;
}
last_mark = __clock_cycles();
FastPin<DATA_PIN>::hi();
@ -85,7 +85,7 @@ protected:
static uint32_t IRAM_ATTR showRGBInternal(PixelController<RGB_ORDER> pixels) {
// Setup the pixel controller and load/scale the first byte
pixels.preStepFirstByteDithering();
REGISTER uint32_t b = pixels.loadAndScale0();
FASTLED_REGISTER uint32_t b = pixels.loadAndScale0();
pixels.preStepFirstByteDithering();
uint32_t start;

8
src/platforms/esp/8266/fastpin_esp8266.h
View File

@ -21,15 +21,15 @@ public:
inline static void hi() __attribute__ ((always_inline)) { if(PIN < 16) { _GPB._GPOS = MASK; } else { GP16O = 1; } }
inline static void lo() __attribute__ ((always_inline)) { if(PIN < 16) { _GPB._GPOC = MASK; } else { GP16O = 0; } }
inline static void set(REGISTER port_t val) __attribute__ ((always_inline)) { if(PIN < 16) { _GPB._GPO = val; } else { GP16O = val; }}
inline static void set(FASTLED_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 void hi(FASTLED_REGISTER port_ptr_t port) __attribute__ ((always_inline)) { hi(); }
inline static void lo(FASTLED_REGISTER port_ptr_t port) __attribute__ ((always_inline)) { lo(); }
inline static void fastset(FASTLED_REGISTER port_ptr_t port, FASTLED_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; } }

4
src/platforms/esp/8266/fastspi_esp8266.h
View File

@ -103,7 +103,7 @@ public:
// 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) {
template <class D> void writeBytes(FASTLED_REGISTER uint8_t *data, int len) {
select();
uint8_t *end = data + len;
while(data != end) {
@ -114,7 +114,7 @@ public:
}
// 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); }
void writeBytes(FASTLED_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 void writeBit(uint8_t b) {

4
src/platforms/fastspi_ardunio_core.h
View File

@ -53,7 +53,7 @@ public:
}
// 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) {
template <class D> void writeBytes(FASTLED_REGISTER uint8_t *data, int len) {
uint8_t *end = data + len;
select();
// could be optimized to write 16bit words out instead of 8bit bytes
@ -66,7 +66,7 @@ public:
}
// 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); }
void writeBytes(FASTLED_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 void writeBit(uint8_t b) {