Using Stefan Petrick’s self modifying code example from this page (very NICE) I thought I’d add a knob to adjust the brightness control a bit. Marc Miller pointed me to some code which should work with the Teensy 3.5 but all I get is a strobing display with very little time for movement to occur. I think it’s because I don’t have the code in the right place. Here it is:
/*
A FastLED matrix example:
A simplex noise field fully modulated and controlled by itself
written by
Stefan Petrick 2017
Do with it whatever you like and show your results to the FastLED community
https://plus.google.com/communities/109127054924227823508
*/
#include “FastLED.h”
// matrix size
uint8_t Width = 16;
uint8_t Height = 16;
uint8_t CentreX = (Width / 2) - 1;
uint8_t CentreY = (Height / 2) - 1;
// NUM_LEDS = Width * Height
#define NUM_LEDS 256
#define DATA_PIN 11
#define MASTER_BRIGHTNESS 255
uint8_t min_brightness = 20; // Set a minimum brightness level.
uint8_t brightness; // Mapped master brightness based on potentiometer reading.
CRGB leds[NUM_LEDS];
// added //
int potPinA = A0; // Pin for potentiometer A (for hue)
int potPinB = A1; // Pin for potentiometer B (for brightness)
int potValA; // Variable to store potentiometer A value (for hue)
int potValB; // Variable to store potentiometer B value (for brightness)
uint8_t hue; // Hue color (0-255)
// Gradient palette “bhw1_sunconure_gp”, originally from
// bhw1 | bhw1 sunconure
// converted for FastLED with gammas (2.6, 2.2, 2.5)
// Size: 16 bytes of program space.
DEFINE_GRADIENT_PALETTE( pit5 ) {
0, 20,223, 13,
160, 232, 65, 1,
252, 232, 5, 1,
255, 232, 5, 1};
// Gradient palette “bhw2_23_gp”, originally from
// bhw2 | bhw2 23
// converted for FastLED with gammas (2.6, 2.2, 2.5)
// Size: 28 bytes of program space.
DEFINE_GRADIENT_PALETTE( pit6 ) {
0, 0, 0, 0,
66, 57,227,233,
96, 255,255, 8,
124, 255,255,255,
153, 255,255, 8,
188, 57,227,233,
255, 0, 0, 0};
DEFINE_GRADIENT_PALETTE( pit7 ) { // rainbowsherbet_gp
0, 255, 33, 4,
43, 255, 68, 25,
86, 255, 7, 25,
127, 255, 82,103,
170, 255,255,242,
209, 42,255, 22,
255, 87,255, 65};
// Gradient palette “bhw2_thanks_gp”, originally from
// bhw2 | bhw2 thanks
// converted for FastLED with gammas (2.6, 2.2, 2.5)
// Size: 36 bytes of program space.
DEFINE_GRADIENT_PALETTE( pit4 ) { // multi color hue
0, 9, 5, 1,
48, 25, 9, 1,
76, 137, 27, 1,
96, 98, 42, 1,
124, 144, 79, 1,
153, 98, 42, 1,
178, 137, 27, 1,
211, 23, 9, 1,
255, 9, 5, 1};
DEFINE_GRADIENT_PALETTE( pit1 ) { // red/orange hue Stephan Petrick original
0, 3, 3, 3,
64, 13, 13, 255, //blue
128, 3, 3, 3,
192, 255, 130, 3 , //orange
255, 3, 3, 3
};
DEFINE_GRADIENT_PALETTE ( pit2 ) { // red hue
0, 3, 3, 3,
128, 255, 3, 3,
255, 3, 3, 3 };
DEFINE_GRADIENT_PALETTE ( pit3 ) { // blue hue
0, 3, 3, 3,
128, 3, 3, 255,
255, 3, 3, 3 };
void setup() {
Serial.begin(115200);
// Adjust this for you own setup. Use the hardware SPI pins if possible.
// On Teensy 3.1/3.2 the pins are 11 & 13
// Details here: SPI Hardware or Bit banging · FastLED/FastLED Wiki · GitHub
// In case you see flickering / glitching leds, reduce the data rate to 12 MHZ or less
LEDS.addLeds<APA102, 11, 13, BGR, DATA_RATE_MHZ(8)>(leds, NUM_LEDS).setCorrection(TypicalSMD5050); // 24MHZ
FastLED.setBrightness(MASTER_BRIGHTNESS);
// added //
pinMode(potPinA, INPUT); // Set pin as an input.
pinMode(potPinB, INPUT); // Set pin as an input.
}
// parameters and buffer for the noise array
#define NUM_LAYERS 1
uint32_t x[NUM_LAYERS];
uint32_t y[NUM_LAYERS];
uint32_t z[NUM_LAYERS];
uint32_t scale_x[NUM_LAYERS];
uint32_t scale_y[NUM_LAYERS];
uint8_t noise[1][16][16];
void loop() {
noise_noise1();
checkKnobs(); // Call function to check knob positions.
for (int i = 0; i < NUM_LEDS; i++) {
leds[i] = CHSV(hue, 255, 255); // hue comes from pot A, and brightness value is scaled based on pot B.
}
// check the Serial Monitor to see how many fps you get
// EVERY_N_MILLIS(1000) {
// Serial.println(LEDS.getFPS());
// }
}
// this finds the right index within a serpentine matrix
uint16_t XY( uint8_t x, uint8_t y) {
uint16_t i;
if ( y & 0x01) {
uint8_t reverseX = (Width - 1) - x;
i = (y * Width) + reverseX;
} else {
i = (y * Width) + x;
}
return i;
}
/*
// for a line by line matrix it should be
uint16_t XY( uint8_t x, uint8_t y)
{
uint16_t i;
i = (y * Width) + x;
return i;
}
*/
// added //
void checkKnobs(){
// potValA = analogRead(potPinA); // Read potentiometer A (for hue).
//potValA = map(potValA, 1023, 0, 0, 1023); // Reverse reading if potentiometer is wired backwards.
// hue = map(potValA, 0, 1023, 0, 255); // map(value, fromLow, fromHigh, toLow, toHigh)
potValB = analogRead(potPinB); // Read potentiometer B (for brightness).
brightness = map(potValB, 0, 1023, min_brightness, MASTER_BRIGHTNESS);
// Map value between min_brightness and MASTER brightness values.
// Note: We are limiting the lowest possible brightness value to the
// min_brightness value assigned up top.
}
// cheap correction with gamma 2.0
void adjust_gamma()
{
for (uint16_t i = 0; i < NUM_LEDS; i++)
{
leds[i].r = dim8_video(leds[i].r);
leds[i].g = dim8_video(leds[i].g);
leds[i].b = dim8_video(leds[i].b);
}
}
//as shown on youtube
//a noise controlled & modulated by itself
void noise_noise1() {
CRGBPalette16 Pal( pit1 );
//modulate the position so that it increases/decreases x
//(here based on the top left pixel - it could be any position else)
//the factor “2” defines the max speed of the x movement
//the “-255” defines the median moving direction
x[0] = x[0] + (2 * noise[0][0][0]) - 255;
//modulate the position so that it increases/decreases y
//(here based on the top right pixel - it could be any position else)
y[0] = y[0] + (2 * noise[0][Width-1][0]) - 255;
//z just in one direction but with the additional “1” to make sure to never get stuck
//in case the movement is stopped by a crazy parameter (noise data) combination
//(here based on the down left pixel - it could be any position else)
z[0] += 1 + ((noise[0][0][Height-1]) / 4);
//set the scaling based on left and right pixel of the middle line
//here you can set the range of the zoom in both dimensions
scale_x[0] = 8000 + (noise[0][0][CentreY] * 16);
scale_y[0] = 8000 + (noise[0][Width-1][CentreY] * 16);
//calculate the noise data
uint8_t layer = 0;
for (uint8_t i = 0; i < Width; i++) {
uint32_t ioffset = scale_x[layer] * (i - CentreX);
for (uint8_t j = 0; j < Height; j++) {
uint32_t joffset = scale_y[layer] * (j - CentreY);
uint16_t data = inoise16(x[layer] + ioffset, y[layer] + joffset, z[layer]);
// limit the 16 bit results to the interesting range
if (data < 11000) data = 11000;
if (data > 51000) data = 51000;
// normalize
data = data - 11000;
// scale down that the result fits into a byte
data = data / 161;
// store the result in the array
noise[layer][i][j] = data;
}
}
//map the colors
for (uint8_t y = 0; y < Height; y++) {
for (uint8_t x = 0; x < Width; x++) {
//I will add this overlay CRGB later for more colors
//it´s basically a rainbow mapping with an inverted brightness mask
CRGB overlay = CHSV(noise[0][y][x], 255, noise[0][x][y]);
//here the actual colormapping happens - note the additional colorshift caused by the down right pixel noise[0][15][15]
leds[XY(x, y)] = ColorFromPalette( Pal, noise[0][Width-1][Height-1] + noise[0][x][y]) + overlay;
}
}
//make it looking nice
adjust_gamma();
// added //
checkKnobs ();
//and show it!
FastLED.show();
// added //
FastLED.setBrightness(brightness); // Set master brightness based on potentiometer position.
}
//===============================================================
Anyone?