Ledmatrix in outputs only white when colors are not in total dominance of red, green or blue

Im using esp32 cam and fastled library to grab pixelvalues from the integritet camera for trigging a ledmatrix connected with serpentine layout. The image is downsampled to 12x12 pixels corresponding to the amount of leds in the ledmatrix and looks like below. (in the image every pixel is 10 pixel big to better display the image)

enter image description here

When I am outputting something with clear red, green or blue everything looks as it should on the ledmatrix. Something like 200,40,35 also outputs a red dominant color.

But when I am outputting the values from the cam as on the image below the values are less dominant from red green or blue and are outputting something like 111, 147, 118. When I am connecting this to leds all the leds seems to be in the same color and outputts more or less white as in the image below.

I have checked the values and habe also tried to just grab one rgb value from the image and no matter what pixel I grab the image seem to be pretty much only white.

This is my code for just grabbing one pixel, and alternate it with red, green and blue color. RGB is correct but with a value copied from the rgbfile array it is only white.

    void testColors()
    {
      for (uint8_t hue = 0; hue < 255; hue++)
      {
        fill_solid(leds, NUM_LEDS, CRGB(111, 147, 118));
        FastLED.show();
        delay(1000);     
        FastLED.clear(); 
        delay(1000);     
    
        fill_solid(leds, NUM_LEDS, CRGB(255, 0, 0)); // Red color
        FastLED.show();
        Serial.println("RED");
        delay(1000);    
        FastLED.clear(); 
        delay(1000);     
    
        fill_solid(leds, NUM_LEDS, CRGB(0, 255, 0)); // Green color
        FastLED.show();
        Serial.println("GREEN");
        delay(1000);    
        FastLED.clear(); 
        delay(1000);     
    
        fill_solid(leds, NUM_LEDS, CRGB(0, 0, 255)); // Blue color
        FastLED.show();
        Serial.println("BLUE");
        delay(1000);     
        FastLED.clear(); 
        delay(1000);     
      }
    }

This is my complete array. What do I miss to get the leds to output correct colors?

    int rgbFile[] = {
        254, 254, 254,
        254, 254, 254,
        253, 255, 253,
        111, 147, 118,
        103, 125, 100,
        62, 123, 96,
        75, 111, 90,
        56, 102, 82,
        62, 94, 63,
        48, 86, 53,
        43, 84, 48,
        34, 74, 36,
        254, 254, 254,
        254, 254, 254,
        246, 255, 231,
        144, 167, 138,
        124, 146, 121,
        121, 146, 121,
        116, 140, 119,
        108, 131, 112,
        98, 123, 99,
        86, 110, 79,
        73, 102, 66,
        63, 86, 51,
        172, 205, 157,
        198, 230, 174,
        163, 189, 152,
        135, 162, 132,
        124, 152, 126,
        126, 147, 131,
        119, 144, 127,
        111, 136, 119,
        90, 127, 104,
        82, 113, 77,
        68, 100, 69,
        55, 80, 55,
        138, 160, 121,
        138, 168, 128,
        141, 163, 130,
        188, 224, 197,
        161, 197, 170,
        119, 152, 130,
        116, 148, 130,
        116, 142, 121,
        100, 127, 103,
        82, 109, 85,
        72, 98, 68,
        63, 82, 52,
        119, 141, 110,
        122, 143, 114,
        157, 187, 161,
        119, 155, 136,
        153, 173, 170,
        63, 86, 63,
        120, 153, 131,
        116, 143, 126,
        104, 131, 107,
        86, 103, 79,
        71, 84, 61,
        44, 66, 41,
        108, 132, 101,
        112, 135, 106,
        115, 123, 109,
        95, 100, 96,
        163, 189, 188,
        102, 128, 107,
        119, 154, 131,
        114, 139, 122,
        68, 94, 64,
        59, 78, 54,
        44, 68, 43,
        31, 58, 34,
        105, 117, 92,
        98, 126, 100,
        95, 95, 70,
        130, 151, 151,
        136, 162, 161,
        109, 126, 133,
        111, 146, 119,
        125, 152, 136,
        126, 151, 134,
        48, 54, 36,
        41, 55, 36,
        31, 39, 25,
        80, 75, 56,
        74, 92, 64,
        143, 160, 132,
        79, 103, 96,
        160, 188, 182,
        76, 93, 92,
        118, 138, 141,
        87, 109, 113,
        68, 74, 80,
        48, 58, 60,
        45, 55, 59,
        33, 47, 32,
        78, 94, 72,
        94, 126, 95,
        78, 87, 60,
        103, 117, 108,
        58, 81, 107,
        72, 81, 102,
        65, 78, 103,
        59, 69, 90,
        64, 74, 79,
        55, 61, 60,
        44, 44, 45,
        52, 69, 45,
        93, 115, 84,
        91, 128, 99,
        158, 193, 168,
        51, 54, 41,
        73, 77, 99,
        70, 77, 97,
        66, 80, 97,
        64, 65, 72,
        56, 64, 75,
        49, 54, 56,
        38, 43, 44,
        21, 41, 28,
        96, 122, 95,
        167, 209, 171,
        113, 132, 92,
        54, 82, 62,
        60, 70, 91,
        60, 69, 94,
        64, 69, 89,
        57, 66, 80,
        51, 58, 66,
        36, 43, 51,
        33, 38, 34,
        43, 56, 44,
        43, 56, 34,
        82, 111, 71,
        64, 67, 35,
        46, 48, 46,
        68, 61, 85,
        53, 59, 81,
        42, 63, 79,
        52, 53, 68,
        46, 49, 58,
        33, 41, 40,
        35, 35, 38,
        22, 29, 30};

