sending 512 rgb pixels to ESP 32 as a ZIGZAG strip of two 256 leds. RESOLVED

Hi,

I would like to control one strip of 256 or 512 or 768 or 1024 leds as fast as possible?

I checked the library FastLed we can control led directly with Hexadecimal but we can't use directly int 8 or int 16. Otherwise we have to convert int to rgb in Esp 32.

I think sending and receiving hexadecimal will be faster than sending unit 16 and convert it to r,g,b in Esp32.

I like the manner to send one line of 256 datas, then one line of 256 ... until a fourth.

I manage to convert data as RGB 565 but I get lost by the arrangement of the data to make a zigzag, as my strip is. I have divided / 3 [zl.group] and [zl.slice] but it's not good.

I worked with chat gpt, and I can receive block of 127 hexadecimal. So I don't know if receiving two blocks of R, G, B datas is not faster than receiving 4 blocks of Hexadecimal datas

So I let the code here, to find it later, when I will mange to change the MAX/msp patch into RGB 565 then Hexa.

For the moment, your last Arduino code posted on JUN 18, 2025 AT 7:47 AM, is totally good!!

Thank u!

#include <WiFi.h>
#include <WiFiUdp.h>
#include <OSCMessage.h>
#include <FastLED.h>

#define NUM_LEDS 512
#define PIN_CONTROLLING_STRIP 23
CRGB leds[NUM_LEDS];

// WiFi config
const char* ssid = "MERCUSYS_RE_13CF";
const char* password = "Poiuytreza8@";

// OSC config
WiFiUDP Udp;
const unsigned int localPort = 8009;
IPAddress local_IP(192, 168, 0, 9);
IPAddress gateway(10, 10, 10, 1);
IPAddress subnet(255, 255, 0, 0);

void setup() {
  Serial.begin(115200);
  WiFi.mode(WIFI_STA);
  WiFi.config(local_IP, gateway, subnet);
  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  Serial.println("\nWiFi connecté !");
  Serial.println(WiFi.localIP());

  Udp.begin(localPort);
  Serial.printf("OSC en écoute sur le port %d\n", localPort);

  FastLED.addLeds<NEOPIXEL, PIN_CONTROLLING_STRIP>(leds, NUM_LEDS);
  FastLED.setBrightness(180);
  FastLED.clear();
  FastLED.show();
}

void loop() {
  OSCMessage msg;
  int size = Udp.parsePacket();
  if (size > 0) {
    while (size--) {
      msg.fill(Udp.read());
    }
    if (!msg.hasError()) {
      msg.route("/leds/0", handleLEDRange0);
      msg.route("/leds/128", handleLEDRange128);
      msg.route("/leds/256", handleLEDRange256);
      msg.route("/leds/384", handleLEDRange384);
    }
  }
}

// Fonctions pour chaque tranche de 128 LEDs
void updateLEDRange(OSCMessage &msg, int addrOffset, int startIndex) {
  int count = min(msg.size(), 128);
  for (int i = 0; i < count; i++) {
    if (!msg.isInt(i)) continue;
    uint32_t color = msg.getInt(i) & 0xFFFFFF;
    int ledIndex = startIndex + i;
    if (ledIndex < NUM_LEDS) {
      leds[ledIndex] = color;

// check if r,g,b match with Hexadecimal
      uint8_t r = (color >> 16) & 0xFF;
      uint8_t g = (color >> 8) & 0xFF;
      uint8_t b = color & 0xFF;
      Serial.printf("LED %03d → #%02X%02X%02X\n", ledIndex, r, g, b);
    }
  }
  FastLED.show();
}

void handleLEDRange0(OSCMessage &msg, int addrOffset)   { updateLEDRange(msg, addrOffset, 0); }
void handleLEDRange128(OSCMessage &msg, int addrOffset) { updateLEDRange(msg, addrOffset, 128); }
void handleLEDRange256(OSCMessage &msg, int addrOffset) { updateLEDRange(msg, addrOffset, 256); }
void handleLEDRange384(OSCMessage &msg, int addrOffset) { updateLEDRange(msg, addrOffset, 384); }