Been racking my brains and so far just got balder.

Dani_Epstein · July 24, 2017, 7:53pm

Been racking my brains and so far just got balder. I would like to “move” a small group of leds across a strip of 144 pixels, in order to use it as a clock. I would like really smooth blending using a palette with a white pixel as the second blending off to red or something, but for the life of me have not figured out how to do this. Having spend hours fiddling with all this, does anyone have any pointers for me?

marmil · July 24, 2017, 8:34pm

Any examples of what you have you tried so far?

One of my first thoughts was something like Mark’s anti-aliased light bar example:

I did a version of that for a rotating light house beacon:

github.com

marmilicious/FastLED_examples/blob/master/lighthouse_beacon_v2_anti-aliased.ino

//***************************************************************
// rotating beacon for lighthouse emulation, Anti-aliased version
// Marc Miller, Nov 2015
//
//Based on Mark Kriegsman's Anti-aliased light bar example here:
//http://pastebin.com/yAgKs0Ay#
//***************************************************************

#include "FastLED.h"
#define LED_TYPE NEOPIXEL
#define DATA_PIN 6
//#define CLOCK_PIN 13
#define NUM_LEDS 12
//#define COLOR_ORDER GRB
#define BRIGHTNESS 255
CRGB leds[NUM_LEDS];

int8_t hue = 42;  // Light color
int8_t sat = 190;  // Saturation
int8_t val = BRIGHTNESS;  // Max brightness of light

This file has been truncated. show original

It doesn’t use a palette, but the trailing pixels should be able to be color shifted from the center color to another color.

Can you clarify how you’re wanting to use the palette? Is it for the moving group, or for coloring all the other pixels besides the moving group?

Tommy_Sciano · July 24, 2017, 9:44pm

github.com

jasoncoon/SparkRing/blob/main/Firmware/spark-ring/spark-ring.ino

#include "FastLED/FastLED.h"
FASTLED_USING_NAMESPACE;

#include "application.h"
#include <math.h>

#define ONE_DAY_MILLIS (24 * 60 * 60 * 1000)

#define LED_PIN     1
#define CLOCK_PIN   0
#define COLOR_ORDER GBR // 1 = GBR; 2 = BGR;
#define CHIPSET     NEOPIXEL
#define NUM_LEDS    24
CRGB leds[NUM_LEDS];

#define ARRAY_SIZE(A) (sizeof(A) / sizeof((A)[0]))
 
// List of patterns to cycle through.  Each is defined as a separate function below.

typedef uint8_t (*SimplePattern)();

This file has been truncated. show original

@Jason_Coon made a clock

Dani_Epstein · July 24, 2017, 9:53pm

Great stuff, @Marc_Miller1 and @Tommy_Sciano , certainly plenty of food for thought. Thanks for that.

Dani_Epstein · July 26, 2017, 10:34pm

This is the effect I’m after, is there a simple way to smoothly move these colours across the strip, at some given speed?
missing/deleted image from Google+

marmil · July 27, 2017, 12:24am

The method used might be determined by requirements of the display. Does it need to vary in speed? (Maybe not if it’s for a clock. Would the length need to change? Constant or variable color(s)? etc.

Think of it as layer up the final image. You could fill the whole strip with the background color (blue) and then draw (add) the moving animation part on top, as well as your minute and hour markers.

The moving animation part could come from a “fixed” set of data (that’s only 12 pixels long for example) with it’s position simply shifted along the strip. Here’s an example of the concept.

github.com

marmilicious/FastLED_examples/blob/master/moving_gradient_example.ino

//***************************************************************
// Moving gradient example
// It will wrap around, and the direction can be reversed.
// This is done a bit different then you might expect as I'm
// filling the gradient once in setup() and saving the colors
// in a seperate CRGB array.  Then coping those into the main
// leds array as needed when moving it around.
//
// Marc Miller, Jan 2016
//***************************************************************

#include "FastLED.h"
#define LED_TYPE LPD8806
#define DATA_PIN 11
#define CLOCK_PIN 13
#define NUM_LEDS 32
#define COLOR_ORDER GRB
#define BRIGHTNESS 255
CRGB leds[NUM_LEDS];

This file has been truncated. show original

It could also all be calculated in real time (like the lighthouse beacon example). Maybe it would be two or three (separate colors and different length) bars that are then added together, and on top of the blue background. See this wiki page for ideas on add/combining colors from two sources. It could leds[i] + some color, or leds[i] + leds_temp[i] (with leds_temp[] being a separate CRGB array, either constant or being calculated on the fly).

[edit: forgot the wiki link]

Dani_Epstein · July 27, 2017, 8:59am

@marmil thanks for that example link. The issue with that and all the other things I have tried is that they don;t move the strip smoothly, they jump from one whole LED to another. What I was hoping for was a simple function or two that would smoothly blend a gradient slowly into the next LED.

I have something working already, but it’s overly complicated, and I’m trying to reduce it to something simpler and more manageable. I will try to post the code sometime today.

marmil · July 27, 2017, 10:11am

What did you think of Mark’s anti-aliased bar sort of setup?

Also, a good diffusion can help smooth things out. But then if wanted a tight/small hour or minute marker on your clock it wouldn’t be as sharp any more.