I think the problem is in the code you didn't post.

Have you read the forum guide? Lots of advice about how to avoid asking questions that no-one can possibly answer.

Well here it comes then :slight_smile:

#include <Arduino.h>
#include <FastLED.h>

#define LED_PIN 15

#define COLOR_ORDER RGB
#define CHIPSET WS2812

#define BRIGHTNESS 5
int rgbFile[] = {117, 165, 126,
                 108, 162, 112,
                 111, 161, 117,
                 131, 175, 137,
                 160, 213, 179,
                 153, 199, 172,
                 172, 215, 191,
                 159, 206, 183,
                 166, 214, 181,
                 161, 222, 175,
                 166, 224, 175,
                 159, 218, 166,
                 133, 169, 138,
                 106, 138, 123,
                 122, 157, 130,
                 134, 169, 144,
                 145, 188, 160,
                 161, 210, 182,
                 163, 212, 184,
                 160, 214, 188,
                 167, 219, 189,
                 166, 221, 181,
                 168, 222, 180,
                 162, 218, 169,
                 141, 170, 140,
                 133, 171, 135,
                 101, 155, 117,
                 126, 165, 126,
                 139, 181, 159,
                 160, 212, 182,
                 163, 209, 182,
                 131, 178, 163,
                 159, 221, 191,
                 164, 218, 184,
                 162, 217, 177,
                 161, 218, 173,
                 132, 169, 140,
                 138, 176, 139,
                 135, 169, 148,
                 114, 155, 137,
                 131, 171, 152,
                 160, 209, 181,
                 106, 156, 135,
                 70, 120, 135,
                 126, 180, 183,
                 162, 215, 185,
                 161, 214, 180,
                 159, 213, 171,
                 129, 171, 145,
                 135, 175, 149,
                 132, 181, 153,
                 153, 190, 167,
                 148, 200, 179,
                 145, 194, 175,
                 61, 135, 145,
                 110, 177, 203,
                 158, 226, 255,
                 115, 165, 150,
                 153, 205, 177,
                 150, 204, 166,
                 132, 167, 142,
                 131, 167, 146,
                 127, 178, 153,
                 145, 194, 166,
                 154, 200, 180,
                 121, 174, 150,
                 72, 104, 111,
                 72, 134, 169,
                 85, 139, 167,
                 126, 169, 168,
                 142, 197, 173,
                 141, 194, 154,
                 119, 164, 135,
                 127, 166, 143,
                 124, 173, 152,
                 133, 188, 166,
                 145, 194, 173,
                 82, 141, 112,
                 78, 148, 169,
                 144, 217, 255,
                 125, 192, 224,
                 96, 155, 156,
                 130, 183, 159,
                 109, 163, 127,
                 110, 154, 134,
                 107, 157, 136,
                 118, 168, 147,
                 123, 180, 158,
                 131, 186, 170,
                 46, 108, 87,
                 83, 143, 165,
                 144, 210, 250,
                 160, 229, 255,
                 90, 136, 139,
                 59, 126, 104,
                 96, 169, 152,
                 74, 126, 98,
                 88, 143, 114,
                 109, 157, 138,
                 140, 200, 185,
                 145, 210, 188,
                 80, 151, 128,
                 73, 115, 131,
                 26, 46, 105,
                 160, 233, 255,
                 189, 221, 228,
                 52, 105, 87,
                 97, 172, 150,
                 81, 105, 98,
                 54, 92, 89,
                 73, 109, 102,
                 82, 126, 121,
                 80, 137, 125,
                 99, 171, 150,
                 55, 101, 123,
                 91, 163, 204,
                 123, 186, 206,
                 62, 111, 92,
                 55, 83, 69,
                 103, 176, 147,
                 69, 98, 88,
                 55, 95, 87,
                 64, 124, 109,
                 59, 108, 102,
                 130, 193, 177,
                 104, 134, 108,
                 47, 73, 81,
                 76, 132, 146,
                 105, 175, 184,
                 81, 125, 105,
                 65, 89, 75,
                 98, 151, 103,
                 64, 107, 89,
                 70, 107, 90,
                 76, 117, 65,
                 77, 107, 75,
                 44, 94, 55,
                 49, 73, 81,
                 71, 113, 129,
                 67, 143, 172,
                 134, 176, 185,
                 83, 126, 102,
                 68, 107, 84,
                 54, 92, 66};

