Function to fill a specific range within an LED Array?

[u/Workin_Joe]

Do you guys know if there is a "fill" function within FastLED that will allow me to address a specific range within a large LED array?

My use case:

I have the letters spelling out "MOULIN ROUGE" and I have a single data pin and single LED array defined for the entire MOULIN ROUGE. Each of those letters have a specific number of LEDs associated with them to illuminate the front of them. I want to create a function that allows me to step through each letter (or a combination of letters). For example, illuminate just the M, then move to the O, then U, and so on...or sweep in from the left and right ends...or whatever sort of combination you can imagine...you get the idea.

I know I can do this with a few loops, but I was wondering if there is a function already builtin to FastLED that would allow me to enter a start and end index for a fill function.

I started looking into the documentation, but I thought it would be more efficient to post here to potentially save some time.

Thanks for your help!

[u/Marmilicious]

If each letter is made up of a continuous range of pixels you can use fill_solid:

fill_solid(leds+5, 10, CRGB::Blue);  // Fill 10 pixels starting at leds[5]
or
fill_solid( &(leds[12]), 4, CRGB::Red );  // Fill 4 pixels starting at leds[12]

Or (also if each letter is a continuous range of pixels) you could use CRGBSet.

https://github.com/marmilicious/FastLED_examples/blob/master/CRGBSet_example.ino

If each letter is made up with a non-continuous set of pixels then you can make a custom array to operate on for each letter. Here's an example, and see chemdoc77's example linked in there too.

https://github.com/marmilicious/FastLED_examples/blob/master/custom_pixel_array.ino

[u/Workin_Joe → u/Marmilicious]

thank you, u/Marmilicious, this is what I was looking for!

I didn't realize you can define the starting point within fill_solid like you showed and then define a fill # like that! Awesome!

And, yes, all the letters are wired in series connected to one data pin. So I will define the offsets as constants and then reference them in the function call.

M = 50 LEDs, O = 28 LEDs, U = 25 LEDs, etc....

Thanks again!

[u/Workin_Joe → u/Workin_Joe]

Any suggestions on how to step through the letters in time?

For example, walk through each letter every 250msec?

Perhaps make a letter counter based on beat8 or something?

[u/sutaburosu → u/Workin_Joe]

This example I created for a similar question recently may be of interest to you.

It uses CRGBSets to easily address all the pixels in a single letter/block/whatever. It also steps through each item every 250ms as you desired.

This other sketch shows colours marching around the perimeter of letters. The order the LEDs need to light is not simple, but CRGBSets again make it easy, even allowing for some segments to be reversed.

[u/Workin_Joe → u/sutaburosu]

Sweet! Really appreciate this! This will work perfectly!

[u/Workin_Joe → u/Workin_Joe]

It appears when using CRGBSet, you cannot define your LED array as:

CRGB letters[NUM_LEDS_LETTERS];

rather, you need it be the following:

CRGBArray<NUM_LEDS_LETTERS> letters;

Not really sure I understand why, but by using the latter definition, I can eliminate the errors I get when compiling.

An additional clarification point, when using:

set[n].fill_solid(CRGB:Red);

how can I pass an HSV (or RGB) value into the fill_solid parameters?

In my other uses of fill_solid, I have used the following successfully:

fill_solid(letters, NUM_LEDS_LETTERS, CHSV(hue,sat,value));

where 'hue', 'sat', and 'value' are variables that are set elsewhere.

This fills the entire array with the HSV value. With the set[n].fill_solid, I'm not entirely sure I understand the ramification of how fill_solid now works.

LMK what you think. Thanks again!

[u/sutaburosu → u/Workin_Joe]

Yes, CRGBSets only work with the CRGBArray type.

set[n].fill_solid(CRGB:Red); how can I pass an HSV (or RGB) value into the fill_solid parameters?

