Where can I find a complete documentation of FastLED? I see a lot of functions I can’t find in the documentation. To be more specific for example in DemoReel100: for e xample, EVERY_N_MILLISECONDS, fill_rainbow, fadeToBlackBy, CRGBPalette16, and many more. How am I supposed to know how they work?
There’s the wiki here - https://github.com/FastLED/FastLED/wiki/Overview
As well as API docs generated via doxygen (though still incomplete) - http://fastled.io/docs/3.1/modules.html
And then there’s searching through the community here and asking questions. There is a lot in the library and we are slowly working on adding more documentation and examples.
It’s just a question of time 
@Ahmad_Sajadian I’ve found the best thing is to find sketches with a function I’m interested in and then try changing some values and settings. Once I see the results, it’s easier to understand what’s going on.
If there’s a specific effect you’re after but don’t know the function, try googling FastLED and the effect – or search the effect in this G+. Chances are good you’ll find what you want or at least get pointed in the right direction.
And, when all else fails, there are a lot of helpful people here. But all those people are chasing down their own projects, and offering advice free of charge on their own time – so it’s only polite to try some stuff on your own first.
All the best! Have fun!
I have been to the wiki page and the Docs page and I must say that to a beginner there is no help there at all. It would be VERY helpful if someone could write an example for EACH function so we could see how it is to be used. I am still struggling with FastLED and have tried until I am blue in the face. I hope someone will write some examples for us beginners that take into account that our programming skills are terrible. We just need a little start to get us going.
@Jack_Keeney you’re not alone. I think it might be the way the docs are written. They have a very “formal codey” feel to them which I found quite confusing.
For example:
fill_rainbow (struct CHSV *targetArray, int numToFill, uint8_t initialhue, uint8_t deltahue=5)
From a code perspective, I get adding in all the variable classes in the definition, but it’s not as easy as seeing the comments/examples in real code where someone says:
fill_rainbow (your_led_array, how_many_leds, start_color, diff_between_pixels)
I think the other huge contributor (making a bit of a guess here) is that perhaps some of the functions changed a bit from master -> 3.1. I think the github site really only discuses for loops and setting leds[i]. I was really confused to see functions applied to the whole array in newer code examples.
I love the plain English on the github master branch, and as stated above, am thinking it’s just going to take some time to update all the new stuff to the same level of prose.
One of the problems with making documentation/examples for beginners with a library this powerful is figuring out what counts as a “beginner” - is it someone who has programming experience, but hasn’t done any graphics stuff or micro controller stuff? Is it someone who hasn’t ever done any programming at all? Etc… @Mark_Kriegsman and I are continually trying to add to the documentation and examples while also working on the library itself, but this is a part time thing for us both, so there’s always going to be holes, and there’s always going to be people coming in at an even lower level of experience than we’ve managed to document for so far.
This is part of why I set up the G+ community early on - to have a place for people to learn and share information and teach each other for all the in between things that we haven’t gotten a chance to do something for yet.
@John_Hendy I suspect you’re referring to the docs that are at http://fastled.io/docs/3.1 – the reason why the documentation output looks that way is because that documentation is generated from the code using a tool called Doxygen, and Doxygen is designed for creating documentation from code, and so it uses the code (and the type information) in what it generates.
Part of why I’m publishing the doxygen based documentation along side all the things that exist on the wiki is to have a way to provide a reference to things that we haven’t had a chance to write dedicated documentation/provide examples for yet.
@Daniel_Garcia totally understood. It takes some getting used to and as has already been suggested, I find I bounce back and forth between official docs and examples/existing code. I wish I understood more… I’d try and help contribute to the mammoth task!
I’m a hobbyist (I’ve studied mechanical engineering) I have little programming experience. I think Arduino and libraries like FastLED are just right for people like me, they are designed to be as easy and powerful as it can be. So I think I’m not supposed to be an experienced programmer. I tried digging into the header files to learn more but I couldn’t understand much. I think a very brief introduction of the built-in functions would be great, at least to know what there is in this awesome library!
My primary goals for FastLED are high performance, followed by power and flexibility. Ease of use sometimes falls out of those design goals and decisions, but sometimes it doesn’t. So, no, FastLED is not designed to be as easy as it can be. Over the years, it has attracted an increasingly lower level of experience’d audience, and we’ve tried to put things in there to make it a little less bumpy to learn the way around the library, but there’s still a lot of work to do there. However, my first priority is almost always performance and flexibility.
FastLED is a large, complex, and powerful library (at least, compared to your average Arduino library). I want to get more documentation in there over time, and we’re slowly doing that, but it’s a slow process. Especially since because for many things, where the power is comes not from individual functions, but from the way those things can be mixed with each other.
(A library like AdaFruit’s Neopixel library has less than 20 functions, and it really exists to do one thing - let you set the rgb values of leds in a strip of neopixels. FastLED has hundreds of functions, and at least a dozen classes (and way more if you drill down into the internal implementations of various pieces of functionality) and provides an entire base of high performance math functions, color management functions, etc… In raw lines of code, FastLED is ~15 times larger than the NeoPixel library)
Do keep checking the wiki, the published API docs, and the G+ group though, as we are always adding more examples and more documentation (even while we add support for more leds and more platforms and more features and more functions).
Thank you Daniel, I love FastLED I found it even easier and more intuitive than Ardufruit’s NeoPixel. Your right, It’s good you didn’t sacrifice performance and flexibility for easiness.
I think a beginner can learn and benefit from it very well, provided there is a good documentation. I believe before working on adding more features a good help should be prepared.
I’ll keep reading and learning from examples and community posts.
“I believe before working on adding more features a good help should be prepared.”
Unfortunately, it is going to be a little while before that happens. I have, for some personal projects that I use FastLED for, a handful of pretty major features to get worked into the library (as well as at least 3 more platforms) that are going to require a lot of code changes and a lot of work in the library to pull off. Because those projects have some pretty hard deadlines associated with them, I won’t be able to devote a whole lot of time to documentation updating until after those are done (though I will still try to continue to trickle things in/around in the code).
This would all be much easier if I could find someone who would pay me full time to work on FastLED all the time Sadly, there isn’t quite anyone out there willing to do that (I do have some contract work from time to time that does help pay for things, though).
My word! @Daniel_Garcia As long as you’re willing to pursue them, don’t ever stop working on new features!
I don’t want to sound like a jerk, but FastLED isn’t something people buy and then expect customer support for. I didn’t even know it existed a few months ago, but after a few hours of trying, I got basic sketches and examples to work. After a few days of trying, I figured out how to alter sketches to do more of what I want. After a few weeks of trying (which included teaching myself some (VERY) basic C++) I’m starting to understand how the sketches work.
If the people way smarter than I am are willing to come up with the code, I more than willing to invest a little time and effort learning how to use it.
Just my 2-cents.
One thing I would like to figure out is where there are some good basic programming resources (how to work with arrays, what is a loop, etc…) that I can point new people to. More of an “introduction to programming” than an “introduction to FastLED” thing, but full of the things that if people know, will make understanding what’s going on in the FastLED documentation and examples easier. If any one has any pointers, I’d love to hear them and i’ll add them to the wiki/docs.
This site talks about C++ in fairly straight-forward language. It’s helping me grasp a lot of what’s going on in a sketch.
Sample pages:
http://www.cplusplus.com/doc/tutorial/arrays/
http://www.cplusplus.com/doc/tutorial/variables/
I was thinking about this more and would like to take a stab at some explanations, code, and possibly video demos. I’ll start with the functions in this post and comment back with the result!
I’ll start a github repo for code samples and was going to start with fill_rainbow since I’m the most familiar with it. I’ll just do a bunch of loops that cycle through settings for start hue, sat, and brightness.
Out of curiosity, where is the idea of fill_rainbow(leds + skip_pixels…) documented? Is that just inherent in the array definition? When I first saw it, it was the first time it occurred to me one could do that to not start on the first pixel of a defined array.
That’s just part of working with arrays in C/C++
I skimmed the array lesson posted above and am not seeing something exactly like that. Is “leds + 5” as the array argument to fill_rainbow() like leds[5…length] ? As in, is it just subsetting from n to the end?
Nevermind, this answer really helped a lot.
I’ve worked with vectors in other languages so the idea is familiar, but not the pointer concept. So that was good to learn!
Alright, would appreciate some honest feedback:
Obviously this is pretty much right at the beginning, but I’d like to build on it if that’s welcomed. I wanted to do a relatively quick example (maybe took me 1.5hrs for that) of my “documentation style” to see if this sort of thing is even helpful.
If folks think this really isn’t what’s needed to make FastLED more accessible/understood, I’ll abandon ship! Otherwise, I’d love to keep going as time allows. I already learned some stuff myself, even with something so basic. I love teaching, as it forces me to try and answer the questions that arise!
Please offer any corrections if my explanations were poor/wrong.