#define NUM_LEDS 144
#define NUM_RGBVALS (NUM_LEDS * 3) // 12 * 12 * 3

CRGB leds_plus_safety_pixel[NUM_LEDS + 1];
CRGB *const leds(leds_plus_safety_pixel + 1);

void testColors();

void setup()
{
    Serial.begin(115200); // Start serial communication
    FastLED.addLeds<CHIPSET, LED_PIN, COLOR_ORDER>(leds, NUM_LEDS).setCorrection(TypicalSMD5050);
    FastLED.setBrightness(BRIGHTNESS);
}

void loop()
{
    FastLED.setBrightness(BRIGHTNESS);
    testColors();
}

void testColors()
{
    for (uint8_t hue = 0; hue < 255; hue++)
    {
        fill_solid(leds, NUM_LEDS, CRGB(111, 161, 117));
        FastLED.show();
        delay(1000);
        FastLED.clear();
        delay(1000);

        fill_solid(leds, NUM_LEDS, CRGB(255, 0, 0)); // Red color
        FastLED.show();
        Serial.println("RED");
        delay(1000);
        FastLED.clear();
        delay(1000);

        fill_solid(leds, NUM_LEDS, CRGB(0, 255, 0)); // Green color
        FastLED.show();
        Serial.println("GREEN");
        delay(1000);
        FastLED.clear();
        delay(1000);

        fill_solid(leds, NUM_LEDS, CRGB(0, 0, 255)); // Blue color
        FastLED.show();
        Serial.println("BLUE");
        delay(1000);
        FastLED.clear();
        delay(1000);
    }
}

