Good grief! I merely can not consider that we’re already at Half 7 of what was initially conceived as a trio, triad, or troika of articles. In my earlier column, we wrote some easy Arduino sketches (packages) to carry out experiments utilizing one among Adafruit’s 8-Component tricolor NeoPixel Sticks.
Experiment #1 concerned us lighting the entire pixels within the stick concurrently. We began by lighting all of them pink, ready a second, then lighting all of them inexperienced, ready a second, then lighting all of them blue, ready a second, and performing these actions time and again.
In Experiment #2, versus lighting the entire pixels concurrently, we determined to gentle them one after the other with out turning the earlier pixel off and with a 100 millisecond (ms) delay between every pixel. As soon as once more, we began by lighting them pink, then inexperienced, then blue, then doing it yet again as illustrated under.
Lighting the NeoPixels one after the other whereas leaving the earlier pixel on.
Only for giggles and grins, we closed our earlier column with a thought experiment. We determined that we wished to do subsequent was to gentle the pixels one after the other as in Experiment #2. This time, nonetheless, every time a brand new pixel lights up, we additionally wish to flip the outdated pixel off. Simply to combine issues up a bit, we determined to make use of the magenta coloration for this experiment as illustrated under.
Lighting the NeoPixels one after the other whereas turning the earlier pixel off.
Your “homework,” because it have been, was to cogitate and ruminate over the duty of how we go about turning the outdated pixel off. There are a number of methods to do that. I can consider 4 “off the highest of my head.” So, what number of did you give you?
Earlier than we plunge into the fray with gusto and abandon (and aplomb, after all), it is likely to be value noting that I personally discover it simpler to consider this kind of factor by visualizing our eight pixels as being organized in a circle as illustrated under.
Visualizing eight pixels as being organized in a circle.
So, how are we going to show the earlier pixel off once we flip the brand new pixel on? Effectively, let’s begin by doing it the fallacious manner, which is able to assist us to wrap our minds across the underlying downside. From our earlier experiments, we all know that NUM_NEOS is a continuing that’s been assigned a worth of 8; additionally, that we’ve outlined COLOR_MAGENTA and COLOR_BLACK as 24-bit hexadecimal values (8-bits every for the pink, inexperienced, and blue coloration channels). Now contemplate the next snippet of code:
That is NOT the correct option to do issues.
As we see, we’re utilizing a for() loop to cycle by means of the pixels from 0 to 7, the place the variable iNeo is used to level to the present pixel of curiosity. For every pixel place, we flip the brand new pixel pointed to by iNeo on, and we flip the outdated pixel pointed to by (iNeo – 1) off.
It’s all the time the top circumstances (often known as “nook instances”) that trigger us issues. On this case, the issue happens when iNeo is pointing at pixel 0, as a result of because of this (iNeo – 1) equals –1, which isn’t a legitimate worth as a result of our pixels are numbered from 0 to 7. What would occur if we ran this program? I’m afraid to search out out (in the event you run it your self, please let me know what occurs).
For the reason that downside happens solely when iNeo is pointing at pixel 0, the apparent answer is so as to add a take a look at to handle this case as follows:
It will work, nevertheless it’s not fairly.
As we see, we’ve added a take a look at to see if (iNeo == 0). If that is true, then we flip the pixel at (NUM_NEOS – 1), which is 8 – 1 = 7, off; in any other case, we return to utilizing (iNeo – 1) for the remainder of the pixels. Word that the explanation we use (NUM_NEOS – 1) as a substitute of merely turning pixel quantity 7 off is to future-proof our code in case we in the future resolve to make use of a stick (or ring) containing extra (or much less) pixels.
Now, this can be a completely serviceable answer, nevertheless it must be acknowledged that it lacks a sure class. I personally dislike having to deal with a single merchandise otherwise from all of the others. It could be good to have the ability to current a minimum of a touch of a sniff of a whiff of panache. (You in all probability assume I ought to have proven this take a look at coloured in inexperienced as a result of it really works, however I’m leaving it coloured pink as a result of I don’t like doing it.)
Fortunately, there are a selection of the way we are able to go about this. The primary requires that we perceive the way in which wherein computer systems retailer and manipulate numbers. Additionally, it solely works when the variety of pixels we’re enjoying with is an influence of two, which is the case on this case, in the event you see what I imply, as a result of we at present have 8 pixels and eight = 2^3.
Earlier, we famous that when iNeo is pointing at pixel 0, because of this (iNeo – 1) equals –1, which isn’t a legitimate worth as a result of our pixels are numbered from 0 to 7. The factor is that the pc really makes use of a worth of all 1s to characterize –1.
We don’t wish to get into signed binary numbers right here, however there’s one other manner to consider this, which is that an int (integer) like our iNeo variable is represented utilizing a hard and fast variety of bits (16 within the case of an Arduino Uno). Let’s assume that this variable already contained all 1s, wherein case including a further 1 will trigger it to overflow, ending up containing all 0s. Contrariwise, if the variable already accommodates all 0s, then subtracting 1 will trigger it to underflow, ending up containing all 1s.
What we’re going to do is to make use of the bitwise AND operator (‘&’) to logically AND the worth ensuing from the (iNeo – 1) operation with 0x7 (hexadecimal 7), which is 111 in binary (the compiler will mechanically insert main 0s as required). (In case you are new to programming, then it’s possible you’ll want to take a look at my Masking and the C/C++ Bitwise Operators column, which gives a jolly good introduction to this matter.) The best option to visualize what we’re doing right here is with a desk as illustrated under:
Utilizing a bitwise AND (‘&’) operator as a masks.
Within the case of pixels 1 to 7 (001 to 111 in binary), subtracting 1 leaves 0 to six (000 to 110 in binary). Since these values all match within the least-significant three bits, ANDing them with 0x7 (111 in binary) has no impact and leaves them “as-is.” Nonetheless, within the case of pixel 0, subtracting 1 leaves us with 1111111111111111 (bear in mind we’re assuming an Arduino Uno with 16-bit integers). ANDing this worth with 0000000000000111 (bear in mind the compiler provides main zeros) leaves us with 111, which is 7 in decimal, which is what we wish (I really feel a “Tra-la!” is so as). This enables us to rewrite our code as proven under:
Utilizing a bitwise AND (‘&’) operator as a masks.
As we see, we now not have to carry out a take a look at. As an alternative, we are able to use a single assertion to show any of our outdated pixels off.
The primary downside with this strategy is that—as we beforehand famous—it really works solely when the variety of pixels is an influence of two. If we have been to resolve to make use of one among Adafruit’s 12-NeoPixel Rings, for instance, then this masking method wouldn’t work (unhappy face).
Happily, there’s one other strategy we are able to use (comfortable face). Return to have a look at the picture displaying the pixels organized as a hoop and visualize this as being drawn in chalk on the ground. Now suppose you might be standing subsequent to one of many pixels—let’s say pixel 4. There are two methods so that you can get to pixel 3. One is to stroll one pixel anticlockwise (we are able to consider this as representing –1); the opposite is to stroll across the ring 7 pixels clockwise (we are able to consider this as representing (NUM_NEOS – 1)).
That is the place we flip to a different C/C++ operator referred to as modulo (‘%’). In C and C++, if x and y are integers, the rest from an integer division (x / y) is discarded. By comparability, the modulo operator (x % y) returns the rest from the division. This leads us to the next desk:
Utilizing the modulo (‘%’) operator.
On this case, let’s begin with the “What we’ve received” column proven within the middle in daring. If we want to decide the worth of the earlier pixel, then what we wish is (pixel – 1), wherein case the suitable calculation is proven within the left-hand column. Alternatively, if we want to decide the worth of the following pixel, then what we wish is (pixel + 1), wherein case the suitable calculation is proven within the right-hand column.
Let’s put this into apply as illustrated within the code snippet proven under:
Utilizing the modulo (‘%’) operator.
As soon as once more, we now not have to carry out a take a look at. And, as soon as once more, we are able to use a single assertion to show any of our outdated pixels off (on this case we’re utilizing the “Pixel – 1” calculation from our desk to show the outdated pixel off). Final, however actually not least, let’s contemplate one other manner of doing issues that removes our for() loop as follows:
One other manner of utilizing the modulo (‘%’) operator.
Personally, I discover this strategy makes issues just a little simpler to wrap one’s mind round. What we’re doing is declaring the pointer to our pixels, iNeo, as a worldwide variable that we initialize to comprise 0.
As soon as once more, we’re utilizing the “Pixel – 1” calculation from our desk to show the outdated pixel off. Additionally, on the finish of the loop, we use the “Pixel + 1” calculation from our desk to level iNeo on the subsequent pixel within the sequence.
Phew! I do know there’s quite a bit to consider on this column in case you are new to programming, nevertheless it’s actually not too dangerous. The necessary factor to notice is that the strategies we’ve mentioned right here (like utilizing masks and the modulo operator) are relevant to a variety of duties that go far past flashing LEDs.
I feel we’ll cease right here for the second to let all of this sink in. As all the time, I welcome your fascinating feedback, insightful questions, and shrewd options relating to something we’ve mentioned on this column.
