now it runs perfectly, thank you!
Controlling an LED with variable colours using Bela and SuperCollider
giuliomoro added the Solved tag .
hi, sorry for bothering again. I tried to "set elements of colors" but I don't have too much experience with C++. Is there any chance that you include an example in the code which shows how to do that? I would really appreciate it.
I would then try and set the color of the LED from PD. To do that I can follow the OLED example to receive OSC messages from PD.
the global variable colors contains triplets of colors that are sent to each LED. When you start the program, the variable's content looks like this:
std::vector<uint8_t> colors = {{
0x00, 0xC0, 0x00,
0xC0, 0x00, 0x00,
0x00, 0x00, 0xC0,
0x00, 0x00, 0x00,
}};So it drives four LED: green, red, blue, dark.
If you have more than 4 LEDs, edit this:
size_t numLeds = 12; // TODO: adjust depending on num of leds in useOnce you have adjusted that, from within setup() or render() or even task() you can adjust the colors of the LEDs. This code will, for example, have all RED leds with increasing brightness
for(unsigned int n = 0; n < colors.size() / kBytesPerRgb; n++)
{
float relative = n / float(colors.size() / kBytesPerRgb);
colors[n * kBytesPerRgb] = 0xff * relative; // LED n, red
colors[n * kBytesPerRgb + 1] = 0; // LED n, green
colors[n * kBytesPerRgb + 2] = 0; // LED n, blue
}wow, you have the best support. Thanks a lot!
4 days later
Thanks for the code. After some adjustments for the leds i have, it work fine.
i have encapsulate them in a class for easy usage :
/***********************************************************
LedStripSpi : send Strip Led (like WS2812) data
with the SPI MOSI output
This assumes BelaMini is used and the neopixels are driven from pin P2.25.
To enable that you'll need to run 'config-pin P2.25 spi' after each reboot
************************************************************/
// The specs (WS2812B-2020 datasheet) say:
// T0H 0 code, high voltage time 220ns~380ns
// T1H 1 code, high voltage time 580ns~1µs
// T0L 0 code, low voltage time 580ns~1µs
// T1L 1 code, low voltage time 220ns~420ns
// RES Frame unit, low voltage time >280µs
// WS2812B v1.0 on the other hand says:
// TH+TL = 1.25µs ± 600ns
// T0H 0 code, high voltage time 0.4us ±150ns
// T1H 1 code, high voltage time 0.8us ±150ns
// T0L 0 code, low voltage time 0.85us ±150ns
// T1L 1 code, low voltage time 0.45us ±150ns
// More recent datasheets say
// For led YF923-F5-F8 (aliexpress) :
// T0H 0 code, high voltage time 0.3us ±150ns
// T1H 1 code, high voltage time 0.6us ±150ns
// T0L 0 code, low voltage time 0.6us ±150ns
// T1L 1 code, low voltage time 0.3us ±150ns
// RES Frame unit, low voltage time >50µs
#ifndef LEDSTRIPSPI_H
#define LEDSTRIPSPI_H
#include <Bela.h>
#include <stdio.h>
#include <libraries/Spi/Spi.h>
#include <cmath>
#include <string.h>
class LedStripSpi
{
public:
enum LedType{
WS2812B = 0,
YF923F5F8
};
protected:
const unsigned int kSpiClock = 12000000;
const unsigned int kSpiMinTransferSize = 160; // min number of bytes to trigger DMA transfer
const unsigned int kSpiMaxTransferSize = 4096; // max number of bytes to be sent at once
const uint8_t kSpiWordLength = 32;
const uint8_t kSpiMsbFirst = 1;
const float kSpiPeriodNs = 1000000000.0 / kSpiClock;
const uint8_t kBitsPerByte = 8;
// Additionally, there is need for adding a long enough "0" output before we start clocking out data.
// The SPI peripheral in use seems to always set the MOSI high when not clocking out data, so we have
// to start clocking out some zeros first.
// Skipping this will result in 1-bit offset in the bit shifting. If you see random flashes
// in your LEDs strip and/or the first LED remaning on when set to off
// and/or the others have the colors "slightly" wrong, this could be the reason.
// This could be avoided if the MOSI was to be LOW when idle, but this would require
// an external transistor to invert it.
const double kSpiLeadingZerosNs = 10000; // determined empirically
const unsigned int kSpiLeadingZeros = std::ceil((kSpiLeadingZerosNs / kSpiPeriodNs));
const int8_t kBytesPerRgb = 3;
typedef struct {
float min;
float max;
} T_t;
bool fReverseByte;
bool fGRB_Mode;
float fSpiInterWordTime;
T_t fTH[2];
T_t fTL[2];
Spi fSpi;
Spi::Mode fSpiMode;
unsigned int fNbrLeds;
uint8_t* fLedBuffers[2];
uint8_t* fDataBuffer;
uint8_t fCurrentSendingLedBuffer;
uint8_t fCurrentEditingLedBuffer;
bool fBufferSwitched;
void SetType(LedType type)
{
// We pick below some conservative values for Led Type
switch(type) {
case WS2812B:
fTH[0].min = 200;
fTH[0].max = 400; // T0H
fTH[1].min = 700;
fTH[1].max = 900; // T1H
fTL[0].min = 750;
fTL[0].max = 950; // T0L
fTL[1].min = 350;
fTL[1].max = 550; // T1L
fReverseByte = false;
fGRB_Mode = true;
fSpiInterWordTime = 200;
fSpiMode = Spi::MODE3;
break;
case YF923F5F8:
fTH[0].min = 200;
fTH[0].max = 450; // T0H
fTH[1].min = 500;
fTH[1].max = 750; // T1H
fTL[0].min = 500;
fTL[0].max = 750; // T0L
fTL[1].min = 200;
fTL[1].max = 450; // T1L
fReverseByte = true;
fGRB_Mode = false;
fSpiInterWordTime = 0;
fSpiMode = Spi::MODE2;
break;
default:
break;
};
}
bool readBitField(uint8_t* data, uint32_t offset) {
uint8_t position = offset % kBitsPerByte;
unsigned int i = offset / kBitsPerByte;
return data[i] & (1 << position);
}
void writeBitField(uint8_t* data, uint32_t offset, bool value) {
uint8_t position = offset % kBitsPerByte;
unsigned int i = offset / kBitsPerByte;
if(value)
data[i] |= 1 << position;
else
data[i] &= ~(1 << position);
}
ssize_t rgbToClk(uint8_t* rgb, size_t numRgb, uint8_t* out, size_t numOut)
{
memset(out, 0, numOut * sizeof(out[0]));
// writeBitField(out, 0, 1);
uint32_t clk = 0;
// emsure we have complete RGB sets
numRgb = numRgb - (numRgb % 3);
for(uint32_t inBit = 0; inBit < numRgb * kBitsPerByte; ++inBit) {
uint32_t actualInBit;
uint8_t remainder = inBit % (3 * kBitsPerByte);
if(fGRB_Mode) { // data comes in as RGB but needs to be shuffled into GRB for the WS2812B
if(remainder < kBitsPerByte)
actualInBit = inBit + kBitsPerByte;
else if(remainder < kBitsPerByte * 2)
actualInBit = inBit - kBitsPerByte;
else
actualInBit = inBit;
} else {
actualInBit = inBit;
}
bool value = readBitField(rgb, actualInBit);
const T_t* Ts[2] = {fTH, fTL};
for(unsigned int t = 0; t < 2; ++t) {
const T_t* T = Ts[t];
bool highLow = (0 == t) ? true : false;
float time = 0;
while(time < T[value].min) {
bool wordEnd = (kSpiWordLength - 1 == clk);
writeBitField(out, clk, highLow);
time += kSpiPeriodNs;
if(wordEnd)
time += fSpiInterWordTime;
++clk;
if(clk / kBitsPerByte > numOut)
return -1;
}
if(time > T[value].max) {
printf("Error: expected %f but got %f\n", T[value].max, time);
return 0;
}
}
}
ssize_t numBytes = ((clk + kSpiWordLength - 1) / kSpiWordLength) * kSpiWordLength / kBitsPerByte; // round up to the next word
if(numBytes > numOut) // just in case numOut was not a multiple, we now no longer fit
return -1;
return numBytes;
}
void SendSpi(uint8_t* data, size_t length)
{
if(length < kSpiMinTransferSize)
length = kSpiMinTransferSize;
if (fSpi.transfer(data, NULL, length) != 0)
printf("SPI: Transaction Failed\r\n");
}
void SendBufferToLeds(uint8_t* buffer, ssize_t buffersize, uint8_t* out, ssize_t outsize)
{
ssize_t len = kSpiLeadingZeros + rgbToClk(buffer, buffersize, out + kSpiLeadingZeros, outsize - kSpiLeadingZeros);
if(len < 0) {
fprintf(stderr, "Error: message too long\n");
return;
}
unsigned int bytesPerWord = kSpiWordLength / kBitsPerByte;
for(unsigned int n = 0; n < len; n += bytesPerWord) {
for(unsigned int b = 0; b < bytesPerWord / 2; ++b) {
uint8_t tmp = out[n + b];
out[n + b] = out[n + bytesPerWord - 1 - b];
out[n + bytesPerWord - 1 - b] = tmp;
}
}
if(kSpiMsbFirst) {
for(unsigned int n = 0; n < len; ++n)
out[n] = __builtin_bitreverse8(out[n]);
}
SendSpi(out, outsize);
}
public:
LedStripSpi()
{
SetType(WS2812B);
fNbrLeds = 0;
fDataBuffer = new uint8_t[kSpiMaxTransferSize];
fCurrentSendingLedBuffer = 1;
fCurrentEditingLedBuffer = 0;
fLedBuffers[0] = NULL;
fLedBuffers[1] = NULL;
fBufferSwitched = false;
}
bool Init(LedType ledtype, unsigned int nbrleds)
{
if(fNbrLeds > 0) // we don't call init sevelal times
return false;
SetType(ledtype);
if(fSpi.setup({ .device = "/dev/spidev2.1", // Device to open
.speed = kSpiClock, // Clock speed in Hz
.delay = 0, // Delay after last transfer before deselecting the device, won't matter
.numBits = kSpiWordLength, // No. of bits per transaction word,
.mode = fSpiMode // SPI mode
}) != 0) {
printf("SPI: Initialisation Failed\r\n");
return false;
}
// Led buffers initialisation
fNbrLeds = nbrleds;
ssize_t buffersize = fNbrLeds*kBytesPerRgb;
fLedBuffers[0] = new uint8_t[buffersize];
memset(fLedBuffers[0] ,0,buffersize);
fLedBuffers[1] = new uint8_t[buffersize];
memset(fLedBuffers[1] ,0,buffersize);
return true;
}
void Draw()
{
if(!fDataBuffer || !fLedBuffers[fCurrentSendingLedBuffer] || !fBufferSwitched) //draw only if new buffer
return;
fBufferSwitched = false;
uint8_t* buffer = fLedBuffers[fCurrentSendingLedBuffer];
SendBufferToLeds(buffer, fNbrLeds*kBytesPerRgb, fDataBuffer, kSpiMaxTransferSize);
}
void Begin()
{
memset(fLedBuffers[fCurrentEditingLedBuffer] ,0,fNbrLeds*kBytesPerRgb);
}
void SetLedColor(int idxled, uint8_t red, uint8_t green, uint8_t blue)
{
if(idxled >= fNbrLeds)
return;
uint8_t* buffer = fLedBuffers[fCurrentEditingLedBuffer];
buffer[idxled * kBytesPerRgb] = (fReverseByte == true) ? __builtin_bitreverse8(red) : red;
buffer[idxled * kBytesPerRgb + 1] = (fReverseByte == true) ? __builtin_bitreverse8(green) : green;
buffer[idxled * kBytesPerRgb + 2] = (fReverseByte == true) ? __builtin_bitreverse8(blue) : blue;
}
void SetAllLedsBlack()
{
memset(fLedBuffers[fCurrentEditingLedBuffer] ,0,fNbrLeds*kBytesPerRgb);
}
void End()
{
uint8_t tmp = fCurrentEditingLedBuffer;
fCurrentEditingLedBuffer = fCurrentSendingLedBuffer;
fCurrentSendingLedBuffer = tmp;
fBufferSwitched = true;
}
~LedStripSpi()
{
delete fLedBuffers[0];
fLedBuffers[0] = NULL;
delete fLedBuffers[1];
fLedBuffers[1] = NULL;
delete fDataBuffer;
fDataBuffer = NULL;
}
};
#endifhere a sample usage with a trill bar :
#include <Bela.h>
#include "ledstripspi.h"
#include <libraries/Trill/Trill.h>
Trill gTouchSensor;
LedStripSpi gLedStrip;
unsigned int gNbrLeds = 12;
unsigned int gRefreshRate = 50000;
unsigned int gTrillRefreshRate = 100000;
void LedStripTask(void*)
{
while(!Bela_stopRequested()) {
gLedStrip.Draw();
usleep(gRefreshRate);
}
//Back to black
gLedStrip.Begin();
gLedStrip.End();
gLedStrip.Draw();
}
// set the leds colors in funtion of the position (0 to 1)
void RenderBarGraph(float position)
{
position = position * gNbrLeds;
float luminosity = 1;
for(int i = 0; i < gNbrLeds; i++) {
if((position - i) < 1)
luminosity = position - i;
else if(position < i)
luminosity = 0 ;
else luminosity = 1;
gLedStrip.SetLedColor( i,
0x20*(float) (i/ (float) gNbrLeds)*luminosity,
0x14*(float) ((gNbrLeds-i)/ (float) gNbrLeds)*luminosity,
0*luminosity);
}
}
//Take the position of the trill bar and render the bar graph
void TrillBarTask(void*)
{
float Position;
while(!Bela_stopRequested()) {
gTouchSensor.readI2C();
int ActiveTouches = gTouchSensor.getNumTouches();
if( ActiveTouches > 0) {
Position = gTouchSensor.compoundTouchLocation();
gLedStrip.Begin();
RenderBarGraph(Position);
gLedStrip.End();
}
usleep(gTrillRefreshRate);
}
}
bool setup(BelaContext *context, void *userData)
{
if(!gLedStrip.Init(LedStripSpi::YF923F5F8,gNbrLeds)) {
fprintf(stderr, "Unable to initialise LedStrip\n");
return false;
}
//trill
if(gTouchSensor.setup(1, Trill::BAR) != 0) {
fprintf(stderr, "Unable to initialise Trill Bar\n");
return false;
}
Bela_runAuxiliaryTask(LedStripTask, 90);
Bela_runAuxiliaryTask(TrillBarTask, 90);
return true;
}
void render(BelaContext *context, void *userData)
{
}
void cleanup(BelaContext *context, void *userData)
{
}4 days later
Hi @PFaivre, thanks for your contribution, what part numbers does YF923F5F8 refer to?
11 days later
giuliomoro This assumes BelaMini is used and the neopixels are driven from pin P2.25. To enable that you'll need to run config-pin P2.25 spi after each reboot ( this can be automated later if needed).
Hi, Could you maybe elaborate on automating this? I could not get this to work with the "user command line arguments"...
- Edited
you'd need to do something along the lines of what you see here.
is that clear enough?
noah automating this?
The solution linked above is probably the easiest if you are using supercollider or Pd or Csound. But if you are using C++, you can do it in a simpler way.
Put this line at the top of the file:
#include <stdlib.h>and then in setup() add this:
system("config-pin P2.25 spi"); Perfect, thanks so much!
6 months later
Hijacking this thread again:
I've got some WS2812B 4x4 matrices and I've basically got them running quite well on a Bela mini, however, I still do get the occasional quirks (random single LEDs flashing in random colors every 20 or so seconds). I do think it's not HW related, as I have checked all connections, but it could still be some GND issue I assume.
I also don't know the exact manufacturer of the matrices, so I don't have a datasheet, but I think the standard WS2812B times you also used are working well.
I slowly don't know how to approach this issue anymore. @giuliomoro you wrote about the leading zeros and resulting random flashing if not done correctly. How did you determine those numbers (e.g. kSpiLeadingZerosNs)? I tried playing around a bit with those and I do think there are improvements, but as long as there are random flashes it's really hard to tell a difference between improvement and coincidence...
How many LEDs are you driving at once? Where are they powered from?
- Edited
I'm driving 64 LEDs (usually not more than 32 at once). They're powered from a 5V/2A supply, Bela is currently powered from my Laptop, but was also already running powered from the same power supply. While bela is powered from my laptop, I have connected the supply's GND to Belas GND, this was necessary to get the SPI working correctly.
Things have evolved a bit since the code you've been using: I made a stand-alone OSC-to-Neopixel bridge, see https://forum.bela.io/d/3001-control-neopixel-with-pure-data/6 .
OSC format is as simple as sending to /leds/setRaw/rgb a set of floats or ints: offset gain led0r led0g led0b led1r led1g led1b... where offset is the offset from the first LED, gain is an overall gain control and then the rest are the values for each LED's red, green or blue components. If you want to send single-component data, use, e.g.:/leds/setRaw/g followed by offset gain led0g led1g led2g (same for r or b);
A simple Sc example to interact with it would be:
~displayOSC = NetAddr.new("bela.local", 7562);
~displayOSC.sendMsg('/leds/setRaw/rgb', 0, 1, 255, 0, 0, 0, 255, 0 );Values for LEDs should normally be betwen 0 to 255 and gain should be between 0 and 1. However, you may find it easier to have LED values betwen 0 and 1 and having gain between 0 and 255. Either way, these two values are multiplied. So the below is equivalent to the above:
~displayOSC.sendMsg('/leds/setRaw/rgb', 0, 255, 1, 0, 0, 0, 1, 0 );Now, I am not sure this fixes any of the issues you are observing, though some bugs may have been fixed in the process, but at the very least it allows us to start form a more modern and maintainable common ground and also perform some extra tests. For instance, you could have O2L running on the board, no Bela program running on the board and Sc running on the host, sending messages to O2L: does the issue still present itself?
noah I'm driving 64 LEDs (usually not more than 32 at once). They're powered from a 5V/2A supply, Bela is currently powered from my Laptop, but was also already running powered from the same power supply. While bela is powered from my laptop, I have connected the supply's GND to Belas GND, this was necessary to get the SPI working correctly.
That looks OK.
Thanks for the link! I was about to integrate your AddressableLeds class from your O2L project in my (C++) project some days ago, but decided to stay with a modified version of the LedStripSpi class by PFaivre that you can find in this thread above (I basically update my LEDs colors constantly in an auxiliary task with a custom refresh rate).
PFaivre i have encapsulate them in a class for easy usage
Latency and performance are quite crucial in my project and unfortunately I also don't have a lot of time to spare anymore, which was the reason I originally decided not to switch to your AddressableLeds class.
I assumed that the Spi implementation was not very different in your O2L project, but it might be worth a try.
Thinking about performance, would I implement your class with send() in a looped auxiliary task? What would be your approach to implement this in C++ without OSC?
thanks for your help.
- Edited
There are several possible reasons why the project may not behave as desired and give pseudo-random flashes, due to the system operating out - or nearly out of - specs. Not knowing the maker of your LEDs doesn't really help in figuring out the issue.
1- many WS2812B-style LEDs expect a digital input voltage - according to the datasheet - that is at least 0.7 * Vcc. Now, when the LEDs are powered from Vcc=5V, this means that in principle the 3.3V from the Bela's SPI output are not enough (though they work in many cases). See possible solutions here https://forum.bela.io/d/3001-control-neopixel-with-pure-data/25
2- timing (and tolerance of the timing) can also vary quite a lot among parts, see same post as above . You may want to get a few datasheets from parts that are likely to be on your boards and see if fine-tuning the T0L, T0H, T1L, T1H helps removing the issue.
3- I assume that the Linux driver will service buffers that are between 160 and 4096 bytes in length via a single DMA transaction. IIRC, I inferred this back in the day by looking at signals generated on a scope. I therefore assume that any CPU load on the board will only affect the delay between asking the transaction to start and the moment it is started, but it shouldn't affect inter-byte timing, which is what is critical here and could be the cause for the sort of behaviour you are seeing. It may be that what you are seeing is the effect of me being wrong on this assumption and in that case, having O2L running on its own reacting to OSC messages would put you in a situation where you can test that for yourself as there would be no load on the board except for the program responsible of parsing OSC and sending out SPI data. For this test, we'd need to also increase the priority of that thread (e.g.: running once in that thread:
struct sched_param p = {
.sched_priority = 90,
};
pthread_setschedparam(pthread_self(), SCHED_FIFO, &p);)
noah How did you determine those numbers (e.g. kSpiLeadingZerosNs)
Most numbers come from reading the datasheet, e.g.:
The first four should be used for TH and TL in the code, while RES should be used for kSpiLeadingZerosNs. From this specific datasheet, you'd get
const T_t TH[2] = {
{.min = 220, .max = 380}, // T0H
{.min = 580, .max = 1000}, // T1H
};
const T_t TL[2] = {
{.min = 580, .max = 1000}, // T0L
{.min = 580, .max = 1000}, // T1L
};
static constexpr double kSpiLeadingZerosNs = 280000; You'll notice these are different from what's in the code right now, which goes to show the importance of knowing the device at hand.
Anyhow, in your case you may want to try and increase kSpiLeadingZerosNs to something like 300000. Unless you are using an inverting FET on the output, in which case it should be set to 0 (see linked thread).
noah Thinking about performance, would I implement your class with send() in a looped auxiliary task? What would be your approach to implement this in C++ without OSC?
Just call send() from an auxiliary task, sure.