This is declared but never used. It might have probably has an effect on the signal (intensity) to each LED in the WS2812.

Exactly why should that have any effect?

I would first start playing with the BRIGHTNESS setting that you apply. Try e.g. full brightness and half brightness.

I would guess that not using this large value would allow the same amount of power to go to the small number of LEDs/pixels, giving each LED higher intensity (toward white).

This colour isn't going to be a strong or rich colour, it will be approximately white, perhaps with a green tinge. The 3 values are within 30~40% of each other

Are the other colours you tested like that?

How are you powering the strip? 144 LEDs will need a lot of current!

NUM_RGBVALS contains the number of values to display 144 rgb leds. It is not used in this simplified sketch and sorry but an unused declaration has nothing to do with what you are talking about :slight_smile:

Both esp32 and the strip is powered through external powersupply. There shouldnt be any current problem.

Yes I know they are pretty whitish the colors but I was although expecting some kind of variation from this image. They seem all to be pretty white.

image

Well.... If all of the numbers are about equal you'll just get dimmer "white" as the numbers go down. That's perfectly valid for an "image" from a camera, etc., but not very "interesting".

...I'm in the "conceptual stage" of a project and I'll probably have one color full-brightness at all times. And maybe another color off at all times. I'll probably want to avoid white or near-white and any "dim" colors except for all-off. I want lots of contrast & color-contrast. I'll have to experiment but I will be limiting the color range.

Unless I've misunderstood, you are setting all your LEDs to the same colour? So there's no visual context to enable your eyes to see the variations between those colours in your captured image. Perhaps, once you are rendering the complete 12x12 image, you will be able to perceive the differences between all those shades of off-white.

okey, I tried this. I got an array with 432 numbers that should be mapped to RGB (three values each over 144 pixels):

I am now looping over the values in the rgbFile array distributing them over each led. What I can tell this should be correct but I am not getting an output that makes sense. It is not only white anymore but no colors that match the actual image.

This is the image plotted in pixels through processing:
image

This is the leds:
image

I have tried with different color orders RGB, GRB, BGR and different brightness but nothing really makes sense ...

What do I miss?

Here is my code:

#include "esp_camera.h"
#include <Arduino.h>
#include <FastLED.h>

#define LED_PIN 15

#define COLOR_ORDER GRB
#define CHIPSET WS2812
#define BRIGHTNESS 15

// 12 * 12
#define TARGET_WIDTH 12
#define TARGET_HEIGHT 12
#define NUM_LEDS (TARGET_WIDTH * TARGET_HEIGHT)
#define NUM_RGBVALS (TARGET_WIDTH * TARGET_HEIGHT * 3) // 12 * 12 * 3

void processingExport(int arr[]);
void DrawRGBFromArray(int arr[]);
const bool serialDebug = 1; // show debug info. on serial port (1=enabled, disable if using pins 1 and 3 as gpio)