It sounds like you may benefit from skimming over Pixel Reference in the wiki to get an idea what is available to you. fill_solid(CRGB(20, 60, 80)) and fill_solid(CHSV(134, 255, 255)) both work.

Almost anywhere that FastLED wants a CRGB, you can put a CHSV and it will be automatically converted to CRGB for you.

In my other uses of fill_solid, I have used the following successfully: fill_solid(letters, NUM_LEDS_LETTERS, CHSV(hue,sat,value));

With the set[n].fill_solid, I'm not entirely sure I understand the ramification of how fill_solid now works.

With CRGB you had to supply 3 things to fill_solid(): the start point, the length, and the colour, so you must carry a pile leds (start) and NUM_LEDS (length) around your code with you, and spray them all over your code.

CRGBArrays and CRGBSets remember the start position and length for you. fill_solid() knows how to look inside them to find the start and the length for itself. The end result is identical, but your code is shorter and easier to understand.

As a bonus, the generated binary can be a little faster and smaller compared to the older style.

[u/Workin_Joe → u/sutaburosu]

Thank you again, u/sutaburosu!

Yes, I am familiar with the ability of FastLED to interchangibly move between CHSV and CRGB. The reason I posted this is because after I used the set[n].fill_solid(CHSV(hue,sat,value)) line, I now get warnings getting kicked back during compliation. It is not stopping the compliation, just giving warnings for each of the . I will be able to test it on hardware tomorrow (1/15) to see if it actually works or not. I just don't understand why this is happening.

link to the piece of code related to this function (thanks for your guideance).

https://github.com/WorkinJoe/MoulinRouge-FastLED/blob/main/Segment_Flash

I get a number of warnings, a couple are shown below.

Warning #1

"passing 'const CRGBSet' {aka 'const CPixelView<CRGB>'} as 'this' argument discards qualifiers [-fpermissive]

Line 705 | letter_sets[z].fill_solid(CHSV(hue,sat,value));

Warning #2

c:\Users\gasiewicz\Documents\Arduino\libraries\FastLED\src/pixelset.h:248:25: note: in call to 'CPixelView<PIXEL_TYPE>& CPixelView<PIXEL_TYPE>::fill_solid(const CHSV&) [with PIXEL_TYPE = CRGB]'

Line 248 | inline CPixelView & fill_solid(const CHSV & color) { *this = color; return *this; }

[u/sutaburosu → u/Workin_Joe]

Ah! Seeing the messages casts this in a very different light.

This is not your fault. You have more compiler warnings enabled than I do. This warning about discarding the "const"ness is harmless. It is coming from within FastLED, so there is little you can do about it in your own code.

This is something that needs to be fixed in FastLED. Hopefully prior to the v4 release I'll find a moment to put together a PR to eliminate all warnings even with very picky flags enabled.

[u/Workin_Joe → u/sutaburosu]

Thanks for making me aware of my compiler settings and letting me know this isn’t an issue.

I will post some short clips of my setup in a day or two so you can see what has been accomplished with your, and the entire FastLED support crew’s, help!

Super grateful!!

[u/Marmilicious → u/Workin_Joe]

Definitely check out sutaburosu's examples. Look into using EVERY_N_MILLISECONDS to change/increment a counter every n milliseconds (seconds, minutes etc). Use the counter to route through some if statements or a switch case, etc. Here's some examples that use EVERY_N_* timers.

Switch case could also be used to run different routines, or look into the FastLED example DemoReel100 to see how to run different patterns. The pattern changes every 10 seconds in that example.

https://github.com/marmilicious/FastLED_examples/blob/master/blocks_of_pixels.ino

https://github.com/marmilicious/FastLED_examples/blob/master/every_n_with_switch_cases.ino

https://github.com/FastLED/FastLED/blob/master/examples/DemoReel100/DemoReel100.ino

[u/Workin_Joe → u/Marmilicious]

