Breakout of animations to separate files Integration of optimized int based math lib Overhaul of rgb_matrix.c and animations for performancepull/5372/head
Ryan Caltabiano
7 years ago
parent
23086808a7
commit
8073da5dea
@ -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.
|
||||||
@ -0,0 +1,242 @@
|
|||||||
|
#define FASTLED_INTERNAL
|
||||||
|
#include <stdint.h>
|
||||||
|
|
||||||
|
#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__)
|
||||||
|
//__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;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#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
|
||||||
@ -0,0 +1,934 @@
|
|||||||
|
#ifndef __INC_LIB8TION_H
|
||||||
|
#define __INC_LIB8TION_H
|
||||||
|
|
||||||
|
/*
|
||||||
|
|
||||||
|
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.
|
||||||
|
|
||||||
|
|
||||||
|
Included are:
|
||||||
|
|
||||||
|
|
||||||
|
- Saturating unsigned 8-bit add and subtract.
|
||||||
|
Instead of wrapping around if an overflow occurs,
|
||||||
|
these routines just 'clamp' the output at a maxumum
|
||||||
|
of 255, or a minimum of 0. Useful for adding pixel
|
||||||
|
values. E.g., qadd8( 200, 100) = 255.
|
||||||
|
|
||||||
|
qadd8( i, j) == MIN( (i + j), 0xFF )
|
||||||
|
qsub8( i, j) == MAX( (i - j), 0 )
|
||||||
|
|
||||||
|
- Saturating signed 8-bit ("7-bit") add.
|
||||||
|
qadd7( i, j) == MIN( (i + j), 0x7F)
|
||||||
|
|
||||||
|
|
||||||
|
- Scaling (down) of unsigned 8- and 16- bit values.
|
||||||
|
Scaledown value is specified in 1/256ths.
|
||||||
|
scale8( i, sc) == (i * sc) / 256
|
||||||
|
scale16by8( i, sc) == (i * sc) / 256
|
||||||
|
|
||||||
|
Example: scaling a 0-255 value down into a
|
||||||
|
range from 0-99:
|
||||||
|
downscaled = scale8( originalnumber, 100);
|
||||||
|
|
||||||
|
A special version of scale8 is provided for scaling
|
||||||
|
LED brightness values, to make sure that they don't
|
||||||
|
accidentally scale down to total black at low
|
||||||
|
dimming levels, since that would look wrong:
|
||||||
|
scale8_video( i, sc) = ((i * sc) / 256) +? 1
|
||||||
|
|
||||||
|
Example: reducing an LED brightness by a
|
||||||
|
dimming factor:
|
||||||
|
new_bright = scale8_video( orig_bright, dimming);
|
||||||
|
|
||||||
|
|
||||||
|
- Fast 8- and 16- bit unsigned random numbers.
|
||||||
|
Significantly faster than Arduino random(), but
|
||||||
|
also somewhat less random. You can add entropy.
|
||||||
|
random8() == random from 0..255
|
||||||
|
random8( n) == random from 0..(N-1)
|
||||||
|
random8( n, m) == random from N..(M-1)
|
||||||
|
|
||||||
|
random16() == random from 0..65535
|
||||||
|
random16( n) == random from 0..(N-1)
|
||||||
|
random16( n, m) == random from N..(M-1)
|
||||||
|
|
||||||
|
random16_set_seed( k) == seed = k
|
||||||
|
random16_add_entropy( k) == seed += k
|
||||||
|
|
||||||
|
|
||||||
|
- Absolute value of a signed 8-bit value.
|
||||||
|
abs8( i) == abs( i)
|
||||||
|
|
||||||
|
|
||||||
|
- 8-bit math operations which return 8-bit values.
|
||||||
|
These are provided mostly for completeness,
|
||||||
|
not particularly for performance.
|
||||||
|
mul8( i, j) == (i * j) & 0xFF
|
||||||
|
add8( i, j) == (i + j) & 0xFF
|
||||||
|
sub8( i, j) == (i - j) & 0xFF
|
||||||
|
|
||||||
|
|
||||||
|
- Fast 16-bit approximations of sin and cos.
|
||||||
|
Input angle is a uint16_t from 0-65535.
|
||||||
|
Output is a signed int16_t from -32767 to 32767.
|
||||||
|
sin16( x) == sin( (x/32768.0) * pi) * 32767
|
||||||
|
cos16( x) == cos( (x/32768.0) * pi) * 32767
|
||||||
|
Accurate to more than 99% in all cases.
|
||||||
|
|
||||||
|
- Fast 8-bit approximations of sin and cos.
|
||||||
|
Input angle is a uint8_t from 0-255.
|
||||||
|
Output is an UNsigned uint8_t from 0 to 255.
|
||||||
|
sin8( x) == (sin( (x/128.0) * pi) * 128) + 128
|
||||||
|
cos8( x) == (cos( (x/128.0) * pi) * 128) + 128
|
||||||
|
Accurate to within about 2%.
|
||||||
|
|
||||||
|
|
||||||
|
- Fast 8-bit "easing in/out" function.
|
||||||
|
ease8InOutCubic(x) == 3(x^i) - 2(x^3)
|
||||||
|
ease8InOutApprox(x) ==
|
||||||
|
faster, rougher, approximation of cubic easing
|
||||||
|
ease8InOutQuad(x) == quadratic (vs cubic) easing
|
||||||
|
|
||||||
|
- Cubic, Quadratic, and Triangle wave functions.
|
||||||
|
Input is a uint8_t representing phase withing the wave,
|
||||||
|
similar to how sin8 takes an angle 'theta'.
|
||||||
|
Output is a uint8_t representing the amplitude of
|
||||||
|
the wave at that point.
|
||||||
|
cubicwave8( x)
|
||||||
|
quadwave8( x)
|
||||||
|
triwave8( x)
|
||||||
|
|
||||||
|
- Square root for 16-bit integers. About three times
|
||||||
|
faster and five times smaller than Arduino's built-in
|
||||||
|
generic 32-bit sqrt routine.
|
||||||
|
sqrt16( uint16_t x ) == sqrt( x)
|
||||||
|
|
||||||
|
- Dimming and brightening functions for 8-bit
|
||||||
|
light values.
|
||||||
|
dim8_video( x) == scale8_video( x, x)
|
||||||
|
dim8_raw( x) == scale8( x, x)
|
||||||
|
dim8_lin( x) == (x<128) ? ((x+1)/2) : scale8(x,x)
|
||||||
|
brighten8_video( x) == 255 - dim8_video( 255 - x)
|
||||||
|
brighten8_raw( x) == 255 - dim8_raw( 255 - x)
|
||||||
|
brighten8_lin( x) == 255 - dim8_lin( 255 - x)
|
||||||
|
The dimming functions in particular are suitable
|
||||||
|
for making LED light output appear more 'linear'.
|
||||||
|
|
||||||
|
|
||||||
|
- Linear interpolation between two values, with the
|
||||||
|
fraction between them expressed as an 8- or 16-bit
|
||||||
|
fixed point fraction (fract8 or fract16).
|
||||||
|
lerp8by8( fromU8, toU8, fract8 )
|
||||||
|
lerp16by8( fromU16, toU16, fract8 )
|
||||||
|
lerp15by8( fromS16, toS16, fract8 )
|
||||||
|
== from + (( to - from ) * fract8) / 256)
|
||||||
|
lerp16by16( fromU16, toU16, fract16 )
|
||||||
|
== from + (( to - from ) * fract16) / 65536)
|
||||||
|
map8( in, rangeStart, rangeEnd)
|
||||||
|
== map( in, 0, 255, rangeStart, rangeEnd);
|
||||||
|
|
||||||
|
- Optimized memmove, memcpy, and memset, that are
|
||||||
|
faster than standard avr-libc 1.8.
|
||||||
|
memmove8( dest, src, bytecount)
|
||||||
|
memcpy8( dest, src, bytecount)
|
||||||
|
memset8( buf, value, bytecount)
|
||||||
|
|
||||||
|
- Beat generators which return sine or sawtooth
|
||||||
|
waves in a specified number of Beats Per Minute.
|
||||||
|
Sine wave beat generators can specify a low and
|
||||||
|
high range for the output. Sawtooth wave beat
|
||||||
|
generators always range 0-255 or 0-65535.
|
||||||
|
beatsin8( BPM, low8, high8)
|
||||||
|
= (sine(beatphase) * (high8-low8)) + low8
|
||||||
|
beatsin16( BPM, low16, high16)
|
||||||
|
= (sine(beatphase) * (high16-low16)) + low16
|
||||||
|
beatsin88( BPM88, low16, high16)
|
||||||
|
= (sine(beatphase) * (high16-low16)) + low16
|
||||||
|
beat8( BPM) = 8-bit repeating sawtooth wave
|
||||||
|
beat16( BPM) = 16-bit repeating sawtooth wave
|
||||||
|
beat88( BPM88) = 16-bit repeating sawtooth wave
|
||||||
|
BPM is beats per minute in either simple form
|
||||||
|
e.g. 120, or Q8.8 fixed-point form.
|
||||||
|
BPM88 is beats per minute in ONLY Q8.8 fixed-point
|
||||||
|
form.
|
||||||
|
|
||||||
|
Lib8tion is pronounced like 'libation': lie-BAY-shun
|
||||||
|
|
||||||
|
*/
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
#include <stdint.h>
|
||||||
|
|
||||||
|
#define LIB8STATIC __attribute__ ((unused)) static inline
|
||||||
|
#define LIB8STATIC_ALWAYS_INLINE __attribute__ ((always_inline)) static inline
|
||||||
|
|
||||||
|
#if !defined(__AVR__)
|
||||||
|
#include <string.h>
|
||||||
|
// for memmove, memcpy, and memset if not defined here
|
||||||
|
#endif
|
||||||
|
|
||||||
|
#if defined(__arm__)
|
||||||
|
|
||||||
|
#if defined(FASTLED_TEENSY3)
|
||||||
|
// Can use Cortex M4 DSP instructions
|
||||||
|
#define QADD8_C 0
|
||||||
|
#define QADD7_C 0
|
||||||
|
#define QADD8_ARM_DSP_ASM 1
|
||||||
|
#define QADD7_ARM_DSP_ASM 1
|
||||||
|
#else
|
||||||
|
// Generic ARM
|
||||||
|
#define QADD8_C 1
|
||||||
|
#define QADD7_C 1
|
||||||
|
#endif
|
||||||
|
|
||||||
|
#define QSUB8_C 1
|
||||||
|
#define SCALE8_C 1
|
||||||
|
#define SCALE16BY8_C 1
|
||||||
|
#define SCALE16_C 1
|
||||||
|
#define ABS8_C 1
|
||||||
|
#define MUL8_C 1
|
||||||
|
#define QMUL8_C 1
|
||||||
|
#define ADD8_C 1
|
||||||
|
#define SUB8_C 1
|
||||||
|
#define EASE8_C 1
|
||||||
|
#define AVG8_C 1
|
||||||
|
#define AVG7_C 1
|
||||||
|
#define AVG16_C 1
|
||||||
|
#define AVG15_C 1
|
||||||
|
#define BLEND8_C 1
|
||||||
|
|
||||||
|
|
||||||
|
#elif defined(__AVR__)
|
||||||
|
|
||||||
|
// AVR ATmega and friends Arduino
|
||||||
|
|
||||||
|
#define QADD8_C 0
|
||||||
|
#define QADD7_C 0
|
||||||
|
#define QSUB8_C 0
|
||||||
|
#define ABS8_C 0
|
||||||
|
#define ADD8_C 0
|
||||||
|
#define SUB8_C 0
|
||||||
|
#define AVG8_C 0
|
||||||
|
#define AVG7_C 0
|
||||||
|
#define AVG16_C 0
|
||||||
|
#define AVG15_C 0
|
||||||
|
|
||||||
|
#define QADD8_AVRASM 1
|
||||||
|
#define QADD7_AVRASM 1
|
||||||
|
#define QSUB8_AVRASM 1
|
||||||
|
#define ABS8_AVRASM 1
|
||||||
|
#define ADD8_AVRASM 1
|
||||||
|
#define SUB8_AVRASM 1
|
||||||
|
#define AVG8_AVRASM 1
|
||||||
|
#define AVG7_AVRASM 1
|
||||||
|
#define AVG16_AVRASM 1
|
||||||
|
#define AVG15_AVRASM 1
|
||||||
|
|
||||||
|
// Note: these require hardware MUL instruction
|
||||||
|
// -- sorry, ATtiny!
|
||||||
|
#if !defined(LIB8_ATTINY)
|
||||||
|
#define SCALE8_C 0
|
||||||
|
#define SCALE16BY8_C 0
|
||||||
|
#define SCALE16_C 0
|
||||||
|
#define MUL8_C 0
|
||||||
|
#define QMUL8_C 0
|
||||||
|
#define EASE8_C 0
|
||||||
|
#define BLEND8_C 0
|
||||||
|
#define SCALE8_AVRASM 1
|
||||||
|
#define SCALE16BY8_AVRASM 1
|
||||||
|
#define SCALE16_AVRASM 1
|
||||||
|
#define MUL8_AVRASM 1
|
||||||
|
#define QMUL8_AVRASM 1
|
||||||
|
#define EASE8_AVRASM 1
|
||||||
|
#define CLEANUP_R1_AVRASM 1
|
||||||
|
#define BLEND8_AVRASM 1
|
||||||
|
#else
|
||||||
|
// On ATtiny, we just use C implementations
|
||||||
|
#define SCALE8_C 1
|
||||||
|
#define SCALE16BY8_C 1
|
||||||
|
#define SCALE16_C 1
|
||||||
|
#define MUL8_C 1
|
||||||
|
#define QMUL8_C 1
|
||||||
|
#define EASE8_C 1
|
||||||
|
#define BLEND8_C 1
|
||||||
|
#define SCALE8_AVRASM 0
|
||||||
|
#define SCALE16BY8_AVRASM 0
|
||||||
|
#define SCALE16_AVRASM 0
|
||||||
|
#define MUL8_AVRASM 0
|
||||||
|
#define QMUL8_AVRASM 0
|
||||||
|
#define EASE8_AVRASM 0
|
||||||
|
#define BLEND8_AVRASM 0
|
||||||
|
#endif
|
||||||
|
|
||||||
|
#else
|
||||||
|
|
||||||
|
// unspecified architecture, so
|
||||||
|
// no ASM, everything in C
|
||||||
|
#define QADD8_C 1
|
||||||
|
#define QADD7_C 1
|
||||||
|
#define QSUB8_C 1
|
||||||
|
#define SCALE8_C 1
|
||||||
|
#define SCALE16BY8_C 1
|
||||||
|
#define SCALE16_C 1
|
||||||
|
#define ABS8_C 1
|
||||||
|
#define MUL8_C 1
|
||||||
|
#define QMUL8_C 1
|
||||||
|
#define ADD8_C 1
|
||||||
|
#define SUB8_C 1
|
||||||
|
#define EASE8_C 1
|
||||||
|
#define AVG8_C 1
|
||||||
|
#define AVG7_C 1
|
||||||
|
#define AVG16_C 1
|
||||||
|
#define AVG15_C 1
|
||||||
|
#define BLEND8_C 1
|
||||||
|
|
||||||
|
#endif
|
||||||
|
|
||||||
|
///@defgroup lib8tion Fast math functions
|
||||||
|
///A variety of functions for working with numbers.
|
||||||
|
///@{
|
||||||
|
|
||||||
|
|
||||||
|
///////////////////////////////////////////////////////////////////////
|
||||||
|
//
|
||||||
|
// typdefs for fixed-point fractional types.
|
||||||
|
//
|
||||||
|
// sfract7 should be interpreted as signed 128ths.
|
||||||
|
// fract8 should be interpreted as unsigned 256ths.
|
||||||
|
// sfract15 should be interpreted as signed 32768ths.
|
||||||
|
// fract16 should be interpreted as unsigned 65536ths.
|
||||||
|
//
|
||||||
|
// Example: if a fract8 has the value "64", that should be interpreted
|
||||||
|
// as 64/256ths, or one-quarter.
|
||||||
|
//
|
||||||
|
//
|
||||||
|
// fract8 range is 0 to 0.99609375
|
||||||
|
// in steps of 0.00390625
|
||||||
|
//
|
||||||
|
// sfract7 range is -0.9921875 to 0.9921875
|
||||||
|
// in steps of 0.0078125
|
||||||
|
//
|
||||||
|
// fract16 range is 0 to 0.99998474121
|
||||||
|
// in steps of 0.00001525878
|
||||||
|
//
|
||||||
|
// sfract15 range is -0.99996948242 to 0.99996948242
|
||||||
|
// in steps of 0.00003051757
|
||||||
|
//
|
||||||
|
|
||||||
|
/// ANSI unsigned short _Fract. range is 0 to 0.99609375
|
||||||
|
/// in steps of 0.00390625
|
||||||
|
typedef uint8_t fract8; ///< ANSI: unsigned short _Fract
|
||||||
|
|
||||||
|
/// ANSI: signed short _Fract. range is -0.9921875 to 0.9921875
|
||||||
|
/// in steps of 0.0078125
|
||||||
|
typedef int8_t sfract7; ///< ANSI: signed short _Fract
|
||||||
|
|
||||||
|
/// ANSI: unsigned _Fract. range is 0 to 0.99998474121
|
||||||
|
/// in steps of 0.00001525878
|
||||||
|
typedef uint16_t fract16; ///< ANSI: unsigned _Fract
|
||||||
|
|
||||||
|
/// ANSI: signed _Fract. range is -0.99996948242 to 0.99996948242
|
||||||
|
/// in steps of 0.00003051757
|
||||||
|
typedef int16_t sfract15; ///< ANSI: signed _Fract
|
||||||
|
|
||||||
|
|
||||||
|
// accumXY types should be interpreted as X bits of integer,
|
||||||
|
// and Y bits of fraction.
|
||||||
|
// E.g., accum88 has 8 bits of int, 8 bits of fraction
|
||||||
|
|
||||||
|
typedef uint16_t accum88; ///< ANSI: unsigned short _Accum. 8 bits int, 8 bits fraction
|
||||||
|
typedef int16_t saccum78; ///< ANSI: signed short _Accum. 7 bits int, 8 bits fraction
|
||||||
|
typedef uint32_t accum1616;///< ANSI: signed _Accum. 16 bits int, 16 bits fraction
|
||||||
|
typedef int32_t saccum1516;///< ANSI: signed _Accum. 15 bits int, 16 bits fraction
|
||||||
|
typedef uint16_t accum124; ///< no direct ANSI counterpart. 12 bits int, 4 bits fraction
|
||||||
|
typedef int32_t saccum114;///< no direct ANSI counterpart. 1 bit int, 14 bits fraction
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
#include "math8.h"
|
||||||
|
#include "scale8.h"
|
||||||
|
#include "random8.h"
|
||||||
|
#include "trig8.h"
|
||||||
|
|
||||||
|
///////////////////////////////////////////////////////////////////////
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
///////////////////////////////////////////////////////////////////////
|
||||||
|
//
|
||||||
|
// float-to-fixed and fixed-to-float conversions
|
||||||
|
//
|
||||||
|
// Note that anything involving a 'float' on AVR will be slower.
|
||||||
|
|
||||||
|
/// sfract15ToFloat: conversion from sfract15 fixed point to
|
||||||
|
/// IEEE754 32-bit float.
|
||||||
|
LIB8STATIC float sfract15ToFloat( sfract15 y)
|
||||||
|
{
|
||||||
|
return y / 32768.0;
|
||||||
|
}
|
||||||
|
|
||||||
|
/// conversion from IEEE754 float in the range (-1,1)
|
||||||
|
/// to 16-bit fixed point. Note that the extremes of
|
||||||
|
/// one and negative one are NOT representable. The
|
||||||
|
/// representable range is basically
|
||||||
|
LIB8STATIC sfract15 floatToSfract15( float f)
|
||||||
|
{
|
||||||
|
return f * 32768.0;
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
///////////////////////////////////////////////////////////////////////
|
||||||
|
//
|
||||||
|
// memmove8, memcpy8, and memset8:
|
||||||
|
// alternatives to memmove, memcpy, and memset that are
|
||||||
|
// faster on AVR than standard avr-libc 1.8
|
||||||
|
|
||||||
|
#if defined(__AVR__)
|
||||||
|
void * memmove8( void * dst, const void * src, uint16_t num );
|
||||||
|
void * memcpy8 ( void * dst, const void * src, uint16_t num ) __attribute__ ((noinline));
|
||||||
|
void * memset8 ( void * ptr, uint8_t value, uint16_t num ) __attribute__ ((noinline)) ;
|
||||||
|
#else
|
||||||
|
// on non-AVR platforms, these names just call standard libc.
|
||||||
|
#define memmove8 memmove
|
||||||
|
#define memcpy8 memcpy
|
||||||
|
#define memset8 memset
|
||||||
|
#endif
|
||||||
|
|
||||||
|
|
||||||
|
///////////////////////////////////////////////////////////////////////
|
||||||
|
//
|
||||||
|
// linear interpolation, such as could be used for Perlin noise, etc.
|
||||||
|
//
|
||||||
|
|
||||||
|
// A note on the structure of the lerp functions:
|
||||||
|
// The cases for b>a and b<=a are handled separately for
|
||||||
|
// speed: without knowing the relative order of a and b,
|
||||||
|
// the value (a-b) might be overflow the width of a or b,
|
||||||
|
// and have to be promoted to a wider, slower type.
|
||||||
|
// To avoid that, we separate the two cases, and are able
|
||||||
|
// to do all the math in the same width as the arguments,
|
||||||
|
// which is much faster and smaller on AVR.
|
||||||
|
|
||||||
|
/// linear interpolation between two unsigned 8-bit values,
|
||||||
|
/// with 8-bit fraction
|
||||||
|
LIB8STATIC uint8_t lerp8by8( uint8_t a, uint8_t b, fract8 frac)
|
||||||
|
{
|
||||||
|
uint8_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;
|
||||||
|
}
|
||||||
|
|
||||||
|
/// linear interpolation between two unsigned 16-bit values,
|
||||||
|
/// with 16-bit fraction
|
||||||
|
LIB8STATIC uint16_t lerp16by16( uint16_t a, uint16_t b, fract16 frac)
|
||||||
|
{
|
||||||
|
uint16_t result;
|
||||||
|
if( b > a ) {
|
||||||
|
uint16_t delta = b - a;
|
||||||
|
uint16_t scaled = scale16(delta, frac);
|
||||||
|
result = a + scaled;
|
||||||
|
} else {
|
||||||
|
uint16_t delta = a - b;
|
||||||
|
uint16_t scaled = scale16( delta, frac);
|
||||||
|
result = a - scaled;
|
||||||
|
}
|
||||||
|
return result;
|
||||||
|
}
|
||||||
|
|
||||||
|
/// linear interpolation between two unsigned 16-bit values,
|
||||||
|
/// with 8-bit fraction
|
||||||
|
LIB8STATIC uint16_t lerp16by8( uint16_t a, uint16_t b, fract8 frac)
|
||||||
|
{
|
||||||
|
uint16_t result;
|
||||||
|
if( b > a) {
|
||||||
|
uint16_t delta = b - a;
|
||||||
|
uint16_t scaled = scale16by8( delta, frac);
|
||||||
|
result = a + scaled;
|
||||||
|
} else {
|
||||||
|
uint16_t delta = a - b;
|
||||||
|
uint16_t scaled = scale16by8( delta, frac);
|
||||||
|
result = a - scaled;
|
||||||
|
}
|
||||||
|
return result;
|
||||||
|
}
|
||||||
|
|
||||||
|
/// linear interpolation between two signed 15-bit values,
|
||||||
|
/// with 8-bit fraction
|
||||||
|
LIB8STATIC int16_t lerp15by8( int16_t a, int16_t b, fract8 frac)
|
||||||
|
{
|
||||||
|
int16_t result;
|
||||||
|
if( b > a) {
|
||||||
|
uint16_t delta = b - a;
|
||||||
|
uint16_t scaled = scale16by8( delta, frac);
|
||||||
|
result = a + scaled;
|
||||||
|
} else {
|
||||||
|
uint16_t delta = a - b;
|
||||||
|
uint16_t scaled = scale16by8( delta, frac);
|
||||||
|
result = a - scaled;
|
||||||
|
}
|
||||||
|
return result;
|
||||||
|
}
|
||||||
|
|
||||||
|
/// linear interpolation between two signed 15-bit values,
|
||||||
|
/// with 8-bit fraction
|
||||||
|
LIB8STATIC int16_t lerp15by16( int16_t a, int16_t b, fract16 frac)
|
||||||
|
{
|
||||||
|
int16_t result;
|
||||||
|
if( b > a) {
|
||||||
|
uint16_t delta = b - a;
|
||||||
|
uint16_t scaled = scale16( delta, frac);
|
||||||
|
result = a + scaled;
|
||||||
|
} else {
|
||||||
|
uint16_t delta = a - b;
|
||||||
|
uint16_t scaled = scale16( delta, frac);
|
||||||
|
result = a - scaled;
|
||||||
|
}
|
||||||
|
return result;
|
||||||
|
}
|
||||||
|
|
||||||
|
/// map8: map from one full-range 8-bit value into a narrower
|
||||||
|
/// range of 8-bit values, possibly a range of hues.
|
||||||
|
///
|
||||||
|
/// E.g. map myValue into a hue in the range blue..purple..pink..red
|
||||||
|
/// hue = map8( myValue, HUE_BLUE, HUE_RED);
|
||||||
|
///
|
||||||
|
/// Combines nicely with the waveform functions (like sin8, etc)
|
||||||
|
/// to produce continuous hue gradients back and forth:
|
||||||
|
///
|
||||||
|
/// hue = map8( sin8( myValue), HUE_BLUE, HUE_RED);
|
||||||
|
///
|
||||||
|
/// Mathematically simiar to lerp8by8, but arguments are more
|
||||||
|
/// like Arduino's "map"; this function is similar to
|
||||||
|
///
|
||||||
|
/// map( in, 0, 255, rangeStart, rangeEnd)
|
||||||
|
///
|
||||||
|
/// but faster and specifically designed for 8-bit values.
|
||||||
|
LIB8STATIC uint8_t map8( uint8_t in, uint8_t rangeStart, uint8_t rangeEnd)
|
||||||
|
{
|
||||||
|
uint8_t rangeWidth = rangeEnd - rangeStart;
|
||||||
|
uint8_t out = scale8( in, rangeWidth);
|
||||||
|
out += rangeStart;
|
||||||
|
return out;
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
///////////////////////////////////////////////////////////////////////
|
||||||
|
//
|
||||||
|
// easing functions; see http://easings.net
|
||||||
|
//
|
||||||
|
|
||||||
|
/// ease8InOutQuad: 8-bit quadratic ease-in / ease-out function
|
||||||
|
/// Takes around 13 cycles on AVR
|
||||||
|
#if EASE8_C == 1
|
||||||
|
LIB8STATIC uint8_t ease8InOutQuad( uint8_t i)
|
||||||
|
{
|
||||||
|
uint8_t j = i;
|
||||||
|
if( j & 0x80 ) {
|
||||||
|
j = 255 - j;
|
||||||
|
}
|
||||||
|
uint8_t jj = scale8( j, j);
|
||||||
|
uint8_t jj2 = jj << 1;
|
||||||
|
if( i & 0x80 ) {
|
||||||
|
jj2 = 255 - jj2;
|
||||||
|
}
|
||||||
|
return jj2;
|
||||||
|
}
|
||||||
|
|
||||||
|
#elif EASE8_AVRASM == 1
|
||||||
|
// This AVR asm version of ease8InOutQuad preserves one more
|
||||||
|
// low-bit of precision than the C version, and is also slightly
|
||||||
|
// smaller and faster.
|
||||||
|
LIB8STATIC uint8_t ease8InOutQuad(uint8_t val) {
|
||||||
|
uint8_t j=val;
|
||||||
|
asm volatile (
|
||||||
|
"sbrc %[val], 7 \n"
|
||||||
|
"com %[j] \n"
|
||||||
|
"mul %[j], %[j] \n"
|
||||||
|
"add r0, %[j] \n"
|
||||||
|
"ldi %[j], 0 \n"
|
||||||
|
"adc %[j], r1 \n"
|
||||||
|
"lsl r0 \n" // carry = high bit of low byte of mul product
|
||||||
|
"rol %[j] \n" // j = (j * 2) + carry // preserve add'l bit of precision
|
||||||
|
"sbrc %[val], 7 \n"
|
||||||
|
"com %[j] \n"
|
||||||
|
"clr __zero_reg__ \n"
|
||||||
|
: [j] "+&a" (j)
|
||||||
|
: [val] "a" (val)
|
||||||
|
: "r0", "r1"
|
||||||
|
);
|
||||||
|
return j;
|
||||||
|
}
|
||||||
|
|
||||||
|
#else
|
||||||
|
#error "No implementation for ease8InOutQuad available."
|
||||||
|
#endif
|
||||||
|
|
||||||
|
/// ease16InOutQuad: 16-bit quadratic ease-in / ease-out function
|
||||||
|
// C implementation at this point
|
||||||
|
LIB8STATIC uint16_t ease16InOutQuad( uint16_t i)
|
||||||
|
{
|
||||||
|
uint16_t j = i;
|
||||||
|
if( j & 0x8000 ) {
|
||||||
|
j = 65535 - j;
|
||||||
|
}
|
||||||
|
uint16_t jj = scale16( j, j);
|
||||||
|
uint16_t jj2 = jj << 1;
|
||||||
|
if( i & 0x8000 ) {
|
||||||
|
jj2 = 65535 - jj2;
|
||||||
|
}
|
||||||
|
return jj2;
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
/// ease8InOutCubic: 8-bit cubic ease-in / ease-out function
|
||||||
|
/// Takes around 18 cycles on AVR
|
||||||
|
LIB8STATIC fract8 ease8InOutCubic( fract8 i)
|
||||||
|
{
|
||||||
|
uint8_t ii = scale8_LEAVING_R1_DIRTY( i, i);
|
||||||
|
uint8_t iii = scale8_LEAVING_R1_DIRTY( ii, i);
|
||||||
|
|
||||||
|
uint16_t r1 = (3 * (uint16_t)(ii)) - ( 2 * (uint16_t)(iii));
|
||||||
|
|
||||||
|
/* the code generated for the above *'s automatically
|
||||||
|
cleans up R1, so there's no need to explicitily call
|
||||||
|
cleanup_R1(); */
|
||||||
|
|
||||||
|
uint8_t result = r1;
|
||||||
|
|
||||||
|
// if we got "256", return 255:
|
||||||
|
if( r1 & 0x100 ) {
|
||||||
|
result = 255;
|
||||||
|
}
|
||||||
|
return result;
|
||||||
|
}
|
||||||
|
|
||||||
|
/// ease8InOutApprox: fast, rough 8-bit ease-in/ease-out function
|
||||||
|
/// shaped approximately like 'ease8InOutCubic',
|
||||||
|
/// it's never off by more than a couple of percent
|
||||||
|
/// from the actual cubic S-curve, and it executes
|
||||||
|
/// more than twice as fast. Use when the cycles
|
||||||
|
/// are more important than visual smoothness.
|
||||||
|
/// Asm version takes around 7 cycles on AVR.
|
||||||
|
|
||||||
|
#if EASE8_C == 1
|
||||||
|
LIB8STATIC fract8 ease8InOutApprox( fract8 i)
|
||||||
|
{
|
||||||
|
if( i < 64) {
|
||||||
|
// start with slope 0.5
|
||||||
|
i /= 2;
|
||||||
|
} else if( i > (255 - 64)) {
|
||||||
|
// end with slope 0.5
|
||||||
|
i = 255 - i;
|
||||||
|
i /= 2;
|
||||||
|
i = 255 - i;
|
||||||
|
} else {
|
||||||
|
// in the middle, use slope 192/128 = 1.5
|
||||||
|
i -= 64;
|
||||||
|
i += (i / 2);
|
||||||
|
i += 32;
|
||||||
|
}
|
||||||
|
|
||||||
|
return i;
|
||||||
|
}
|
||||||
|
|
||||||
|
#elif EASE8_AVRASM == 1
|
||||||
|
LIB8STATIC uint8_t ease8InOutApprox( fract8 i)
|
||||||
|
{
|
||||||
|
// takes around 7 cycles on AVR
|
||||||
|
asm volatile (
|
||||||
|
" subi %[i], 64 \n\t"
|
||||||
|
" cpi %[i], 128 \n\t"
|
||||||
|
" brcc Lshift_%= \n\t"
|
||||||
|
|
||||||
|
// middle case
|
||||||
|
" mov __tmp_reg__, %[i] \n\t"
|
||||||
|
" lsr __tmp_reg__ \n\t"
|
||||||
|
" add %[i], __tmp_reg__ \n\t"
|
||||||
|
" subi %[i], 224 \n\t"
|
||||||
|
" rjmp Ldone_%= \n\t"
|
||||||
|
|
||||||
|
// start or end case
|
||||||
|
"Lshift_%=: \n\t"
|
||||||
|
" lsr %[i] \n\t"
|
||||||
|
" subi %[i], 96 \n\t"
|
||||||
|
|
||||||
|
"Ldone_%=: \n\t"
|
||||||
|
|
||||||
|
: [i] "+&a" (i)
|
||||||
|
:
|
||||||
|
: "r0", "r1"
|
||||||
|
);
|
||||||
|
return i;
|
||||||
|
}
|
||||||
|
#else
|
||||||
|
#error "No implementation for ease8 available."
|
||||||
|
#endif
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
/// triwave8: triangle (sawtooth) wave generator. Useful for
|
||||||
|
/// turning a one-byte ever-increasing value into a
|
||||||
|
/// one-byte value that oscillates up and down.
|
||||||
|
///
|
||||||
|
/// input output
|
||||||
|
/// 0..127 0..254 (positive slope)
|
||||||
|
/// 128..255 254..0 (negative slope)
|
||||||
|
///
|
||||||
|
/// On AVR this function takes just three cycles.
|
||||||
|
///
|
||||||
|
LIB8STATIC uint8_t triwave8(uint8_t in)
|
||||||
|
{
|
||||||
|
if( in & 0x80) {
|
||||||
|
in = 255 - in;
|
||||||
|
}
|
||||||
|
uint8_t out = in << 1;
|
||||||
|
return out;
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
// quadwave8 and cubicwave8: S-shaped wave generators (like 'sine').
|
||||||
|
// Useful for turning a one-byte 'counter' value into a
|
||||||
|
// one-byte oscillating value that moves smoothly up and down,
|
||||||
|
// with an 'acceleration' and 'deceleration' curve.
|
||||||
|
//
|
||||||
|
// These are even faster than 'sin8', and have
|
||||||
|
// slightly different curve shapes.
|
||||||
|
//
|
||||||
|
|
||||||
|
/// quadwave8: quadratic waveform generator. Spends just a little more
|
||||||
|
/// time at the limits than 'sine' does.
|
||||||
|
LIB8STATIC uint8_t quadwave8(uint8_t in)
|
||||||
|
{
|
||||||
|
return ease8InOutQuad( triwave8( in));
|
||||||
|
}
|
||||||
|
|
||||||
|
/// cubicwave8: cubic waveform generator. Spends visibly more time
|
||||||
|
/// at the limits than 'sine' does.
|
||||||
|
LIB8STATIC uint8_t cubicwave8(uint8_t in)
|
||||||
|
{
|
||||||
|
return ease8InOutCubic( triwave8( in));
|
||||||
|
}
|
||||||
|
|
||||||
|
/// squarewave8: square wave generator. Useful for
|
||||||
|
/// turning a one-byte ever-increasing value
|
||||||
|
/// into a one-byte value that is either 0 or 255.
|
||||||
|
/// The width of the output 'pulse' is
|
||||||
|
/// determined by the pulsewidth argument:
|
||||||
|
///
|
||||||
|
///~~~
|
||||||
|
/// If pulsewidth is 255, output is always 255.
|
||||||
|
/// If pulsewidth < 255, then
|
||||||
|
/// if input < pulsewidth then output is 255
|
||||||
|
/// if input >= pulsewidth then output is 0
|
||||||
|
///~~~
|
||||||
|
///
|
||||||
|
/// the output looking like:
|
||||||
|
///
|
||||||
|
///~~~
|
||||||
|
/// 255 +--pulsewidth--+
|
||||||
|
/// . | |
|
||||||
|
/// 0 0 +--------(256-pulsewidth)--------
|
||||||
|
///~~~
|
||||||
|
///
|
||||||
|
/// @param in
|
||||||
|
/// @param pulsewidth
|
||||||
|
/// @returns square wave output
|
||||||
|
LIB8STATIC uint8_t squarewave8( uint8_t in, uint8_t pulsewidth)
|
||||||
|
{
|
||||||
|
if( in < pulsewidth || (pulsewidth == 255)) {
|
||||||
|
return 255;
|
||||||
|
} else {
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
// Beat generators - These functions produce waves at a given
|
||||||
|
// number of 'beats per minute'. Internally, they use
|
||||||
|
// the Arduino function 'millis' to track elapsed time.
|
||||||
|
// Accuracy is a bit better than one part in a thousand.
|
||||||
|
//
|
||||||
|
// beat8( BPM ) returns an 8-bit value that cycles 'BPM' times
|
||||||
|
// per minute, rising from 0 to 255, resetting to zero,
|
||||||
|
// rising up again, etc.. The output of this function
|
||||||
|
// is suitable for feeding directly into sin8, and cos8,
|
||||||
|
// triwave8, quadwave8, and cubicwave8.
|
||||||
|
// beat16( BPM ) returns a 16-bit value that cycles 'BPM' times
|
||||||
|
// per minute, rising from 0 to 65535, resetting to zero,
|
||||||
|
// rising up again, etc. The output of this function is
|
||||||
|
// suitable for feeding directly into sin16 and cos16.
|
||||||
|
// beat88( BPM88) is the same as beat16, except that the BPM88 argument
|
||||||
|
// MUST be in Q8.8 fixed point format, e.g. 120BPM must
|
||||||
|
// be specified as 120*256 = 30720.
|
||||||
|
// beatsin8( BPM, uint8_t low, uint8_t high) returns an 8-bit value that
|
||||||
|
// rises and falls in a sine wave, 'BPM' times per minute,
|
||||||
|
// between the values of 'low' and 'high'.
|
||||||
|
// beatsin16( BPM, uint16_t low, uint16_t high) returns a 16-bit value
|
||||||
|
// that rises and falls in a sine wave, 'BPM' times per
|
||||||
|
// minute, between the values of 'low' and 'high'.
|
||||||
|
// beatsin88( BPM88, ...) is the same as beatsin16, except that the
|
||||||
|
// BPM88 argument MUST be in Q8.8 fixed point format,
|
||||||
|
// e.g. 120BPM must be specified as 120*256 = 30720.
|
||||||
|
//
|
||||||
|
// BPM can be supplied two ways. The simpler way of specifying BPM is as
|
||||||
|
// a simple 8-bit integer from 1-255, (e.g., "120").
|
||||||
|
// The more sophisticated way of specifying BPM allows for fractional
|
||||||
|
// "Q8.8" fixed point number (an 'accum88') with an 8-bit integer part and
|
||||||
|
// an 8-bit fractional part. The easiest way to construct this is to multiply
|
||||||
|
// a floating point BPM value (e.g. 120.3) by 256, (e.g. resulting in 30796
|
||||||
|
// in this case), and pass that as the 16-bit BPM argument.
|
||||||
|
// "BPM88" MUST always be specified in Q8.8 format.
|
||||||
|
//
|
||||||
|
// Originally designed to make an entire animation project pulse with brightness.
|
||||||
|
// For that effect, add this line just above your existing call to "FastLED.show()":
|
||||||
|
//
|
||||||
|
// uint8_t bright = beatsin8( 60 /*BPM*/, 192 /*dimmest*/, 255 /*brightest*/ ));
|
||||||
|
// FastLED.setBrightness( bright );
|
||||||
|
// FastLED.show();
|
||||||
|
//
|
||||||
|
// The entire animation will now pulse between brightness 192 and 255 once per second.
|
||||||
|
|
||||||
|
|
||||||
|
// The beat generators need access to a millisecond counter.
|
||||||
|
// On Arduino, this is "millis()". On other platforms, you'll
|
||||||
|
// need to provide a function with this signature:
|
||||||
|
// uint32_t get_millisecond_timer();
|
||||||
|
// that provides similar functionality.
|
||||||
|
// You can also force use of the get_millisecond_timer function
|
||||||
|
// by #defining USE_GET_MILLISECOND_TIMER.
|
||||||
|
#if (defined(ARDUINO) || defined(SPARK) || defined(FASTLED_HAS_MILLIS)) && !defined(USE_GET_MILLISECOND_TIMER)
|
||||||
|
// Forward declaration of Arduino function 'millis'.
|
||||||
|
//uint32_t millis();
|
||||||
|
#define GET_MILLIS millis
|
||||||
|
#else
|
||||||
|
uint32_t get_millisecond_timer(void);
|
||||||
|
#define GET_MILLIS get_millisecond_timer
|
||||||
|
#endif
|
||||||
|
|
||||||
|
// beat16 generates a 16-bit 'sawtooth' wave at a given BPM,
|
||||||
|
/// with BPM specified in Q8.8 fixed-point format; e.g.
|
||||||
|
/// for this function, 120 BPM MUST BE specified as
|
||||||
|
/// 120*256 = 30720.
|
||||||
|
/// If you just want to specify "120", use beat16 or beat8.
|
||||||
|
LIB8STATIC uint16_t beat88( accum88 beats_per_minute_88, uint32_t timebase)
|
||||||
|
{
|
||||||
|
// BPM is 'beats per minute', or 'beats per 60000ms'.
|
||||||
|
// To avoid using the (slower) division operator, we
|
||||||
|
// want to convert 'beats per 60000ms' to 'beats per 65536ms',
|
||||||
|
// and then use a simple, fast bit-shift to divide by 65536.
|
||||||
|
//
|
||||||
|
// The ratio 65536:60000 is 279.620266667:256; we'll call it 280:256.
|
||||||
|
// The conversion is accurate to about 0.05%, more or less,
|
||||||
|
// e.g. if you ask for "120 BPM", you'll get about "119.93".
|
||||||
|
return (((GET_MILLIS()) - timebase) * beats_per_minute_88 * 280) >> 16;
|
||||||
|
}
|
||||||
|
|
||||||
|
/// beat16 generates a 16-bit 'sawtooth' wave at a given BPM
|
||||||
|
LIB8STATIC uint16_t beat16( accum88 beats_per_minute, uint32_t timebase)
|
||||||
|
{
|
||||||
|
// Convert simple 8-bit BPM's to full Q8.8 accum88's if needed
|
||||||
|
if( beats_per_minute < 256) beats_per_minute <<= 8;
|
||||||
|
return beat88(beats_per_minute, timebase);
|
||||||
|
}
|
||||||
|
|
||||||
|
/// beat8 generates an 8-bit 'sawtooth' wave at a given BPM
|
||||||
|
LIB8STATIC uint8_t beat8( accum88 beats_per_minute, uint32_t timebase)
|
||||||
|
{
|
||||||
|
return beat16( beats_per_minute, timebase) >> 8;
|
||||||
|
}
|
||||||
|
|
||||||
|
/// beatsin88 generates a 16-bit sine wave at a given BPM,
|
||||||
|
/// that oscillates within a given range.
|
||||||
|
/// For this function, BPM MUST BE SPECIFIED as
|
||||||
|
/// a Q8.8 fixed-point value; e.g. 120BPM must be
|
||||||
|
/// specified as 120*256 = 30720.
|
||||||
|
/// If you just want to specify "120", use beatsin16 or beatsin8.
|
||||||
|
LIB8STATIC uint16_t beatsin88( accum88 beats_per_minute_88, uint16_t lowest, uint16_t highest, uint32_t timebase, uint16_t phase_offset)
|
||||||
|
{
|
||||||
|
uint16_t beat = beat88( beats_per_minute_88, timebase);
|
||||||
|
uint16_t beatsin = (sin16( beat + phase_offset) + 32768);
|
||||||
|
uint16_t rangewidth = highest - lowest;
|
||||||
|
uint16_t scaledbeat = scale16( beatsin, rangewidth);
|
||||||
|
uint16_t result = lowest + scaledbeat;
|
||||||
|
return result;
|
||||||
|
}
|
||||||
|
|
||||||
|
/// beatsin16 generates a 16-bit sine wave at a given BPM,
|
||||||
|
/// that oscillates within a given range.
|
||||||
|
LIB8STATIC uint16_t beatsin16(accum88 beats_per_minute, uint16_t lowest, uint16_t highest, uint32_t timebase, uint16_t phase_offset)
|
||||||
|
{
|
||||||
|
uint16_t beat = beat16( beats_per_minute, timebase);
|
||||||
|
uint16_t beatsin = (sin16( beat + phase_offset) + 32768);
|
||||||
|
uint16_t rangewidth = highest - lowest;
|
||||||
|
uint16_t scaledbeat = scale16( beatsin, rangewidth);
|
||||||
|
uint16_t result = lowest + scaledbeat;
|
||||||
|
return result;
|
||||||
|
}
|
||||||
|
|
||||||
|
/// beatsin8 generates an 8-bit sine wave at a given BPM,
|
||||||
|
/// that oscillates within a given range.
|
||||||
|
LIB8STATIC uint8_t beatsin8( accum88 beats_per_minute, uint8_t lowest, uint8_t highest, uint32_t timebase, uint8_t phase_offset)
|
||||||
|
{
|
||||||
|
uint8_t beat = beat8( beats_per_minute, timebase);
|
||||||
|
uint8_t beatsin = sin8( beat + phase_offset);
|
||||||
|
uint8_t rangewidth = highest - lowest;
|
||||||
|
uint8_t scaledbeat = scale8( beatsin, rangewidth);
|
||||||
|
uint8_t result = lowest + scaledbeat;
|
||||||
|
return result;
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
/// Return the current seconds since boot in a 16-bit value. Used as part of the
|
||||||
|
/// "every N time-periods" mechanism
|
||||||
|
LIB8STATIC uint16_t seconds16(void)
|
||||||
|
{
|
||||||
|
uint32_t ms = GET_MILLIS();
|
||||||
|
uint16_t s16;
|
||||||
|
s16 = ms / 1000;
|
||||||
|
return s16;
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Return the current minutes since boot in a 16-bit value. Used as part of the
|
||||||
|
/// "every N time-periods" mechanism
|
||||||
|
LIB8STATIC uint16_t minutes16(void)
|
||||||
|
{
|
||||||
|
uint32_t ms = GET_MILLIS();
|
||||||
|
uint16_t m16;
|
||||||
|
m16 = (ms / (60000L)) & 0xFFFF;
|
||||||
|
return m16;
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Return the current hours since boot in an 8-bit value. Used as part of the
|
||||||
|
/// "every N time-periods" mechanism
|
||||||
|
LIB8STATIC uint8_t hours8(void)
|
||||||
|
{
|
||||||
|
uint32_t ms = GET_MILLIS();
|
||||||
|
uint8_t h8;
|
||||||
|
h8 = (ms / (3600000L)) & 0xFF;
|
||||||
|
return h8;
|
||||||
|
}
|
||||||
|
|
||||||
|
///@}
|
||||||
|
|
||||||
|
#endif
|
||||||
@ -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
|
||||||
|
uint16_t 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
|
||||||
|
int16_t 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
|
||||||
|
uint16_t 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
|
||||||
|
int16_t 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 ((uint16_t)i * (uint16_t)(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 = ((uint16_t)i * (uint16_t)(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
|
||||||
@ -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(void)
|
||||||
|
{
|
||||||
|
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(void)
|
||||||
|
{
|
||||||
|
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_max(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_min_max(uint8_t min, uint8_t lim)
|
||||||
|
{
|
||||||
|
uint8_t delta = lim - min;
|
||||||
|
uint8_t r = random8_max(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_max(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_min_max( uint16_t min, uint16_t lim)
|
||||||
|
{
|
||||||
|
uint16_t delta = lim - min;
|
||||||
|
uint16_t r = random16_max(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(void)
|
||||||
|
{
|
||||||
|
return rand16seed;
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Add entropy into the random number generator
|
||||||
|
LIB8STATIC void random16_add_entropy(uint16_t entropy)
|
||||||
|
{
|
||||||
|
rand16seed += entropy;
|
||||||
|
}
|
||||||
|
|
||||||
|
///@}
|
||||||
|
|
||||||
|
#endif
|
||||||
@ -0,0 +1,542 @@
|
|||||||
|
#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
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
/// 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
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Clean up the r1 register after a series of *LEAVING_R1_DIRTY calls
|
||||||
|
LIB8STATIC_ALWAYS_INLINE void cleanup_R1(void)
|
||||||
|
{
|
||||||
|
#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 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
|
||||||
@ -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
|
||||||
@ -0,0 +1,26 @@
|
|||||||
|
#pragma once
|
||||||
|
#ifndef DISABLE_RGB_MATRIX_ALPHAS_MODS
|
||||||
|
|
||||||
|
extern const rgb_led g_rgb_leds[DRIVER_LED_TOTAL];
|
||||||
|
extern rgb_config_t rgb_matrix_config;
|
||||||
|
|
||||||
|
// alphas = color1, mods = color2
|
||||||
|
bool rgb_matrix_alphas_mods(bool init, uint8_t iter) {
|
||||||
|
RGB_MATRIX_USE_LIMITS(led_min, led_max);
|
||||||
|
|
||||||
|
HSV hsv = { rgb_matrix_config.hue, rgb_matrix_config.sat, rgb_matrix_config.val };
|
||||||
|
RGB rgb1 = hsv_to_rgb(hsv);
|
||||||
|
hsv.h += rgb_matrix_config.speed;
|
||||||
|
RGB rgb2 = hsv_to_rgb(hsv);
|
||||||
|
|
||||||
|
for (uint8_t i = led_min; i < led_max; i++) {
|
||||||
|
if (g_rgb_leds[i].modifier) {
|
||||||
|
rgb_matrix_set_color(i, rgb2.r, rgb2.g, rgb2.b);
|
||||||
|
} else {
|
||||||
|
rgb_matrix_set_color(i, rgb1.r, rgb1.g, rgb1.b);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return led_max < DRIVER_LED_TOTAL;
|
||||||
|
}
|
||||||
|
|
||||||
|
#endif // DISABLE_RGB_MATRIX_ALPHAS_MODS
|
||||||
@ -0,0 +1,19 @@
|
|||||||
|
#pragma once
|
||||||
|
#ifndef DISABLE_RGB_MATRIX_BREATHING
|
||||||
|
|
||||||
|
extern rgb_config_t rgb_matrix_config;
|
||||||
|
|
||||||
|
bool rgb_matrix_breathing(bool init, uint8_t iter) {
|
||||||
|
RGB_MATRIX_USE_LIMITS(led_min, led_max);
|
||||||
|
|
||||||
|
uint16_t time = scale16by8(g_rgb_counters.tick, rgb_matrix_config.speed / 8);
|
||||||
|
uint8_t val = scale8(abs8(sin8(time) - 128) * 2, rgb_matrix_config.val);
|
||||||
|
HSV hsv = { rgb_matrix_config.hue, rgb_matrix_config.sat, val };
|
||||||
|
RGB rgb = hsv_to_rgb(hsv);
|
||||||
|
for (uint8_t i = led_min; i < led_max; i++) {
|
||||||
|
rgb_matrix_set_color(i, rgb.r, rgb.g, rgb.b);
|
||||||
|
}
|
||||||
|
return led_max < DRIVER_LED_TOTAL;
|
||||||
|
}
|
||||||
|
|
||||||
|
#endif // DISABLE_RGB_MATRIX_BREATHING
|
||||||
@ -0,0 +1,21 @@
|
|||||||
|
#pragma once
|
||||||
|
#ifndef DISABLE_RGB_MATRIX_CYCLE_ALL
|
||||||
|
|
||||||
|
extern rgb_counters_t g_rgb_counters;
|
||||||
|
extern const rgb_led g_rgb_leds[DRIVER_LED_TOTAL];
|
||||||
|
extern rgb_config_t rgb_matrix_config;
|
||||||
|
|
||||||
|
bool rgb_matrix_cycle_all(bool init, uint8_t iter) {
|
||||||
|
RGB_MATRIX_USE_LIMITS(led_min, led_max);
|
||||||
|
|
||||||
|
HSV hsv = { 0, rgb_matrix_config.sat, rgb_matrix_config.val };
|
||||||
|
uint8_t time = scale16by8(g_rgb_counters.tick, rgb_matrix_config.speed / 4);
|
||||||
|
for (uint8_t i = led_min; i < led_max; i++) {
|
||||||
|
hsv.h = time;
|
||||||
|
RGB rgb = hsv_to_rgb(hsv);
|
||||||
|
rgb_matrix_set_color(i, rgb.r, rgb.g, rgb.b);
|
||||||
|
}
|
||||||
|
return led_max < DRIVER_LED_TOTAL;
|
||||||
|
}
|
||||||
|
|
||||||
|
#endif // DISABLE_RGB_MATRIX_CYCLE_ALL
|
||||||
@ -0,0 +1,22 @@
|
|||||||
|
#pragma once
|
||||||
|
#ifndef DISABLE_RGB_MATRIX_CYCLE_LEFT_RIGHT
|
||||||
|
|
||||||
|
extern rgb_counters_t g_rgb_counters;
|
||||||
|
extern const rgb_led g_rgb_leds[DRIVER_LED_TOTAL];
|
||||||
|
extern rgb_config_t rgb_matrix_config;
|
||||||
|
|
||||||
|
bool rgb_matrix_cycle_left_right(bool init, uint8_t iter) {
|
||||||
|
RGB_MATRIX_USE_LIMITS(led_min, led_max);
|
||||||
|
|
||||||
|
HSV hsv = { 0, rgb_matrix_config.sat, rgb_matrix_config.val };
|
||||||
|
uint8_t time = scale16by8(g_rgb_counters.tick, rgb_matrix_config.speed / 4);
|
||||||
|
for (uint8_t i = led_min; i < led_max; i++) {
|
||||||
|
point_t point = g_rgb_leds[i].point;
|
||||||
|
hsv.h = point.x - time;
|
||||||
|
RGB rgb = hsv_to_rgb(hsv);
|
||||||
|
rgb_matrix_set_color(i, rgb.r, rgb.g, rgb.b);
|
||||||
|
}
|
||||||
|
return led_max < DRIVER_LED_TOTAL;
|
||||||
|
}
|
||||||
|
|
||||||
|
#endif // DISABLE_RGB_MATRIX_CYCLE_LEFT_RIGHT
|
||||||
@ -0,0 +1,22 @@
|
|||||||
|
#pragma once
|
||||||
|
#ifndef DISABLE_RGB_MATRIX_CYCLE_UP_DOWN
|
||||||
|
|
||||||
|
extern rgb_counters_t g_rgb_counters;
|
||||||
|
extern const rgb_led g_rgb_leds[DRIVER_LED_TOTAL];
|
||||||
|
extern rgb_config_t rgb_matrix_config;
|
||||||
|
|
||||||
|
bool rgb_matrix_cycle_up_down(bool init, uint8_t iter) {
|
||||||
|
RGB_MATRIX_USE_LIMITS(led_min, led_max);
|
||||||
|
|
||||||
|
HSV hsv = { 0, rgb_matrix_config.sat, rgb_matrix_config.val };
|
||||||
|
uint8_t time = scale16by8(g_rgb_counters.tick, rgb_matrix_config.speed / 4);
|
||||||
|
for (uint8_t i = led_min; i < led_max; i++) {
|
||||||
|
point_t point = g_rgb_leds[i].point;
|
||||||
|
hsv.h = point.y - time;
|
||||||
|
RGB rgb = hsv_to_rgb(hsv);
|
||||||
|
rgb_matrix_set_color(i, rgb.r, rgb.g, rgb.b);
|
||||||
|
}
|
||||||
|
return led_max < DRIVER_LED_TOTAL;
|
||||||
|
}
|
||||||
|
|
||||||
|
#endif // DISABLE_RGB_MATRIX_CYCLE_UP_DOWN
|
||||||
@ -0,0 +1,74 @@
|
|||||||
|
#pragma once
|
||||||
|
#ifndef DISABLE_RGB_MATRIX_DIGITAL_RAIN
|
||||||
|
|
||||||
|
#ifndef RGB_DIGITAL_RAIN_DROPS
|
||||||
|
// lower the number for denser effect/wider keyboard
|
||||||
|
#define RGB_DIGITAL_RAIN_DROPS 24
|
||||||
|
#endif
|
||||||
|
|
||||||
|
bool rgb_matrix_digital_rain(bool init, uint8_t iter) {
|
||||||
|
// algorithm ported from https://github.com/tremby/Kaleidoscope-LEDEffect-DigitalRain
|
||||||
|
const uint8_t drop_ticks = 28;
|
||||||
|
const uint8_t pure_green_intensity = 0xd0;
|
||||||
|
const uint8_t max_brightness_boost = 0xc0;
|
||||||
|
const uint8_t max_intensity = 0xff;
|
||||||
|
|
||||||
|
static uint8_t map[MATRIX_COLS][MATRIX_ROWS] = {{0}};
|
||||||
|
static uint8_t drop = 0;
|
||||||
|
|
||||||
|
if (init) {
|
||||||
|
rgb_matrix_set_color_all(0, 0, 0);
|
||||||
|
memset(map, 0, sizeof map);
|
||||||
|
drop = 0;
|
||||||
|
}
|
||||||
|
for (uint8_t col = 0; col < MATRIX_COLS; col++) {
|
||||||
|
for (uint8_t row = 0; row < MATRIX_ROWS; row++) {
|
||||||
|
if (row == 0 && drop == 0 && rand() < RAND_MAX / RGB_DIGITAL_RAIN_DROPS) {
|
||||||
|
// top row, pixels have just fallen and we're
|
||||||
|
// making a new rain drop in this column
|
||||||
|
map[col][row] = max_intensity;
|
||||||
|
}
|
||||||
|
else if (map[col][row] > 0 && map[col][row] < max_intensity) {
|
||||||
|
// neither fully bright nor dark, decay it
|
||||||
|
map[col][row]--;
|
||||||
|
}
|
||||||
|
// set the pixel colour
|
||||||
|
uint8_t led[LED_HITS_TO_REMEMBER];
|
||||||
|
uint8_t led_count = rgb_matrix_map_row_column_to_led(row, col, led);
|
||||||
|
|
||||||
|
// TODO: multiple leds are supported mapped to the same row/column
|
||||||
|
if (led_count > 0) {
|
||||||
|
if (map[col][row] > pure_green_intensity) {
|
||||||
|
const uint8_t boost = (uint8_t) ((uint16_t) max_brightness_boost * (map[col][row] - pure_green_intensity) / (max_intensity - pure_green_intensity));
|
||||||
|
rgb_matrix_set_color(led[0], boost, max_intensity, boost);
|
||||||
|
}
|
||||||
|
else {
|
||||||
|
const uint8_t green = (uint8_t) ((uint16_t) max_intensity * map[col][row] / pure_green_intensity);
|
||||||
|
rgb_matrix_set_color(led[0], 0, green, 0);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if (++drop > drop_ticks) {
|
||||||
|
// reset drop timer
|
||||||
|
drop = 0;
|
||||||
|
for (uint8_t row = MATRIX_ROWS - 1; row > 0; row--) {
|
||||||
|
for (uint8_t col = 0; col < MATRIX_COLS; col++) {
|
||||||
|
// if ths is on the bottom row and bright allow decay
|
||||||
|
if (row == MATRIX_ROWS - 1 && map[col][row] == max_intensity) {
|
||||||
|
map[col][row]--;
|
||||||
|
}
|
||||||
|
// check if the pixel above is bright
|
||||||
|
if (map[col][row - 1] == max_intensity) {
|
||||||
|
// allow old bright pixel to decay
|
||||||
|
map[col][row - 1]--;
|
||||||
|
// make this pixel bright
|
||||||
|
map[col][row] = max_intensity;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
|
#endif // DISABLE_RGB_MATRIX_DIGITAL_RAIN
|
||||||
@ -0,0 +1,24 @@
|
|||||||
|
#pragma once
|
||||||
|
#ifndef DISABLE_RGB_MATRIX_DUAL_BEACON
|
||||||
|
|
||||||
|
extern rgb_counters_t g_rgb_counters;
|
||||||
|
extern const rgb_led g_rgb_leds[DRIVER_LED_TOTAL];
|
||||||
|
extern rgb_config_t rgb_matrix_config;
|
||||||
|
|
||||||
|
bool rgb_matrix_dual_beacon(bool init, uint8_t iter) {
|
||||||
|
RGB_MATRIX_USE_LIMITS(led_min, led_max);
|
||||||
|
|
||||||
|
HSV hsv = { 0, rgb_matrix_config.sat, rgb_matrix_config.val };
|
||||||
|
uint16_t time = scale16by8(g_rgb_counters.tick, rgb_matrix_config.speed / 4);
|
||||||
|
int8_t cos_value = cos8(time) - 128;
|
||||||
|
int8_t sin_value = sin8(time) - 128;
|
||||||
|
for (uint8_t i = led_min; i < led_max; i++) {
|
||||||
|
point_t point = g_rgb_leds[i].point;
|
||||||
|
hsv.h = ((point.y - 32) * cos_value + (point.x - 112) * sin_value) / 128 + rgb_matrix_config.hue;
|
||||||
|
RGB rgb = hsv_to_rgb(hsv);
|
||||||
|
rgb_matrix_set_color(i, rgb.r, rgb.g, rgb.b);
|
||||||
|
}
|
||||||
|
return led_max < DRIVER_LED_TOTAL;
|
||||||
|
}
|
||||||
|
|
||||||
|
#endif // DISABLE_RGB_MATRIX_DUAL_BEACON
|
||||||
@ -0,0 +1,22 @@
|
|||||||
|
#pragma once
|
||||||
|
#ifndef DISABLE_RGB_MATRIX_GRADIENT_UP_DOWN
|
||||||
|
|
||||||
|
extern const rgb_led g_rgb_leds[DRIVER_LED_TOTAL];
|
||||||
|
extern rgb_config_t rgb_matrix_config;
|
||||||
|
|
||||||
|
bool rgb_matrix_gradient_up_down(bool init, uint8_t iter) {
|
||||||
|
RGB_MATRIX_USE_LIMITS(led_min, led_max);
|
||||||
|
|
||||||
|
HSV hsv = { 0, rgb_matrix_config.sat, rgb_matrix_config.val };
|
||||||
|
uint8_t scale = scale8(64, rgb_matrix_config.speed);
|
||||||
|
for (uint8_t i = led_min; i < led_max; i++) {
|
||||||
|
point_t point = g_rgb_leds[i].point;
|
||||||
|
// The y range will be 0..64, map this to 0..4
|
||||||
|
// Relies on hue being 8-bit and wrapping
|
||||||
|
hsv.h = rgb_matrix_config.hue + scale * (point.y >> 4);
|
||||||
|
RGB rgb = hsv_to_rgb(hsv);
|
||||||
|
rgb_matrix_set_color(i, rgb.r, rgb.g, rgb.b);
|
||||||
|
}
|
||||||
|
return led_max < DRIVER_LED_TOTAL;
|
||||||
|
}
|
||||||
|
#endif // DISABLE_RGB_MATRIX_GRADIENT_UP_DOWN
|
||||||
@ -0,0 +1,30 @@
|
|||||||
|
#pragma once
|
||||||
|
#ifndef DISABLE_RGB_MATRIX_JELLYBEAN_RAINDROPS
|
||||||
|
|
||||||
|
extern rgb_counters_t g_rgb_counters;
|
||||||
|
extern const rgb_led g_rgb_leds[DRIVER_LED_TOTAL];
|
||||||
|
extern rgb_config_t rgb_matrix_config;
|
||||||
|
|
||||||
|
static void jellybean_raindrops_set_color(int i) {
|
||||||
|
HSV hsv = { rand() & 0xFF , rand() & 0xFF, rgb_matrix_config.val };
|
||||||
|
RGB rgb = hsv_to_rgb(hsv);
|
||||||
|
rgb_matrix_set_color(i, rgb.r, rgb.g, rgb.b);
|
||||||
|
}
|
||||||
|
|
||||||
|
bool rgb_matrix_jellybean_raindrops(bool init, uint8_t iter) {
|
||||||
|
if (!init) {
|
||||||
|
// Change one LED every tick, make sure speed is not 0
|
||||||
|
if (scale16by8(g_rgb_counters.tick, qadd8(rgb_matrix_config.speed, 16)) % 5 == 0) {
|
||||||
|
jellybean_raindrops_set_color(rand() % DRIVER_LED_TOTAL);
|
||||||
|
}
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
|
RGB_MATRIX_USE_LIMITS(led_min, led_max);
|
||||||
|
for (int i = led_min; i < led_max; i++) {
|
||||||
|
jellybean_raindrops_set_color(i);
|
||||||
|
}
|
||||||
|
return led_max < DRIVER_LED_TOTAL;
|
||||||
|
}
|
||||||
|
|
||||||
|
#endif // DISABLE_RGB_MATRIX_JELLYBEAN_RAINDROPS
|
||||||
@ -0,0 +1,24 @@
|
|||||||
|
#pragma once
|
||||||
|
#ifndef DISABLE_RGB_MATRIX_RAINBOW_BEACON
|
||||||
|
|
||||||
|
extern rgb_counters_t g_rgb_counters;
|
||||||
|
extern const rgb_led g_rgb_leds[DRIVER_LED_TOTAL];
|
||||||
|
extern rgb_config_t rgb_matrix_config;
|
||||||
|
|
||||||
|
bool rgb_matrix_rainbow_beacon(bool init, uint8_t iter) {
|
||||||
|
RGB_MATRIX_USE_LIMITS(led_min, led_max);
|
||||||
|
|
||||||
|
HSV hsv = { 0, rgb_matrix_config.sat, rgb_matrix_config.val };
|
||||||
|
uint16_t time = scale16by8(g_rgb_counters.tick, rgb_matrix_config.speed / 4);
|
||||||
|
int16_t cos_value = 2 * (cos8(time) - 128);
|
||||||
|
int16_t sin_value = 2 * (sin8(time) - 128);
|
||||||
|
for (uint8_t i = led_min; i < led_max; i++) {
|
||||||
|
point_t point = g_rgb_leds[i].point;
|
||||||
|
hsv.h = ((point.y - 32) * cos_value + (point.x - 112) * sin_value) / 128 + rgb_matrix_config.hue;
|
||||||
|
RGB rgb = hsv_to_rgb(hsv);
|
||||||
|
rgb_matrix_set_color(i, rgb.r, rgb.g, rgb.b);
|
||||||
|
}
|
||||||
|
return led_max < DRIVER_LED_TOTAL;
|
||||||
|
}
|
||||||
|
|
||||||
|
#endif // DISABLE_RGB_MATRIX_RAINBOW_BEACON
|
||||||
@ -0,0 +1,22 @@
|
|||||||
|
#pragma once
|
||||||
|
#ifndef DISABLE_RGB_MATRIX_RAINBOW_MOVING_CHEVRON
|
||||||
|
|
||||||
|
extern rgb_counters_t g_rgb_counters;
|
||||||
|
extern const rgb_led g_rgb_leds[DRIVER_LED_TOTAL];
|
||||||
|
extern rgb_config_t rgb_matrix_config;
|
||||||
|
|
||||||
|
bool rgb_matrix_rainbow_moving_chevron(bool init, uint8_t iter) {
|
||||||
|
RGB_MATRIX_USE_LIMITS(led_min, led_max);
|
||||||
|
|
||||||
|
HSV hsv = { 0, rgb_matrix_config.sat, rgb_matrix_config.val };
|
||||||
|
uint8_t time = scale16by8(g_rgb_counters.tick, rgb_matrix_config.speed / 4);
|
||||||
|
for (uint8_t i = led_min; i < led_max; i++) {
|
||||||
|
point_t point = g_rgb_leds[i].point;
|
||||||
|
hsv.h = abs8(point.y - 32) + (point.x - time) + rgb_matrix_config.hue;
|
||||||
|
RGB rgb = hsv_to_rgb(hsv);
|
||||||
|
rgb_matrix_set_color(i, rgb.r, rgb.g, rgb.b);
|
||||||
|
}
|
||||||
|
return led_max < DRIVER_LED_TOTAL;
|
||||||
|
}
|
||||||
|
|
||||||
|
#endif // DISABLE_RGB_MATRIX_RAINBOW_MOVING_CHEVRON
|
||||||
@ -0,0 +1,24 @@
|
|||||||
|
#pragma once
|
||||||
|
#ifndef DISABLE_RGB_MATRIX_RAINBOW_PINWHEELS
|
||||||
|
|
||||||
|
extern rgb_counters_t g_rgb_counters;
|
||||||
|
extern const rgb_led g_rgb_leds[DRIVER_LED_TOTAL];
|
||||||
|
extern rgb_config_t rgb_matrix_config;
|
||||||
|
|
||||||
|
bool rgb_matrix_rainbow_pinwheels(bool init, uint8_t iter) {
|
||||||
|
RGB_MATRIX_USE_LIMITS(led_min, led_max);
|
||||||
|
|
||||||
|
HSV hsv = { 0, rgb_matrix_config.sat, rgb_matrix_config.val };
|
||||||
|
uint16_t time = scale16by8(g_rgb_counters.tick, rgb_matrix_config.speed / 4);
|
||||||
|
int16_t cos_value = 3 * (cos8(time) - 128);
|
||||||
|
int16_t sin_value = 3 * (sin8(time) - 128);
|
||||||
|
for (uint8_t i = led_min; i < led_max; i++) {
|
||||||
|
point_t point = g_rgb_leds[i].point;
|
||||||
|
hsv.h = ((point.y - 32) * cos_value + (56 - abs8(point.x - 112)) * sin_value) / 128 + rgb_matrix_config.hue;
|
||||||
|
RGB rgb = hsv_to_rgb(hsv);
|
||||||
|
rgb_matrix_set_color(i, rgb.r, rgb.g, rgb.b);
|
||||||
|
}
|
||||||
|
return led_max < DRIVER_LED_TOTAL;
|
||||||
|
}
|
||||||
|
|
||||||
|
#endif // DISABLE_RGB_MATRIX_RAINBOW_PINWHEELS
|
||||||
@ -0,0 +1,40 @@
|
|||||||
|
#pragma once
|
||||||
|
#ifndef DISABLE_RGB_MATRIX_RAINDROPS
|
||||||
|
#include "rgb_matrix_types.h"
|
||||||
|
|
||||||
|
extern rgb_counters_t g_rgb_counters;
|
||||||
|
extern rgb_config_t rgb_matrix_config;
|
||||||
|
|
||||||
|
static void raindrops_set_color(int i) {
|
||||||
|
HSV hsv = { 0 , rgb_matrix_config.sat, rgb_matrix_config.val };
|
||||||
|
|
||||||
|
// Take the shortest path between hues
|
||||||
|
int16_t deltaH = ((rgb_matrix_config.hue + 180) % 360 - rgb_matrix_config.hue) / 4;
|
||||||
|
if (deltaH > 127) {
|
||||||
|
deltaH -= 256;
|
||||||
|
} else if (deltaH < -127) {
|
||||||
|
deltaH += 256;
|
||||||
|
}
|
||||||
|
|
||||||
|
hsv.h = rgb_matrix_config.hue + (deltaH * (rand() & 0x03));
|
||||||
|
RGB rgb = hsv_to_rgb(hsv);
|
||||||
|
rgb_matrix_set_color(i, rgb.r, rgb.g, rgb.b);
|
||||||
|
}
|
||||||
|
|
||||||
|
bool rgb_matrix_raindrops(bool init, uint8_t iter) {
|
||||||
|
if (!init) {
|
||||||
|
// Change one LED every tick, make sure speed is not 0
|
||||||
|
if (scale16by8(g_rgb_counters.tick, qadd8(rgb_matrix_config.speed, 16)) % 10 == 0) {
|
||||||
|
raindrops_set_color(rand() % DRIVER_LED_TOTAL);
|
||||||
|
}
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
|
RGB_MATRIX_USE_LIMITS(led_min, led_max);
|
||||||
|
for (int i = led_min; i < led_max; i++) {
|
||||||
|
raindrops_set_color(i);
|
||||||
|
}
|
||||||
|
return led_max < DRIVER_LED_TOTAL;
|
||||||
|
}
|
||||||
|
|
||||||
|
#endif // DISABLE_RGB_MATRIX_RAINDROPS
|
||||||
@ -0,0 +1,14 @@
|
|||||||
|
#pragma once
|
||||||
|
|
||||||
|
extern rgb_config_t rgb_matrix_config;
|
||||||
|
|
||||||
|
bool rgb_matrix_solid_color(bool init, uint8_t iter) {
|
||||||
|
RGB_MATRIX_USE_LIMITS(led_min, led_max);
|
||||||
|
|
||||||
|
HSV hsv = { rgb_matrix_config.hue, rgb_matrix_config.sat, rgb_matrix_config.val };
|
||||||
|
RGB rgb = hsv_to_rgb(hsv);
|
||||||
|
for (uint8_t i = led_min; i < led_max; i++) {
|
||||||
|
rgb_matrix_set_color(i, rgb.r, rgb.g, rgb.b);
|
||||||
|
}
|
||||||
|
return led_max < DRIVER_LED_TOTAL;
|
||||||
|
}
|
||||||
@ -0,0 +1,33 @@
|
|||||||
|
#pragma once
|
||||||
|
#ifdef RGB_MATRIX_KEYPRESSES
|
||||||
|
#ifndef DISABLE_RGB_MATRIX_SOLID_REACTIVE
|
||||||
|
|
||||||
|
extern rgb_config_t rgb_matrix_config;
|
||||||
|
extern last_hit_t g_last_hit_tracker;
|
||||||
|
|
||||||
|
bool rgb_matrix_solid_reactive(bool init, uint8_t iter) {
|
||||||
|
RGB_MATRIX_USE_LIMITS(led_min, led_max);
|
||||||
|
|
||||||
|
HSV hsv = { rgb_matrix_config.hue, 255, rgb_matrix_config.val };
|
||||||
|
// Max tick based on speed scale ensures results from scale16by8 with rgb_matrix_config.speed are no greater than 255
|
||||||
|
uint16_t max_tick = 65535 / rgb_matrix_config.speed;
|
||||||
|
// Relies on hue being 8-bit and wrapping
|
||||||
|
for (uint8_t i = led_min; i < led_max; i++) {
|
||||||
|
uint16_t tick = max_tick;
|
||||||
|
for(uint8_t j = 0; j < g_last_hit_tracker.count; j++) {
|
||||||
|
if (g_last_hit_tracker.index[j] == i && g_last_hit_tracker.tick[j] < tick) {
|
||||||
|
tick = g_last_hit_tracker.tick[j];
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
uint16_t offset = scale16by8(tick, rgb_matrix_config.speed);
|
||||||
|
hsv.h = rgb_matrix_config.hue + qsub8(130, offset);
|
||||||
|
RGB rgb = hsv_to_rgb(hsv);
|
||||||
|
rgb_matrix_set_color(i, rgb.r, rgb.g, rgb.b);
|
||||||
|
}
|
||||||
|
return led_max < DRIVER_LED_TOTAL;
|
||||||
|
}
|
||||||
|
|
||||||
|
#endif // DISABLE_RGB_MATRIX_RAINBOW_MOVING_CHEVRON
|
||||||
|
#endif // RGB_MATRIX_KEYPRESSES
|
||||||
@ -0,0 +1,32 @@
|
|||||||
|
#pragma once
|
||||||
|
#ifdef RGB_MATRIX_KEYPRESSES
|
||||||
|
#ifndef DISABLE_RGB_MATRIX_SOLID_REACTIVE_SIMPLE
|
||||||
|
|
||||||
|
extern rgb_config_t rgb_matrix_config;
|
||||||
|
extern last_hit_t g_last_hit_tracker;
|
||||||
|
|
||||||
|
bool rgb_matrix_solid_reactive_simple(bool init, uint8_t iter) {
|
||||||
|
RGB_MATRIX_USE_LIMITS(led_min, led_max);
|
||||||
|
|
||||||
|
HSV hsv = { rgb_matrix_config.hue, rgb_matrix_config.sat, 0 };
|
||||||
|
// Max tick based on speed scale ensures results from scale16by8 with rgb_matrix_config.speed are no greater than 255
|
||||||
|
uint16_t max_tick = 65535 / rgb_matrix_config.speed;
|
||||||
|
for (uint8_t i = led_min; i < led_max; i++) {
|
||||||
|
uint16_t tick = max_tick;
|
||||||
|
for(uint8_t j = 0; j < g_last_hit_tracker.count; j++) {
|
||||||
|
if (g_last_hit_tracker.index[j] == i && g_last_hit_tracker.tick[j] < tick) {
|
||||||
|
tick = g_last_hit_tracker.tick[j];
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
uint16_t offset = scale16by8(tick, rgb_matrix_config.speed);
|
||||||
|
hsv.v = scale8(255 - offset, rgb_matrix_config.val);
|
||||||
|
RGB rgb = hsv_to_rgb(hsv);
|
||||||
|
rgb_matrix_set_color(i, rgb.r, rgb.g, rgb.b);
|
||||||
|
}
|
||||||
|
return led_max < DRIVER_LED_TOTAL;
|
||||||
|
}
|
||||||
|
|
||||||
|
#endif // DISABLE_RGB_MATRIX_SOLID_REACTIVE_SIMPLE
|
||||||
|
#endif // RGB_MATRIX_KEYPRESSES
|
||||||
@ -0,0 +1,42 @@
|
|||||||
|
#pragma once
|
||||||
|
#ifdef RGB_MATRIX_KEYPRESSES
|
||||||
|
#if !defined(DISABLE_RGB_MATRIX_SOLID_SPLASH) || !defined(DISABLE_RGB_MATRIX_SOLID_MULTISPLASH)
|
||||||
|
|
||||||
|
extern const rgb_led g_rgb_leds[DRIVER_LED_TOTAL];
|
||||||
|
extern rgb_config_t rgb_matrix_config;
|
||||||
|
extern last_hit_t g_last_hit_tracker;
|
||||||
|
|
||||||
|
static bool rgb_matrix_solid_multisplash_range(uint8_t start, uint8_t iter) {
|
||||||
|
RGB_MATRIX_USE_LIMITS(led_min, led_max);
|
||||||
|
|
||||||
|
HSV hsv = { rgb_matrix_config.hue, rgb_matrix_config.sat, 0 };
|
||||||
|
uint8_t count = g_last_hit_tracker.count;
|
||||||
|
for (uint8_t i = led_min; i < led_max; i++) {
|
||||||
|
hsv.v = 0;
|
||||||
|
point_t point = g_rgb_leds[i].point;
|
||||||
|
for (uint8_t j = start; j < count; j++) {
|
||||||
|
int16_t dx = point.x - g_last_hit_tracker.x[j];
|
||||||
|
int16_t dy = point.y - g_last_hit_tracker.y[j];
|
||||||
|
uint8_t dist = sqrt16(dx * dx + dy * dy);
|
||||||
|
uint16_t effect = scale16by8(g_last_hit_tracker.tick[j], rgb_matrix_config.speed) - dist;
|
||||||
|
if (effect > 255)
|
||||||
|
effect = 255;
|
||||||
|
hsv.v = qadd8(hsv.v, 255 - effect);
|
||||||
|
}
|
||||||
|
hsv.v = scale8(hsv.v, rgb_matrix_config.val);
|
||||||
|
RGB rgb = hsv_to_rgb(hsv);
|
||||||
|
rgb_matrix_set_color(i, rgb.r, rgb.g, rgb.b);
|
||||||
|
}
|
||||||
|
return led_max < DRIVER_LED_TOTAL;
|
||||||
|
}
|
||||||
|
|
||||||
|
bool rgb_matrix_solid_multisplash(bool init, uint8_t iter) {
|
||||||
|
return rgb_matrix_solid_multisplash_range(0, iter);
|
||||||
|
}
|
||||||
|
|
||||||
|
bool rgb_matrix_solid_splash(bool init, uint8_t iter) {
|
||||||
|
return rgb_matrix_solid_multisplash_range(qsub8(g_last_hit_tracker.count, 1), iter);
|
||||||
|
}
|
||||||
|
|
||||||
|
#endif // !defined(DISABLE_RGB_MATRIX_SPLASH) && !defined(DISABLE_RGB_MATRIX_MULTISPLASH)
|
||||||
|
#endif // RGB_MATRIX_KEYPRESSES
|
||||||
@ -0,0 +1,44 @@
|
|||||||
|
#pragma once
|
||||||
|
#ifdef RGB_MATRIX_KEYPRESSES
|
||||||
|
#if !defined(DISABLE_RGB_MATRIX_SPLASH) || !defined(DISABLE_RGB_MATRIX_MULTISPLASH)
|
||||||
|
|
||||||
|
extern const rgb_led g_rgb_leds[DRIVER_LED_TOTAL];
|
||||||
|
extern rgb_config_t rgb_matrix_config;
|
||||||
|
extern last_hit_t g_last_hit_tracker;
|
||||||
|
|
||||||
|
static bool rgb_matrix_multisplash_range(uint8_t start, uint8_t iter) {
|
||||||
|
RGB_MATRIX_USE_LIMITS(led_min, led_max);
|
||||||
|
|
||||||
|
HSV hsv = { 0, rgb_matrix_config.sat, 0 };
|
||||||
|
uint8_t count = g_last_hit_tracker.count;
|
||||||
|
for (uint8_t i = led_min; i < led_max; i++) {
|
||||||
|
hsv.h = rgb_matrix_config.hue;
|
||||||
|
hsv.v = 0;
|
||||||
|
point_t point = g_rgb_leds[i].point;
|
||||||
|
for (uint8_t j = start; j < count; j++) {
|
||||||
|
int16_t dx = point.x - g_last_hit_tracker.x[j];
|
||||||
|
int16_t dy = point.y - g_last_hit_tracker.y[j];
|
||||||
|
uint8_t dist = sqrt16(dx * dx + dy * dy);
|
||||||
|
uint16_t effect = scale16by8(g_last_hit_tracker.tick[j], rgb_matrix_config.speed) - dist;
|
||||||
|
if (effect > 255)
|
||||||
|
effect = 255;
|
||||||
|
hsv.h += effect;
|
||||||
|
hsv.v = qadd8(hsv.v, 255 - effect);
|
||||||
|
}
|
||||||
|
hsv.v = scale8(hsv.v, rgb_matrix_config.val);
|
||||||
|
RGB rgb = hsv_to_rgb(hsv);
|
||||||
|
rgb_matrix_set_color(i, rgb.r, rgb.g, rgb.b);
|
||||||
|
}
|
||||||
|
return led_max < DRIVER_LED_TOTAL;
|
||||||
|
}
|
||||||
|
|
||||||
|
bool rgb_matrix_multisplash(bool init, uint8_t iter) {
|
||||||
|
return rgb_matrix_multisplash_range(0, iter);
|
||||||
|
}
|
||||||
|
|
||||||
|
bool rgb_matrix_splash(bool init, uint8_t iter) {
|
||||||
|
return rgb_matrix_multisplash_range(qsub8(g_last_hit_tracker.count, 1), iter);
|
||||||
|
}
|
||||||
|
|
||||||
|
#endif // !defined(DISABLE_RGB_MATRIX_SPLASH) || !defined(DISABLE_RGB_MATRIX_MULTISPLASH)
|
||||||
|
#endif // RGB_MATRIX_KEYPRESSES
|
||||||
@ -0,0 +1,88 @@
|
|||||||
|
#pragma once
|
||||||
|
|
||||||
|
#include <stdint.h>
|
||||||
|
#include <stdbool.h>
|
||||||
|
|
||||||
|
#if defined(__GNUC__)
|
||||||
|
#define PACKED __attribute__ ((__packed__))
|
||||||
|
#else
|
||||||
|
#define PACKED
|
||||||
|
#endif
|
||||||
|
|
||||||
|
#if defined(_MSC_VER)
|
||||||
|
#pragma pack( push, 1 )
|
||||||
|
#endif
|
||||||
|
|
||||||
|
// Last led hit
|
||||||
|
#ifndef LED_HITS_TO_REMEMBER
|
||||||
|
#define LED_HITS_TO_REMEMBER 8
|
||||||
|
#endif // LED_HITS_TO_REMEMBER
|
||||||
|
|
||||||
|
#if defined(RGB_MATRIX_KEYPRESSES) || defined(RGB_MATRIX_KEYRELEASES)
|
||||||
|
typedef struct PACKED {
|
||||||
|
uint8_t count;
|
||||||
|
uint8_t x[LED_HITS_TO_REMEMBER];
|
||||||
|
uint8_t y[LED_HITS_TO_REMEMBER];
|
||||||
|
uint8_t index[LED_HITS_TO_REMEMBER];
|
||||||
|
uint16_t tick[LED_HITS_TO_REMEMBER];
|
||||||
|
} last_hit_t;
|
||||||
|
#endif // defined(RGB_MATRIX_KEYPRESSES) || defined(RGB_MATRIX_KEYRELEASES)
|
||||||
|
|
||||||
|
typedef enum rgb_task_states {
|
||||||
|
STARTING,
|
||||||
|
RENDERING,
|
||||||
|
FLUSHING,
|
||||||
|
SYNCING
|
||||||
|
} rgb_task_states;
|
||||||
|
|
||||||
|
typedef struct PACKED {
|
||||||
|
// Global tick at 20 Hz
|
||||||
|
uint32_t tick;
|
||||||
|
// Ticks since this key was last hit.
|
||||||
|
uint32_t any_key_hit;
|
||||||
|
} rgb_counters_t;
|
||||||
|
|
||||||
|
typedef struct PACKED {
|
||||||
|
uint8_t x;
|
||||||
|
uint8_t y;
|
||||||
|
} point_t;
|
||||||
|
|
||||||
|
typedef union {
|
||||||
|
uint8_t raw;
|
||||||
|
struct {
|
||||||
|
uint8_t row:4; // 16 max
|
||||||
|
uint8_t col:4; // 16 max
|
||||||
|
};
|
||||||
|
} matrix_co_t;
|
||||||
|
|
||||||
|
typedef struct PACKED {
|
||||||
|
matrix_co_t matrix_co;
|
||||||
|
point_t point;
|
||||||
|
uint8_t modifier:1;
|
||||||
|
} rgb_led;
|
||||||
|
|
||||||
|
/*typedef union {
|
||||||
|
uint32_t raw; // 32 bits
|
||||||
|
struct {
|
||||||
|
bool enable :1; // 1 bit
|
||||||
|
uint8_t mode :7; // 7 bits
|
||||||
|
HSV hsv; // 24 bits
|
||||||
|
uint8_t speed; // 8 bits
|
||||||
|
}; // 40 bits =(
|
||||||
|
} rgb_config_t;*/
|
||||||
|
|
||||||
|
typedef union {
|
||||||
|
uint32_t raw;
|
||||||
|
struct PACKED {
|
||||||
|
bool enable :1;
|
||||||
|
uint8_t mode :7;
|
||||||
|
uint8_t hue :8;
|
||||||
|
uint8_t sat :8;
|
||||||
|
uint8_t val :8;
|
||||||
|
uint8_t speed :8;//EECONFIG needs to be increased to support this
|
||||||
|
};
|
||||||
|
} rgb_config_t;
|
||||||
|
|
||||||
|
#if defined(_MSC_VER)
|
||||||
|
#pragma pack( pop )
|
||||||
|
#endif
|
||||||
Loading…
Reference in new issue