int rgbFile[] = {
    135, 158, 141,
    130, 151, 136,
    127, 154, 130,
    147, 165, 145,
    177, 196, 186,
    160, 191, 175,
    169, 201, 183,
    169, 199, 187,
    179, 206, 190,
    178, 208, 182,
    184, 210, 180,
    177, 209, 171,
    138, 158, 138,
    131, 144, 129,
    137, 144, 126,
    153, 160, 143,
    166, 180, 166,
    178, 200, 185,
    169, 200, 185,
    173, 205, 190,
    179, 211, 193,
    179, 209, 191,
    185, 213, 187,
    173, 211, 174,
    150, 166, 146,
    143, 159, 145,
    122, 146, 131,
    149, 155, 141,
    154, 176, 161,
    173, 201, 187,
    173, 211, 192,
    139, 167, 163,
    175, 212, 196,
    166, 211, 187,
    175, 210, 187,
    172, 209, 176,
    141, 164, 143,
    151, 165, 151,
    148, 159, 152,
    132, 148, 140,
    145, 166, 160,
    170, 202, 187,
    141, 169, 166,
    67, 107, 121,
    113, 143, 152,
    170, 208, 189,
    166, 206, 187,
    172, 204, 173,
    146, 166, 147,
    143, 167, 152,
    154, 175, 160,
    152, 185, 164,
    172, 192, 179,
    151, 189, 176,
    70, 116, 144,
    124, 167, 205,
    175, 220, 255,
    162, 200, 187,
    166, 199, 181,
    161, 197, 170,
    148, 161, 146,
    147, 161, 152,
    145, 171, 157,
    155, 185, 175,
    158, 192, 184,
    135, 165, 153,
    83, 102, 128,
    82, 129, 178,
    105, 151, 186,
    164, 182, 192,
    161, 190, 174,
    153, 184, 162,
    130, 158, 144,
    147, 154, 143,
    137, 167, 159,
    142, 177, 166,
    155, 185, 177,
    117, 143, 129,
    87, 128, 171,
    165, 215, 255,
    159, 196, 251,
    98, 144, 153,
    148, 170, 161,
    128, 155, 139,
    129, 145, 137,
    128, 146, 138,
    118, 162, 148,
    135, 167, 164,
    143, 178, 173,
    58, 88, 78,
    98, 135, 166,
    150, 179, 234,
    172, 219, 255,
    88, 120, 128,
    71, 115, 108,
    106, 163, 157,
    91, 110, 86,
    103, 126, 126,
    103, 152, 141,
    142, 182, 174,
    163, 207, 194,
    75, 114, 115,
    61, 107, 123,
    75, 89, 159,
    172, 221, 255,
    186, 214, 231,
    66, 86, 83,
    105, 167, 154,
    96, 105, 88,
    83, 102, 96,
    91, 114, 114,
    93, 126, 115,
    81, 133, 132,
    109, 158, 152,
    69, 99, 135,
    114, 159, 214,
    132, 174, 214,
    72, 106, 99,
    62, 78, 77,
    119, 166, 153,
    96, 88, 77,
    67, 99, 102,
    87, 111, 109,
    75, 120, 113,
    160, 195, 200,
    77, 108, 80,
    63, 69, 85,
    102, 140, 169,
    128, 172, 181,
    82, 117, 117,
    62, 84, 81,
    93, 132, 104,
    91, 97, 89,
    63, 102, 96,
    81, 99, 79,
    63, 82, 59,
    67, 84, 60,
    51, 63, 92,
    57, 87, 122,
    89, 142, 193,
    73, 104, 115,
    83, 118, 95,
    72, 103, 87,
    112, 141, 113};

const int serialSpeed = 115200; // Serial data speed to use
int ledIndex = 0;               // Index to track the current LED being set

uint16_t XY(uint8_t x, uint8_t y)
{
    uint16_t i;

    if (y & 0x01)
    {
        // Odd rows run backwards
        uint8_t reverseX = (TARGET_WIDTH - 1) - x;
        i = (y * TARGET_WIDTH) + reverseX;
    }
    else
    {
        // Even rows run forwards
        i = (y * TARGET_WIDTH) + x;
    }

    return i;
}

CRGB leds_plus_safety_pixel[NUM_LEDS + 1];
CRGB *const leds(leds_plus_safety_pixel + 1);

void setup()
{
    Serial.begin(serialSpeed); // Start serial communication

    FastLED.addLeds<CHIPSET, LED_PIN, COLOR_ORDER>(leds, NUM_LEDS).setCorrection(TypicalSMD5050);
    FastLED.setBrightness(BRIGHTNESS);
}

void loop()
{
    DrawRGBFromArray(rgbFile);
    delay(5000);
}