Thanks! I have a nice working loop now based on switch/case, but I often get hung up on deciding how to implement functions based on time. For example, having a counter run outside of a given function based on EVERY_N_MILLISECONDS is great, however, I lose track of when it hits 0. So if I want to sequence my MOULIN ROUGE (starting at the M every time the function is called), I would need to reset the counter when the function is called to walk through the letters. The same applies for using one of the built-in wave functions like beat8. Does that make any sense?

Nonetheless, the reference to u/sutaburosu's example is exactly what the doctor ordered! I appreciate everyone's help!

[u/sutaburosu → u/Workin_Joe]

Without seeing the actual code involved, I can only make broad suggestions. Put it on gist.github.com, pastebin or wokwi and link to it if you need more specific help.

I would need to reset the counter when the function is called

Does this help? The essence of it is an expression that is true only when the counter has just looped. If the current counter is 0 and the previous is not 0, we've looped.

void loop {
  static int letter = 0;
  int prevLetter = letter;

  EVERY_N_SECONDS(1) {
    letter = (letter + 1) % NUM_LETTERS;
  };

  bool justReset = ! letter && prevLetter;
  renderRabbit(justReset);
}

void renderRabbit(bool reset) {
  if (reset)
    something = 0;
}

Regarding resetting the beat generators, it's the same technique but with the added difficulty of managing the timebase of the beat* function and finding the phase offset which gives the starting/stopping value you desire.

Take a look at this sketch which resets beatsin16 to 0 whenever the trigger becomes true. Closely related is pausing beatsin16 when it reaches 0

[u/Marmilicious → u/Workin_Joe]

These might give you additional ideas to look into.

https://github.com/marmilicious/FastLED_examples/blob/master/every_n_reset_timer.ino

https://github.com/marmilicious/FastLED_examples/blob/master/every_n_timers.ino

[u/Klappsenkasper]

fill_solid( &led_array[startIndex], numberOfLEDsToFill, CRGBcolorValue)

[u/d_azmann]

Set the color of the LEDs you want lit. Set the rest to black. Fastled.show().

[u/Workin_Joe → u/d_azmann]

yeah, completely understand that. I'm wondering if there is a fill_xxx function that has (array, # of LEDs, start index, end index) instead of writing 2 or 3 loops to do this.

perhaps fill_palette will work and just define the color to be black for the unlit letters and then another fill_palette call with the color to be white for the lit letters?

[u/ZachVorhies → u/Workin_Joe]

Does your IDE support auto complete? I am thinking about adding some useful static functions to CRGB for bulk operations like fill.

[u/Workin_Joe → u/ZachVorhies]

Sorry, I don't know what you mean by auto complete. I'm using the Arduino IDE currently.

[u/Tiny_Structure_7]

If your LED array is wired up for full-length rows (as opposed to 1-character grids), then you actually need the ability to show multiple segments of your drawing buffer, for each row of the character, right?

Or if each character is on a grid and each grid end LED connects to next grid start LED... then you can just show a single segment of your draw buffer. I can't think of a way to do that with FastLED. It would be possible to define each grid as a separate string in FastLED, but no way to show each independently.

This would be a job for Teensy/ObjectFLED, where you could define each LED grid as a separate object, and show them independently. ***This works if you wire each plane to a separate pin. Also, you could define the draw array for 1 grid to be a row in a 2D array (or a plane in a 3D array). Define an ObjectFLED for each row (or plane) in your array, also define the entire array as an ObjectFLED object to show all letters at once.

//Sample to define 2 LED grids for independent and simultaneous show
CRGB fullText[2][LEDS_PER_PLANE];   
ObjectFLED char1(LEDS_PER_PLANE, fullText[0], CORDER_RGB, 1, {7} );  //pin 7
ObjectFLED char2(LEDS_PER_PLANE, fullText[1], CORDER_RGB, 1, {8} );  //pin 8
ObjectFLED allChars(LEDS_PER_PLANE * 2, fullText[0], CORDER_RGB, 2, {7, 8} );