void DrawRGBFromArray(int arr[])
{
    ledIndex = 0;

    for (uint8_t y = 0; y < TARGET_HEIGHT; y++)
    {
        for (uint8_t x = 0; x < TARGET_WIDTH; x++)
        {
            Serial.print(XY(x, y) + String(" : "));
            uint8_t r = arr[ledIndex];
            Serial.print("LEDINDEX: " + String(ledIndex) + "  R: " + String(arr[ledIndex]) + String(" , "));
            ledIndex++;
            uint8_t g = arr[ledIndex];
            Serial.print("LEDINDEX: " + String(ledIndex) + "  G: " + String(arr[ledIndex]) + String(" , "));
            ledIndex++;
            uint8_t b = arr[ledIndex];
            Serial.print("LEDINDEX: " + String(ledIndex) + "  B: " + String(arr[ledIndex]) + String(" , "));
            ledIndex++;

            leds[XY(x, y)] = CRGB(r, g, b);
            Serial.println("");
        }
        Serial.println("");
    }

    Serial.println("");
    Serial.println("");
    Serial.println("");

    FastLED.show();
}


Multiply each LEDvalue by 0.1 (1/10th the brightness)... or 0.3 or 0.5...

NUM_RGBVALS is the size of the individual LED elements in the matrix (12x12x3). The name suggests that the "12x12" will address each Pixel, with the "3" part of the dimension being the three values of R and G and B. rgbFile[] is doing a similar thing in one-dimension... so you can for-loop that array using NUMRGBVALS as the end value to the loop.

The pixelated image looks familiar. I wish it be just a red ball.

Im using the xy value in a function for serpentine layout of the leds strips so ... no I need 2d.

You add 1 to increase columns, add 12 to increase rows. Simple base 12 counting, so Yes.

Begin with a simpler image for testing. Such as a white background with a red vertical or horizontal stripe across it.

This will also help you test the whole process. The RGB values in your array should be only 2 sets of values (approximately), something like 255, 255, 255 or 255, 0, 0 or values close to that.

I agree. Make one LED of one Pixel do what you want, then make one Pixel work. That should give you all the x,y you need. (but, it's still a one-dimension array)

I made your Neopixel array show on a 12x12 neopixel with two lines:

  for (int i = 0; i < 144; i++) {
     leds[i] = CRGB(rgbFile[i*3+0], rgbFile[i*3+1], rgbFile[i*3+2]);
  }

I also used the instance call from the FastLED library, which made the picture darker.

  FastLED.addLeds<WS2812, LED_PIN, COLOR_ORDER>(leds, NUM_LEDS);  
  // FastLED.addLeds<CHIPSET, LED_PIN, COLOR_ORDER>(leds, NUM_LEDS).setCorrection(TypicalSMD5050);

As you can see in my algorithm, the array is linear, not two-dimensional. I counted from zero to NUM_LEDS, multiplied the pixel number by 3 and add 0, 1 or 2 for the color.

The result was this:

Images (your pixelated image) use additive colors (RYB) but light (Neopixels) use subtractive colors (CYM). The two will look similar, but Neopixels will always be brighter. That is to say, you can't make a "dark yellow, dark red, or dark blue" in Neopixel, just a less-bright color.

#include <FastLED.h>
#define LED_PIN 15

#define COLOR_ORDER GBR
#define CHIPSET WS2812
#define BRIGHTNESS 255

#define TARGET_WIDTH 12
#define TARGET_HEIGHT 12
#define NUM_LEDS (TARGET_WIDTH * TARGET_HEIGHT)

CRGB leds[NUM_LEDS];

int rgbFile[] = {
  135, 158, 141,
  130, 151, 136,
  127, 154, 130,
  147, 165, 145,
  177, 196, 186,
  160, 191, 175,
  169, 201, 183,
  169, 199, 187,
  179, 206, 190,
  178, 208, 182,
  184, 210, 180,
  177, 209, 171,
  138, 158, 138,
  131, 144, 129,
  137, 144, 126,
  153, 160, 143,
  166, 180, 166,
  178, 200, 185,
  169, 200, 185,
  173, 205, 190,
  179, 211, 193,
  179, 209, 191,
  185, 213, 187,
  173, 211, 174,
  150, 166, 146,
  143, 159, 145,
  122, 146, 131,
  149, 155, 141,
  154, 176, 161,
  173, 201, 187,
  173, 211, 192,
  139, 167, 163,
  175, 212, 196,
  166, 211, 187,
  175, 210, 187,
  172, 209, 176,
  141, 164, 143,
  151, 165, 151,
  148, 159, 152,
  132, 148, 140,
  145, 166, 160,
  170, 202, 187,
  141, 169, 166,
  67, 107, 121,
  113, 143, 152,
  170, 208, 189,
  166, 206, 187,
  172, 204, 173,
  146, 166, 147,
  143, 167, 152,
  154, 175, 160,
  152, 185, 164,
  172, 192, 179,
  151, 189, 176,
  70, 116, 144,
  124, 167, 205,
  175, 220, 255,
  162, 200, 187,
  166, 199, 181,
  161, 197, 170,
  148, 161, 146,
  147, 161, 152,
  145, 171, 157,
  155, 185, 175,
  158, 192, 184,
  135, 165, 153,
  83, 102, 128,
  82, 129, 178,
  105, 151, 186,
  164, 182, 192,
  161, 190, 174,
  153, 184, 162,
  130, 158, 144,
  147, 154, 143,
  137, 167, 159,
  142, 177, 166,
  155, 185, 177,
  117, 143, 129,
  87, 128, 171,
  165, 215, 255,
  159, 196, 251,
  98, 144, 153,
  148, 170, 161,
  128, 155, 139,
  129, 145, 137,
  128, 146, 138,
  118, 162, 148,
  135, 167, 164,
  143, 178, 173,
  58, 88, 78,
  98, 135, 166,
  150, 179, 234,
  172, 219, 255,
  88, 120, 128,
  71, 115, 108,
  106, 163, 157,
  91, 110, 86,
  103, 126, 126,
  103, 152, 141,
  142, 182, 174,
  163, 207, 194,
  75, 114, 115,
  61, 107, 123,
  75, 89, 159,
  172, 221, 255,
  186, 214, 231,
  66, 86, 83,
  105, 167, 154,
  96, 105, 88,
  83, 102, 96,
  91, 114, 114,
  93, 126, 115,
  81, 133, 132,
  109, 158, 152,
  69, 99, 135,
  114, 159, 214,
  132, 174, 214,
  72, 106, 99,
  62, 78, 77,
  119, 166, 153,
  96, 88, 77,
  67, 99, 102,
  87, 111, 109,
  75, 120, 113,
  160, 195, 200,
  77, 108, 80,
  63, 69, 85,
  102, 140, 169,
  128, 172, 181,
  82, 117, 117,
  62, 84, 81,
  93, 132, 104,
  91, 97, 89,
  63, 102, 96,
  81, 99, 79,
  63, 82, 59,
  67, 84, 60,
  51, 63, 92,
  57, 87, 122,
  89, 142, 193,
  73, 104, 115,
  83, 118, 95,
  72, 103, 87,
  112, 141, 113
};

void setup()
{
  FastLED.addLeds<WS2812, LED_PIN, COLOR_ORDER>(leds, NUM_LEDS);  
  // FastLED.addLeds<CHIPSET, LED_PIN, COLOR_ORDER>(leds, NUM_LEDS).setCorrection(TypicalSMD5050);
  FastLED.setBrightness(BRIGHTNESS);

  for (int i = 0; i < NUM_LEDS; i++) {
     leds[i] = CRGB(rgbFile[i*3+0], rgbFile[i*3+1], rgbFile[i*3+2]);
  }
   FastLED.show();
}

void loop() {}

No. Neopixels use RGB, because those are the light colours/wavelengths that the cone cells in your retina are sensitive to. To the eye, light colours are additive, for example red+green=yellow.