Arduino.ru

Ну, навскидку:

1) В DO летит помеха, которая воспринимается как последовательность бит для "красного", "синего" и пр. 

Скетч написан с помощью библиотеки "Адафрукт неопиксель". Скетч и вариации катаю на двух кубах. Есть особенность у pl9823, когда включаю к питанию они все ярко вспыхивают на мгновение и дальше по скетчу с бликами. А ws2812b включаются не сразу , но по скетчу... Как помехи исключить,? у каждого пикселя конденсатор по питанию на 0,1 мкф и ограничительный резистор на 75 Ом.

// Подключаем библиотеку Adafruit NeoPixel.
#include "Adafruit_NeoPixel.h"

// Указываем, какое количество пикселей у нашей ленты.
#define LED_COUNT1 125


// Указываем, к какому порту подключен вход ленты DIN.
#define LED_PIN1 6

Adafruit_NeoPixel strip1 = Adafruit_NeoPixel(LED_COUNT1, LED_PIN1, NEO_RGB + NEO_KHZ400);// Создаем переменную strip для управления нашей лентой. 
int T=100;int N=0;
int d=0;int d1=200;long y1=0;long y2=0;long Y1=0;long Y2=0;long Y3=0;long Y4=0;
 int x=0;int y=0;int z=0;
 int r=0;int g=0;int b=0;
 int k=50;//яркость свечения пикселя из 0 до 255 ступеней
 int j=0;int i=0;
 int k1=5;//число пикселей в ребре куба
 int n=75;//длительность переключений
int r1;int j1=0;
 int l=0;int l1=0;int y5=0;int v=1;
 
void setup()
{
 strip1.begin();

 
 }
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void loop()
{
 
  Y3=millis ();if (Y3-Y4>=60000){N=0;n=35;}
 
//////////////////////////////////////////////////  ПРОГРАММА РАДУЖНЫЙ ДОЖДИК  /////////////////////////////////////////////////////// 
while (d<6){
 g=random(0,2);r=random(0,2);b=random(0,2); 
 if (g==0&&r==0&&b==0){r=1;g=1;}
 
  // Включаем и выключаем по одному в одну сторону светодиоды.
 if(N!=1&&N!=0){goto metka1;}//////////////////////////////////////////////////////////
  for (i = 0; i <= k1-1; i++)
  {
    for(j=0;j<=k1*k1-1;j++)
    {
  strip1.setPixelColor(i+k1*j, strip1.Color(k*g,k*r,k*b)); //псевдослучайный цвет на яркости k
    } 
  strip1.show();
 
if(N!=1&&N!=0){goto metka1;}

  fun (2*n);///////////////////   ФУНКЦИЯ   ///////////////////
  if (i<=k1-2){
    for(j=0;j<=k1*k1-1;j++)
    { 
  strip1.setPixelColor(i+k1*j, strip1.Color(0,0,0));//выключение пикселя
    }
   strip1.show();}
  }
   // Включаем и выключаем по одному в другую сторону светодиоды.
   for (i=k1*k1*k1-1 ; i >= 0; i--)
  {
  strip1.setPixelColor(i, strip1.Color(k*g,k*r,k*b)); //псевдослучайный цвет
 strip1.show();
 if(N!=1&&N!=0){goto metka1;}
 fun (n);///////////////////   ФУНКЦИЯ   /////////////////// 
  strip1.setPixelColor(i, strip1.Color(0,0,0)); //выключение пикселя
  strip1.show();
  }d++;} metka1:
  j1=0; d=0;
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 
 ////////////////////////////////// ПРОГРАММА ПИКСЕЛЬНЫЙ АССОРТИ //////////////////////////////////////////
 while (d<4){
 int tabl1[3]={0,5,50};j1=tabl1[random(0,3)];// условие,задающее смену количества одновременно светящихся пикселей
 if(j1==50){d1=50;}else{d1=200;}
for(r1=0;r1<=d1;r1++)
{
  g=random(0,2);r=random(0,2);b=random(0,2); //псевдослучайный выбор цвета с исключением его отсутствия
  if (g==0&&r==0&&b==0){r=1;g=1;}
 x=random(0,5);y=random(0,5);z=random(0,5);
  strip1.setPixelColor(x+k1*y+k1*k1*z, strip1.Color(k*g,k*r,k*b)); //псевдослучайный цвет на яркости k
 strip1.show();
 if(N!=2&&N!=0){goto metka2;}
  fun (n);///////////////////   ФУНКЦИЯ   ///////////////////
  for(i=0;i<=j1;i++)
  {
  x=random(0,5);y=random(0,5);z=random(0,5);
  strip1.setPixelColor(x+k1*y+k1*k1*z, strip1.Color(0,0,0)); //псевдослучайное выключение пикселей
  strip1.show(); 
  } 
  }d++;}metka2:d=0;k1=6;
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 
 ////////////////////////////////// ПРОГРАММА ПЕРЕКЛЮЧЕНИЯ РАДУЖНОЕ СИЯНИЕ //////////////////////////////////////////
 while(d<35){
 g=random(0,2);r=random(0,2);b=random(0,2); //псевдослучайный выбор цвета с исключением его отсутствия
if (g==0&&r==0&&b==0){r=1;g=1;}
 y1=millis();if(y1-y2>=150*n){y5=!y5;y2=y1;}//условие смены переключения с одновременно одноцветного на двухцветное
 if(N!=3&&N!=0){goto metka3;}
  // Включаем и выключаем по одной плоскости в одну сторону по диагонали светодиоды.
  for (i = 0; i <= k1-1; i++)
  {
    for(j=0;j<=k1*k1-1;j++)
    {
  strip1.setPixelColor(i+k1*j, strip1.Color(k*g,k*r,k*b)); //псевдослучайный цвет на яркости k
    } 
  strip1.show();
  if(N!=3&&N!=0){goto metka3;}
fun (3*n);///////////////////   ФУНКЦИЯ   ///////////////////  
  if (i<=k1-2*y5){
    for(j=0;j<=k1*k1-1;j++)
    { 
  strip1.setPixelColor(i+k1*j, strip1.Color(0,0,0));//выключение пикселя
    }
   strip1.show();}
  }d++;}metka3:d=0;k1=5;j=0;
   
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 
  ////////////////////////////////// ПРОГРАММА ПРЫГАЮЩАЯ ЗВЕЗДА //////////////////////////////////////////
  for (i=0;i<=k1*k1*k1-1;i++)
{
 strip1.setPixelColor(i, strip1.Color(0,0,0)); 
}
 strip1.show();
 while (d<30){
  g=random(0,2);r=random(0,2);b=random(0,2); //псевдослучайный выбор цвета с исключением его отсутствия
  if (g==0&&r==0&&b==0){r=1;g=1;}
  if(N!=4&&N!=0){goto metka4;}
 x=random(0,3);y=random(0,3);z=random(0,3);
  strip1.setPixelColor((x+1)+k1*(y)+k1*k1*(z+1), strip1.Color(k*g,k*r,k*b)); //псевдослучайный цвет на яркости k
   strip1.setPixelColor((x+1)+k1*(y+1)+k1*k1*(z+1), strip1.Color(k*g,k*r,k*b));
    strip1.setPixelColor((x+1)+k1*(y+2)+k1*k1*(z+1), strip1.Color(k*g,k*r,k*b));
     strip1.setPixelColor((x)+k1*(y+1)+k1*k1*(z+1), strip1.Color(k*g,k*r,k*b));
      strip1.setPixelColor((x+2)+k1*(y+1)+k1*k1*(z+1), strip1.Color(k*g,k*r,k*b));
       strip1.setPixelColor((x+1)+k1*(y+1)+k1*k1*(z), strip1.Color(k*g,k*r,k*b));
        strip1.setPixelColor((x+1)+k1*(y+1)+k1*k1*(z+2), strip1.Color(k*g,k*r,k*b));
strip1.show();

fun (5*n);///////////////////   ФУНКЦИЯ   ///////////////////

 
   strip1.setPixelColor((x+1)+k1*(y)+k1*k1*(z+1), strip1.Color(0,0,0)); 
   strip1.setPixelColor((x+1)+k1*(y+1)+k1*k1*(z+1), strip1.Color(0,0,0));
    strip1.setPixelColor((x+1)+k1*(y+2)+k1*k1*(z+1), strip1.Color(0,0,0));
     strip1.setPixelColor((x)+k1*(y+1)+k1*k1*(z+1), strip1.Color(0,0,0));
      strip1.setPixelColor((x+2)+k1*(y+1)+k1*k1*(z+1), strip1.Color(0,0,0));
       strip1.setPixelColor((x+1)+k1*(y+1)+k1*k1*(z), strip1.Color(0,0,0));
        strip1.setPixelColor((x+1)+k1*(y+1)+k1*k1*(z+2), strip1.Color(0,0,0));// выключение пикселей
  strip1.show();
d++;}metka4:d=0;
 
//////////////////////////////////////////ПРОГРАММА ВРАЩЕНИЕ ПЛОСКОСТИ/////////////////////////////////////////////////////////
while(d<50){
g=random(0,2);r=random(0,2);b=random(0,2); //псевдослучайный выбор цвета с исключением его отсутствия
  if (g==0&&r==0&&b==0){r=1;g=1;}

//////////////////////////////////////////////////////////////////////////////////////////////////////
if(N!=5&&N!=0){goto metka5;}////////////////////////////////////////////////////////////////////////
for (x=0;x<=4;x++)
{
  
 for (y=0;y<=4;y++)
{
 
  int tabl2[48]={x,y,2, x,y,y, x,2,y, x,4-y,y,  x,y,2, y,x,y, 2,x,y, 4-y,x,y, x,y,2, x,y,y, x,2,y, y,4-y,x, 2,x,y, 4-y,4-y,x, x,2,y, x,y,y  };
  strip1.setPixelColor(tabl2[j]+k1*tabl2[j+1]+k1*k1*tabl2[j+2], strip1.Color(k*g,k*r,k*b));
  

}
}
strip1.show(); 
if(N!=5&&N!=0){goto metka5;}
fun (4*n);///////////////////   ФУНКЦИЯ   ///////////////////
 j=j+3;if(j>47){j=0;}
//////////////////////////////////////////////////////////////////////////////////////////////////////////      
for (i=0;i<=k1*k1*k1-1;i++)
{
 strip1.setPixelColor(i, strip1.Color(0,0,0)); 
}
 strip1.show();
d++;}metka5:d=0;
//////////////////////////////////////////////////  ПРОГРАММА ПОЛЁТ  /////////////////////////////////////////////////////// 
while (d<10){
 g=random(0,2);r=random(0,2);b=random(0,2); 
 if (g==0&&r==0&&b==0){r=1;g=1;}
 
  
 if(N!=6&&N!=0){goto metka7;}//////////////////////////////////////////////////////////
 int tablA[15]={0,1,2,3,4,4,4,4,3,2,1,0,0,0};
 int tablB[15]={0,0,1,2,3,4,4,4,4,3,2,1,0,0};
 int tablC[15]={0,0,0,1,2,3,4,4,4,4,3,2,1,0};
 int tablD[15]={0,0,0,0,1,2,3,4,4,4,4,3,2,1};
  for (i = 0; i <=14; i++)
  {
   
  strip1.setPixelColor((tablA[i])+k1*(2)+k1*k1*(2), strip1.Color(k*g,k*r,k*b)); //псевдослучайный цвет на яркости k
  
   strip1.setPixelColor((tablB[i])+k1*(2)+k1*k1*(1), strip1.Color(k*g,k*r,k*b));
   strip1.setPixelColor((tablB[i])+k1*(2)+k1*k1*(3), strip1.Color(k*g,k*r,k*b)); 
   strip1.setPixelColor((tablB[i])+k1*(1)+k1*k1*(2), strip1.Color(k*g,k*r,k*b));
   strip1.setPixelColor((tablB[i])+k1*(3)+k1*k1*(2), strip1.Color(k*g,k*r,k*b));

    strip1.setPixelColor((tablC[i])+k1*(0)+k1*k1*(2), strip1.Color(k*g,k*r,k*b));
   strip1.setPixelColor((tablC[i])+k1*(4)+k1*k1*(2), strip1.Color(k*g,k*r,k*b)); 
   strip1.setPixelColor((tablC[i])+k1*(2)+k1*k1*(0), strip1.Color(k*g,k*r,k*b));
   strip1.setPixelColor((tablC[i])+k1*(2)+k1*k1*(4), strip1.Color(k*g,k*r,k*b));
    strip1.setPixelColor((tablC[i])+k1*(1)+k1*k1*(1), strip1.Color(k*g,k*r,k*b));
   strip1.setPixelColor((tablC[i])+k1*(3)+k1*k1*(1), strip1.Color(k*g,k*r,k*b)); 
   strip1.setPixelColor((tablC[i])+k1*(1)+k1*k1*(3), strip1.Color(k*g,k*r,k*b));
   strip1.setPixelColor((tablC[i])+k1*(3)+k1*k1*(3), strip1.Color(k*g,k*r,k*b));

    strip1.setPixelColor((tablD[i])+k1*(1)+k1*k1*(0), strip1.Color(k*g,k*r,k*b));
   strip1.setPixelColor((tablD[i])+k1*(0)+k1*k1*(1), strip1.Color(k*g,k*r,k*b)); 
   strip1.setPixelColor((tablD[i])+k1*(3)+k1*k1*(0), strip1.Color(k*g,k*r,k*b));
   strip1.setPixelColor((tablD[i])+k1*(4)+k1*k1*(1), strip1.Color(k*g,k*r,k*b));
    strip1.setPixelColor((tablD[i])+k1*(0)+k1*k1*(3), strip1.Color(k*g,k*r,k*b));
   strip1.setPixelColor((tablD[i])+k1*(1)+k1*k1*(4), strip1.Color(k*g,k*r,k*b)); 
   strip1.setPixelColor((tablD[i])+k1*(3)+k1*k1*(4), strip1.Color(k*g,k*r,k*b));
   strip1.setPixelColor((tablD[i])+k1*(4)+k1*k1*(3), strip1.Color(k*g,k*r,k*b));
   
  strip1.show();
  fun (3*n);///////////////////   ФУНКЦИЯ   ///////////////////
  strip1.setPixelColor((tablA[i])+k1*(2)+k1*k1*(2), strip1.Color(0,0,0)); 
  
  strip1.setPixelColor((tablB[i])+k1*(2)+k1*k1*(1), strip1.Color(0,0,0)); 
  strip1.setPixelColor((tablB[i])+k1*(2)+k1*k1*(3), strip1.Color(0,0,0));
  strip1.setPixelColor((tablB[i])+k1*(1)+k1*k1*(2), strip1.Color(0,0,0));
  strip1.setPixelColor((tablB[i])+k1*(3)+k1*k1*(2), strip1.Color(0,0,0));

  strip1.setPixelColor((tablC[i])+k1*(0)+k1*k1*(2), strip1.Color(0,0,0));
   strip1.setPixelColor((tablC[i])+k1*(4)+k1*k1*(2), strip1.Color(0,0,0)); 
   strip1.setPixelColor((tablC[i])+k1*(2)+k1*k1*(0), strip1.Color(0,0,0));
   strip1.setPixelColor((tablC[i])+k1*(2)+k1*k1*(4), strip1.Color(0,0,0));
    strip1.setPixelColor((tablC[i])+k1*(1)+k1*k1*(1), strip1.Color(0,0,0));
   strip1.setPixelColor((tablC[i])+k1*(3)+k1*k1*(1), strip1.Color(0,0,0)); 
   strip1.setPixelColor((tablC[i])+k1*(1)+k1*k1*(3), strip1.Color(0,0,0));
   strip1.setPixelColor((tablC[i])+k1*(3)+k1*k1*(3), strip1.Color(0,0,0));

    strip1.setPixelColor((tablD[i])+k1*(1)+k1*k1*(0), strip1.Color(0,0,0));
   strip1.setPixelColor((tablD[i])+k1*(0)+k1*k1*(1), strip1.Color(0,0,0)); 
   strip1.setPixelColor((tablD[i])+k1*(3)+k1*k1*(0), strip1.Color(0,0,0));
   strip1.setPixelColor((tablD[i])+k1*(4)+k1*k1*(1), strip1.Color(0,0,0));
    strip1.setPixelColor((tablD[i])+k1*(0)+k1*k1*(3), strip1.Color(0,0,0));
   strip1.setPixelColor((tablD[i])+k1*(1)+k1*k1*(4), strip1.Color(0,0,0)); 
   strip1.setPixelColor((tablD[i])+k1*(3)+k1*k1*(4), strip1.Color(0,0,0));
   strip1.setPixelColor((tablD[i])+k1*(4)+k1*k1*(3), strip1.Color(0,0,0));
  
  strip1.show();
  }d++;} metka7:
   d=0;
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 
//////////////////////////////////////////////////  ПРОГРАММА САЛЮТ  /////////////////////////////////////////////////////// 
while (d<10){
 g=random(0,2);r=random(0,2);b=random(0,2); 
 if (g==0&&r==0&&b==0){r=1;g=1;}
 
  // Включаем и выключаем по одному в одну сторону светодиоды.
 if(N!=7&&N!=0){goto metka8;}//////////////////////////////////////////////////////////

  for (i = 0; i <=4; i++)
  {
  strip1.setPixelColor((i)+k1*(i)+k1*k1*(i), strip1.Color(k*g,k*r,k*b)); //псевдослучайный цвет на яркости k
  strip1.show();
  fun (3*n);///////////////////   ФУНКЦИЯ   ///////////////////
  strip1.setPixelColor((i)+k1*(i)+k1*k1*(i), strip1.Color(0,0,0));
  strip1.show();
  }

  g=random(0,2);r=random(0,2);b=random(0,2); 
 if (g==0&&r==0&&b==0){r=1;g=1;}
   for (i = 3; i>=0; i--)
  {
 
  
  strip1.setPixelColor((4)+k1*(4)+k1*k1*(i), strip1.Color(k*g,k*r,k*b)); //псевдослучайный цвет на яркости k
  strip1.setPixelColor((i)+k1*(4)+k1*k1*(i), strip1.Color(k*g,k*r,k*b));
  strip1.setPixelColor((i)+k1*(4)+k1*k1*(4), strip1.Color(k*g,k*r,k*b));
  strip1.setPixelColor((i)+k1*(i)+k1*k1*(4), strip1.Color(k*g,k*r,k*b));
  strip1.setPixelColor((4)+k1*(i)+k1*k1*(4), strip1.Color(k*g,k*r,k*b));
  strip1.setPixelColor((4)+k1*(i)+k1*k1*(i), strip1.Color(k*g,k*r,k*b));
  strip1.show();
  fun (2*n);///////////////////   ФУНКЦИЯ   ///////////////////
   }
    for (i = 3; i>=1; i--)
  {
 
  strip1.setPixelColor((4)+k1*(4)+k1*k1*(i), strip1.Color(0,0,0)); //псевдослучайный цвет на яркости k
  strip1.setPixelColor((i)+k1*(4)+k1*k1*(i), strip1.Color(0,0,0));
  strip1.setPixelColor((i)+k1*(4)+k1*k1*(4), strip1.Color(0,0,0));
  strip1.setPixelColor((i)+k1*(i)+k1*k1*(4), strip1.Color(0,0,0));
  strip1.setPixelColor((4)+k1*(i)+k1*k1*(4), strip1.Color(0,0,0));
  strip1.setPixelColor((4)+k1*(i)+k1*k1*(i), strip1.Color(0,0,0));
  strip1.show();
  fun (2*n);///////////////////   ФУНКЦИЯ   ///////////////////
   }
    for (i = 4; i>=0; i--)
  {
  strip1.setPixelColor((i)+k1*(4)+k1*k1*(0), strip1.Color(k*g,k*r,k*b)); //псевдослучайный цвет на яркости k
  strip1.setPixelColor((i)+k1*(0)+k1*k1*(0), strip1.Color(k*g,k*r,k*b));
  strip1.setPixelColor((i)+k1*(0)+k1*k1*(4), strip1.Color(k*g,k*r,k*b));
  strip1.show();
  fun (5*n);///////////////////   ФУНКЦИЯ   ///////////////////
  strip1.setPixelColor((i)+k1*(4)+k1*k1*(0), strip1.Color(0,0,0)); //псевдослучайный цвет на яркости k
  strip1.setPixelColor((i)+k1*(0)+k1*k1*(0), strip1.Color(0,0,0));
  strip1.setPixelColor((i)+k1*(0)+k1*k1*(4), strip1.Color(0,0,0));
  strip1.setPixelColor((i)+k1*(4)+k1*k1*(4), strip1.Color(0,0,0));
   }
  d++;} metka8:
  j1=0; d=0;
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 
//////////////////////////////////////////////////  ПРОГРАММА ВОЛНА  /////////////////////////////////////////////////////// 
while (d<7){
 
 
  // Включаем и выключаем по одному в одну сторону светодиоды.
 if(N!=8&&N!=0){goto metka9;}//////////////////////////////////////////////////////////
  
  for (j = 1; j <=4; j++)
  {
    g=random(0,2);r=random(0,2);b=random(0,2); 
    if (g==0&&r==0&&b==0){r=1;g=1;}
  for (x = 0; x <=j; x++)
  {
  for (y = 0; y <=j; y++)
  {
  for (z = 0; z <=j; z++)
  {
  strip1.setPixelColor((x)+k1*(y)+k1*k1*(z), strip1.Color(k*g,k*r,k*b)); //псевдослучайный цвет на яркости k
  }
  }
  }
  for (x = 0; x <=j-1; x++)
  {
  for (y = 0; y <=j-1; y++)
  {
  for (z = 0; z <=j-1; z++)
  {
  strip1.setPixelColor((x)+k1*(y)+k1*k1*(z), strip1.Color(0,0,0)); //псевдослучайный цвет на яркости k
  }
  }
  }
  strip1.show();
  fun (5*n);///////////////////   ФУНКЦИЯ   ///////////////////
  for (i = 0; i <=124; i++)
  {strip1.setPixelColor(i, strip1.Color(0,0,0));}
  }
  ////////////////////////////////////////////////////////////////////////////////////////////////////////
   for (j = 4; j >=1; j--)
  {
    g=random(0,2);r=random(0,2);b=random(0,2); 
    if (g==0&&r==0&&b==0){r=1;g=1;}
  for (x = j; x >=0; x--)
  {
  for (y = j; y >=0; y--)
  {
  for (z = j; z >=0; z--)
  {
  strip1.setPixelColor((x)+k1*(y)+k1*k1*(z), strip1.Color(k*g,k*r,k*b)); //псевдослучайный цвет на яркости k
  }
  }
  }
  for (x = j-1; x >=0; x--)
  {
  for (y = j-1; y >=0; y--)
  {
  for (z = j-1; z >=0; z--)
  {
  strip1.setPixelColor((x)+k1*(y)+k1*k1*(z), strip1.Color(0,0,0)); //псевдослучайный цвет на яркости k
  }
  }
  }
  strip1.show();
  fun (5*n);///////////////////   ФУНКЦИЯ   ///////////////////
  for (i = 0; i <=124; i++)
  {strip1.setPixelColor(i, strip1.Color(0,0,0));} strip1.show();
  }
  d++;} metka9:
  j=0; d=0;
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 

 

 

 
}
////////////////////////////////////////   ФУНКЦИИ ОПИСАНИЕ   ////////////////////////////////////////////////////////////////// 
void fun (int T1)
{
 v=1; Y2=millis();metka6:Y1=millis();if(Y1-Y2<=T1){ goto metka6;} 
 // вместо задержки времени через delay

}

 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

Скетч без пояснений, с кучей счётчиков и циклов, может чего не так написал? Ну вроде всё однообразно - "включил", обновил, подаждал, выключил, обновил...

Давайте рассуждать логически. У нас есть две возможные проблемы: аппаратная или программная. Может и оба варианта сразу. Нам нужно сократить область поиска.

Если проблема аппаратная, то она, скорее всего, должна сохраниться при любом простом эффекте, нагружающем страйп однотипно с тем, на которым фиксируется глюк. Т.е., теоретически, она должна проявляться и на стандартном примере из библиотеки. 

Если проблема программная, то она с большой степенью вероятности проявляться перестанет.

Понимаете ход размышлений?

Ход ясен. Сильнее пиксели пестрят при белом цвете и быстрых обновлениях по скетчу.С утреца забью скетч с быстрыми обновлениями пикселей нулевой яркостью по всем цветам. По идее ничего пестрить не должно...

Уточнил на вариациях скетча, пестрит сильнее красный кристалл. Программно никак не убирается...можно ослабить, исключив красный, фигня воощем пока. 

Со скетчами из примеров Adafruit - то же самое?

Не, ещё не пробовал. Надеюсь на косяк в аппарате.

Посмотрел скетчи в примерах...как их пришить к 125 светодиодам?, ум за разум. Добавил к схеме два потенциометра на аналоговые входы, регулирую частоту переключений  и яркость. На самой малой яркости и частоте анимация из скетча воспринимается отдельно, яркое пестрение отдельно (2-7 штук вразброс)...

В смысле - как? Adafruit_NeoPixel strip = Adafruit_NeoPixel(125, PIN,...

// This is a demonstration on how to use an input device to trigger changes on your neo pixels.
// You should wire a momentary push button to connect from ground to a digital IO pin.  When you
// press the button it will change to a new pixel animation.  Note that you need to press the
// button once to start the first animation!

#include <Adafruit_NeoPixel.h>

#define BUTTON_PIN   2    // Digital IO pin connected to the button.  This will be
                          // driven with a pull-up resistor so the switch should
                          // pull the pin to ground momentarily.  On a high -> low
                          // transition the button press logic will execute.

#define PIXEL_PIN    6    // Digital IO pin connected to the NeoPixels.

#define PIXEL_COUNT 16

// Parameter 1 = number of pixels in strip,  neopixel stick has 8
// Parameter 2 = pin number (most are valid)
// Parameter 3 = pixel type flags, add together as needed:
//   NEO_RGB     Pixels are wired for RGB bitstream
//   NEO_GRB     Pixels are wired for GRB bitstream, correct for neopixel stick
//   NEO_KHZ400  400 KHz bitstream (e.g. FLORA pixels)
//   NEO_KHZ800  800 KHz bitstream (e.g. High Density LED strip), correct for neopixel stick
Adafruit_NeoPixel strip = Adafruit_NeoPixel(PIXEL_COUNT, PIXEL_PIN, NEO_GRB + NEO_KHZ800);

bool oldState = HIGH;
int showType = 0;

void setup() {
  pinMode(BUTTON_PIN, INPUT_PULLUP);
  strip.begin();
  strip.show(); // Initialize all pixels to 'off'
}

void loop() {
  // Get current button state.
  bool newState = digitalRead(BUTTON_PIN);

  // Check if state changed from high to low (button press).
  if (newState == LOW && oldState == HIGH) {
    // Short delay to debounce button.
    delay(20);
    // Check if button is still low after debounce.
    newState = digitalRead(BUTTON_PIN);
    if (newState == LOW) {
      showType++;
      if (showType > 9)
        showType=0;
      startShow(showType);
    }
  }

  // Set the last button state to the old state.
  oldState = newState;
}

void startShow(int i) {
  switch(i){
    case 0: colorWipe(strip.Color(0, 0, 0), 50);    // Black/off
            break;
    case 1: colorWipe(strip.Color(255, 0, 0), 50);  // Red
            break;
    case 2: colorWipe(strip.Color(0, 255, 0), 50);  // Green
            break;
    case 3: colorWipe(strip.Color(0, 0, 255), 50);  // Blue
            break;
    case 4: theaterChase(strip.Color(127, 127, 127), 50); // White
            break;
    case 5: theaterChase(strip.Color(127,   0,   0), 50); // Red
            break;
    case 6: theaterChase(strip.Color(  0,   0, 127), 50); // Blue
            break;
    case 7: rainbow(20);
            break;
    case 8: rainbowCycle(20);
            break;
    case 9: theaterChaseRainbow(50);
            break;
  }
}

// Fill the dots one after the other with a color
void colorWipe(uint32_t c, uint8_t wait) {
  for(uint16_t i=0; i<strip.numPixels(); i++) {
    strip.setPixelColor(i, c);
    strip.show();
    delay(wait);
  }
}

void rainbow(uint8_t wait) {
  uint16_t i, j;

  for(j=0; j<256; j++) {
    for(i=0; i<strip.numPixels(); i++) {
      strip.setPixelColor(i, Wheel((i+j) & 255));
    }
    strip.show();
    delay(wait);
  }
}

// Slightly different, this makes the rainbow equally distributed throughout
void rainbowCycle(uint8_t wait) {
  uint16_t i, j;

  for(j=0; j<256*5; j++) { // 5 cycles of all colors on wheel
    for(i=0; i< strip.numPixels(); i++) {
      strip.setPixelColor(i, Wheel(((i * 256 / strip.numPixels()) + j) & 255));
    }
    strip.show();
    delay(wait);
  }
}

//Theatre-style crawling lights.
void theaterChase(uint32_t c, uint8_t wait) {
  for (int j=0; j<10; j++) {  //do 10 cycles of chasing
    for (int q=0; q < 3; q++) {
      for (int i=0; i < strip.numPixels(); i=i+3) {
        strip.setPixelColor(i+q, c);    //turn every third pixel on
      }
      strip.show();

      delay(wait);

      for (int i=0; i < strip.numPixels(); i=i+3) {
        strip.setPixelColor(i+q, 0);        //turn every third pixel off
      }
    }
  }
}

//Theatre-style crawling lights with rainbow effect
void theaterChaseRainbow(uint8_t wait) {
  for (int j=0; j < 256; j++) {     // cycle all 256 colors in the wheel
    for (int q=0; q < 3; q++) {
      for (int i=0; i < strip.numPixels(); i=i+3) {
        strip.setPixelColor(i+q, Wheel( (i+j) % 255));    //turn every third pixel on
      }
      strip.show();

      delay(wait);

      for (int i=0; i < strip.numPixels(); i=i+3) {
        strip.setPixelColor(i+q, 0);        //turn every third pixel off
      }
    }
  }
}

// Input a value 0 to 255 to get a color value.
// The colours are a transition r - g - b - back to r.
uint32_t Wheel(byte WheelPos) {
  WheelPos = 255 - WheelPos;
  if(WheelPos < 85) {
    return strip.Color(255 - WheelPos * 3, 0, WheelPos * 3);
  }
  if(WheelPos < 170) {
    WheelPos -= 85;
    return strip.Color(0, WheelPos * 3, 255 - WheelPos * 3);
  }
  WheelPos -= 170;
  return strip.Color(WheelPos * 3, 255 - WheelPos * 3, 0);
}

Ну вот например... Куда ставить 125 ясно, а схемы нет. Да и для чего скетч не ясно (немецкий учил). Кнопка управления вроде есть? на выводе 2. А на что замыкает? GND?

И что, если бы скетч был на немецком, то всё самостоятельно бы перевёл? Без словаря?

P.S. Для "учивших немецкий" - translate.google.com

Подключил кнопку к земле... Запустил скетч...логика в моргалках просматривается, но светодиоды явно пестрят - часть из них остаётся загадочного цвета свечения по отношению к окружающим (и по яркости тоже). 

Да, пробовал менять частоту 800 на 400 и наоборот, зелёный с красным местами тоже переставлял, на одном сайте даже читанул, что для pl9823  нуна частота 580кГц, но библиотека послала меня... и у продавца написано 800кГц, воощем пестрят стробоскопически рандомно гады...

Пришло озарение...Перечитал "даташит" продавца... Написано 800 кГц, а внизу диаграмки временные. Если у ws2812b в сумме время 0 и 1 по протоколу 1,25 мкс, то у pl9823 - 1,71мкс!!! Библиотека и не должна корректно работать с ними, частота ведь 580кГц. Что делать с "пистрюками" ???

Как и в любом другом случае выхода два:

1) Искать;

2) Писать самому.

Я поискал за вас: https://github.com/FastLED/FastLED/issues/518

Спасибо, другая библиотека, правда, но буду пробовать...

Глянул блинк для фастледа, нет там опции для pl9823, для других туча, для них нет. Мож не та версия библиотеки?

Странно. В документации есть : http://fastled.io/docs/3.1/class_p_l9823.html

Запутался,.. поищу версию библиотеки поновее, в моей не активны ни pl9823,  ни apa106 ...

#включить "FastLED.ч"

// Сколько светодиодов в вашу полосу?
#определить NUM_LEDS 1

// Для светодиодных чипов, как Neopixels, которые имеют линии передачи данных и питания, вы просто
// нужно определить DATA_PIN. Для светодиодных чипов, через SPI-интерфейс (четыре провода - данные, часы,
// землю, и власть), как LPD8806 определяют как DATA_PIN и CLOCK_PIN
#определить DATA_PIN 3
#определить CLOCK_PIN 13

// Определяем массив из светодиодов
Светодиоды CRGB[NUM_LEDS];

настройка недействительными() { 
 // Раскомментируйте/редактировать одну из следующих строк для расположения светодиодов.
 // FastLED.addLeds<TM1803, DATA_PIN, свет>(светодиоды, NUM_LEDS);
 // FastLED.addLeds<TM1804, DATA_PIN, свет>(светодиоды, NUM_LEDS);
 // FastLED.addLeds<TM1809, DATA_PIN, свет>(светодиоды, NUM_LEDS);
 // FastLED.addLeds<чипами ws2811, DATA_PIN, РГБ>(светодиоды, NUM_LEDS);
 // FastLED.addLeds<WS2812, DATA_PIN, свет>(светодиоды, NUM_LEDS);
 // FastLED.addLeds<WS2812B, DATA_PIN, свет>(светодиоды, NUM_LEDS);
 FastLED.addLeds<NEOPIXEL, DATA_PIN>(светодиоды, NUM_LEDS);
 // FastLED.addLeds<APA104, DATA_PIN, свет>(светодиоды, NUM_LEDS);
 // FastLED.addLeds<UCS1903, DATA_PIN, свет>(светодиоды, NUM_LEDS);
 // FastLED.addLeds<UCS1903B, DATA_PIN, свет>(светодиоды, NUM_LEDS);
 // FastLED.addLeds<GW6205, DATA_PIN, свет>(светодиоды, NUM_LEDS);
 // FastLED.addLeds<GW6205_400, DATA_PIN, свет>(светодиоды, NUM_LEDS);

 // FastLED.addLeds<WS2801, РГБ>(светодиоды, NUM_LEDS);
 // FastLED.addLeds<SM16716, РГБ>(светодиоды, NUM_LEDS);
 // FastLED.addLeds<LPD8806, РГБ>(светодиоды, NUM_LEDS);
 // FastLED.addLeds<P9813, РГБ>(светодиоды, NUM_LEDS);
 // FastLED.addLeds<APA102, РГБ>(светодиоды, NUM_LEDS);
 // FastLED.addLeds<DOTSTAR, РГБ>(светодиоды, NUM_LEDS);

 // FastLED.addLeds<WS2801, DATA_PIN, CLOCK_PIN, свет>(светодиоды, NUM_LEDS);
 // FastLED.addLeds<SM16716, DATA_PIN, CLOCK_PIN, свет>(светодиоды, NUM_LEDS);
 // FastLED.addLeds<LPD8806, DATA_PIN, CLOCK_PIN, свет>(светодиоды, NUM_LEDS);
 // FastLED.addLeds<P9813, DATA_PIN, CLOCK_PIN, свет>(светодиоды, NUM_LEDS);
 // FastLED.addLeds<APA102, DATA_PIN, CLOCK_PIN, свет>(светодиоды, NUM_LEDS);
 // FastLED.addLeds<DOTSTAR, DATA_PIN, CLOCK_PIN, свет>(светодиоды, NUM_LEDS);
}

недействительными петля() { 
 // Включить светодиод, затем пауза
 светодиоды[0] = CRGB::Красный;
FastLED.показать();
задержка(500);
 // Теперь поверните горит, затем пауза
 светодиоды[0] = CRGB::черный;
FastLED.показать();
задержка(500);
}

 Вот, версия библиотеки 3.1.0. Совсем не вижу pl9823. Затупил...

А у меня 3.1.6 , только что качнул (хотя зачем мне это вообще надо...).

В блинке нет нужного, но сочинить-то по аналогии недолго: FastLED.addLeds<PL9823,DATA_PIN,RGB>(leds, NUM_LEDS); - компильнул с ней, ошибок нет.

Может они и есть эти самые "неопиксели"???

Ну вот зачем вы фантазируете? Возьмите с гитхаба 3.1.6 - ссылку я дал, строку инициализации для скетчей дал, скомилировал, проверил... 

А где найти 3.1.6.? Щас попробую в поисковике... голова кругом.

Попробую по ссылке...

#include "FastLED.h"


#define NUM_LEDS 125


#define DATA_PIN 6


// Define the array of leds
CRGB leds[NUM_LEDS];

void setup()
{
FastLED.addLeds<PL9823,DATA_PIN>(leds, NUM_LEDS); 


void loop() { 
  
  for(int i=0;i<=124;i++)
  {
  leds[i] = CRGB(10,10,0);
  }
  FastLED.show();
  delay(1000);
  for(int i=0;i<=124;i++)
  {
  leds[i] = CRGB(0,0,0);
  }
  FastLED.show();
  delay(1000);
}

Попробовал такой блинк на кубе жёлтеньким...включаются почти все (ошибаются 1-3 штуки), зато "гаснут красным, зелёным, синим" где-то 5-10 штук... 

Ну, что ж могу поделать... У меня таких диодов не было и нет. Что мог - то подсказал.

Спасибо. Просто странно, как так: светодиоды есть, а библиотек для них нет. В скетче скобку потерял

#include "FastLED.h"


#define NUM_LEDS 125


#define DATA_PIN 6


// Define the array of leds
CRGB leds[NUM_LEDS];

void setup()
{
FastLED.addLeds<PL9823,DATA_PIN>(leds, NUM_LEDS); 

}
void loop()
{ 
  
  for(int i=0;i<=124;i++)
  {
  leds[i] = CRGB(10,10,0);
  }
  FastLED.show();
  delay(1000);
  for(int i=0;i<=124;i++)
  {
  leds[i] = CRGB(0,0,0);
  }
  FastLED.show();
  delay(1000);
}

Всё таки 580кГц это далеко от 400 и 800. С горя залез внутрь библиотеки "адафруктнеопиксель", даже нашёл кусок который надо исправить (как мне наивно кажется), исправил, переподключил библиотеку, всё равно, как пестрили, так и пестрят.

Не знаю, что вы там исправили, но как мне помнится - там задержки в asm-куске nop-ами задаются. И их нужно расчитывать в зависимости от частоты целевого МК.

Да, именно в эти "норки" Их там в двух местах нашёл, изменил в нижнем. Рассуждал так для 800 наносекунд в библиотеке прописано 92 норки, а для 1360 наносекунд надо 147 "норок". Ну и по аналогии для 450, 850, 400 наносекунд. Может я ошибся?

Смотрите по #define до asm-вставки, там написано при компиляции под какую платформу (частоту) данный фрагмент будет применен. От этого и будет кол-во дополнительных операций расчитываться. Впрочем, там еще сам алгоритм расписан по тактам и часть задержки происходит за счет других операций, так что увеличение может быть совсем не пропорциональное. Это уже нужно какой-нить логический анализатор брать и на выход вешаться. 

Понял, слабоваст я пока до высших материй.

Доброго времени суток)

Получилось забороть артефакты? Собрал куб по журналу Радио №5, если скетч полностью запустить, то винегрет какой-то, если кусками отдельно каждый эффект, то рисунок понятен... Запустил скетч из Вашей переписки на этом форуме - пошел сразу, но артефакты присутствуют...  Может эта тема уже не актуальна.... Надеюсь на положительный ответ, спасибо. Павел.

Все здесь напамять помнят эту схему, даже год указывать ненадо. 

Сейчас наткнулся на это сообщение случайно, в связи с другой темой.

Принципиально нет, не удалось, всё же частота этих светодиодов отлична от частоты WS2812b. И библиотек под них нет.

Но!, если снизить питание до 3,7 Вольт и использовать синий и зелёный, то артефакты исчезают.

Ну, как нет... Есть код, который нужно вкрячить в адафрутовскую библиотеку, например.

Вобщем, я вывожу на эти PL-ки самопиской.

Так, а Вы делали самописку из-за "пестрения"? Частоту меняли под них?

Не совсем из-за пестрения, просто нужно было большой линзованный светодиод для индикации статуса устройства повесить на МК. И, чтобы, потенциально не было вот таки всполохов - дернул и перелицевал кусок из неопиксельной библиотеки.

Задержки в ассемблере пересчитывал для формирования правильного таймлайна.

Но моя функция вывода только под AVR и одну частоту МК - 16мгц. В адафрутовской железа поддерживается гораздо больше, поэтому совсем красиво всунуть в неё не удастся.

Да, я сегодня опять в неё лазил,"норки" искал :-) Похоже прошлый раз я просто не в ту часть их вставил. Поэтому УНО никак не отреагировала.

Я правильно понимаю?, надо брать вот этот фрагмент из файла cpp:

 // The 400 KHz clock on 16 MHz MCU is the most 'relaxed' version.

    // 40 inst. clocks per bit: HHHHHHHHxxxxxxxxxxxxLLLLLLLLLLLLLLLLLLLL
    // ST instructions:         ^       ^           ^         (T=0,8,20)

    volatile uint8_t next, bit;

    hi   = *port |  pinMask;
    lo   = *port & ~pinMask;
    next = lo;
    bit  = 8;

    asm volatile(
     "head40:"                  "\n\t" // Clk  Pseudocode    (T =  0)
      "st   %a[port], %[hi]"    "\n\t" // 2    PORT = hi     (T =  2)
      "sbrc %[byte] , 7"        "\n\t" // 1-2  if(b & 128)
       "mov  %[next] , %[hi]"   "\n\t" // 0-1   next = hi    (T =  4)
      "rjmp .+0"                "\n\t" // 2    nop nop       (T =  6)
      "rjmp .+0"                "\n\t" // 2    nop nop       (T =  8)
      "st   %a[port], %[next]"  "\n\t" // 2    PORT = next   (T = 10)
      "rjmp .+0"                "\n\t" // 2    nop nop       (T = 12)
      "rjmp .+0"                "\n\t" // 2    nop nop       (T = 14)
      "rjmp .+0"                "\n\t" // 2    nop nop       (T = 16)
      "rjmp .+0"                "\n\t" // 2    nop nop       (T = 18)
      "rjmp .+0"                "\n\t" // 2    nop nop       (T = 20)
      "st   %a[port], %[lo]"    "\n\t" // 2    PORT = lo     (T = 22)
      "nop"                     "\n\t" // 1    nop           (T = 23)
      "mov  %[next] , %[lo]"    "\n\t" // 1    next = lo     (T = 24)
      "dec  %[bit]"             "\n\t" // 1    bit--         (T = 25)
      "breq nextbyte40"         "\n\t" // 1-2  if(bit == 0)
      "rol  %[byte]"            "\n\t" // 1    b <<= 1       (T = 27)
      "nop"                     "\n\t" // 1    nop           (T = 28)
      "rjmp .+0"                "\n\t" // 2    nop nop       (T = 30)
      "rjmp .+0"                "\n\t" // 2    nop nop       (T = 32)
      "rjmp .+0"                "\n\t" // 2    nop nop       (T = 34)
      "rjmp .+0"                "\n\t" // 2    nop nop       (T = 36)
      "rjmp .+0"                "\n\t" // 2    nop nop       (T = 38)
      "rjmp head40"             "\n\t" // 2    -> head40 (next bit out)
     "nextbyte40:"              "\n\t" //                    (T = 27)
      "ldi  %[bit]  , 8"        "\n\t" // 1    bit = 8       (T = 28)
      "ld   %[byte] , %a[ptr]+" "\n\t" // 2    b = *ptr++    (T = 30)
      "rjmp .+0"                "\n\t" // 2    nop nop       (T = 32)
      "st   %a[port], %[lo]"    "\n\t" // 2    PORT = lo     (T = 34)
      "rjmp .+0"                "\n\t" // 2    nop nop       (T = 36)
      "sbiw %[count], 1"        "\n\t" // 2    i--           (T = 38)
      "brne head40"             "\n"   // 1-2  if(i != 0) -> (next byte)
      : [port]  "+e" (port),
        [byte]  "+r" (b),
        [bit]   "+r" (bit),
        [next]  "+r" (next),
        [count] "+w" (i)
      : [ptr]    "e" (ptr),
        [hi]     "r" (hi),
        [lo]     "r" (lo));

и преобразовывать его что бы вместо строк

// 40 inst. clocks per bit: HHHHHHHHxxxxxxxxxxxxLLLLLLLLLLLLLLLLLLLL
 // ST instructions:         ^       ^           ^         (T=0,8,20)

реализовывалось

// 28 inst. clocks per bit: HHHHHHxxxxxxxxxxxxxxxxLLLLLL
 // ST instructions:         ^       ^           ^         (T=0,6,22)

Направление мысли правильное, но без лог.анализатора менять в коде задержки бессмысленно. Одними нопами не обойтись, как оказалось.

 // WS2811 and WS2812 have different hi/lo duty cycles; this is
    // similar but NOT an exact copy of the prior 400-on-8 code.

    // 20 inst. clocks per bit: HHHHHxxxxxxxxLLLLLLL
    // ST instructions:         ^   ^        ^       (T=0,5,13)
	// 28 inst. clocks per bit: HHHHHHxxxxxxxxxxxxxxxxLLLLLL
    // ST instructions:         ^       ^           ^ (T=0,6,22)
  

    volatile uint8_t next, bit;

    hi   = *port |  pinMask;
    lo   = *port & ~pinMask;
    next = lo;
    bit  = 8;

    asm volatile(
     "head28:"                   "\n\t" // Clk  Pseudocode    (T =  0)
      "st   %a[port],  %[hi]"    "\n\t" // 2    PORT = hi     (T =  2)
      "sbrc %[byte],  7"         "\n\t" // 1-2  if(b & 128)
       "mov  %[next], %[hi]"     "\n\t" // 0-1   next = hi    (T =  4)
      "dec  %[bit]"              "\n\t" // 1    bit--         (T =  5)
	             "nop"                      "\n\t" // 1    nop  ////////////////////////////////////////////
      "st   %a[port],  %[next]"  "\n\t" // 2    PORT = next   (T =  7)
	            "rjmp .+0"                 "\n\t" // 2    nop nop ///////////////////////////////////////////
                "rjmp .+0"                 "\n\t" // 2    nop nop ////////////////////////////////////////////
                "rjmp .+0"                 "\n\t" // 2    nop nop ///////////////////////////////////////////	
               	"nop"                      "\n\t" // 1    nop 		////////////////////////////////////////	
      "mov  %[next] ,  %[lo]"    "\n\t" // 1    next = lo     (T =  8)
      "breq nextbyte20"          "\n\t" // 1-2  if(bit == 0) (from dec above)
      "rol  %[byte]"             "\n\t" // 1    b <<= 1       (T = 10)
      "rjmp .+0"                 "\n\t" // 2    nop nop       (T = 12)
      "nop"                      "\n\t" // 1    nop           (T = 13)
      "st   %a[port],  %[lo]"    "\n\t" // 2    PORT = lo     (T = 15)
      "nop"                      "\n\t" // 1    nop           (T = 16)
      "rjmp .+0"                 "\n\t" // 2    nop nop       (T = 18)
      "rjmp head28"              "\n\t" // 2    -> head28 (next bit out)
     "nextbyte20:"               "\n\t" //                    (T = 10)
      "ldi  %[bit]  ,  8"        "\n\t" // 1    bit = 8       (T = 11)
      "ld   %[byte] ,  %a[ptr]+" "\n\t" // 2    b = *ptr++    (T = 13)
      "st   %a[port], %[lo]"     "\n\t" // 2    PORT = lo     (T = 15)
      "nop"                      "\n\t" // 1    nop           (T = 16)
      "sbiw %[count], 1"         "\n\t" // 2    i--           (T = 18)
       "brne head28"             "\n"   // 2    if(i != 0) -> (next byte)

Да, действительно наобум никак :-)

Добился только что 800 кГц работает без бликов на синем цвете и при питании от аккумулятора добавкой 8 "норок".

///////////////////////////КУБ 5*5*5 НА PL9823
#include <QuadrumCode.h>
#include <FastLED.h>
#define NUM_LEDS 125
#define DATASTORE_IS_PROGMEM true
#define DATA_PIN 6
CRGB leds[NUM_LEDS];

int r = 0; int g = 0; int b = 0; int k=25;  //переменные хранения параметров включений пикселей
extern const uint8_t animation_1[];
extern const uint8_t animation_2[];
extern const uint8_t animation_3[];
extern const uint8_t animation_4[];   
//////////////////////////////////////
QuadrumCode qc;
int t = 0; //счётчик кадров
long Y=0;//

void setup () {
////
FastLED.addLeds<PL9823, DATA_PIN, RGB>(leds, NUM_LEDS);
// FastLED.setBrightness(k);
////
  qc.configure(animation_3, 256, frame, DATASTORE_IS_PROGMEM );
  // allow frame control//разрешить управление кадром
  qc.start();
  ////////////////////////////////////////////////
 

  for (int i = 0; i <NUM_LEDS  ; i++) {
    leds[i] = CRGB::Black; // 
  }
  FastLED.show();
  /////////////////////////////////////////////////

}
void loop () {

int cvet=map(analogRead(A0),0,1025,0,26);// выбор цвета из 27
 b=cvet/9;g=(cvet%9)/3;r=cvet-3*g-9*b;//
///////////

  // tick must calls always to frame speed/change control//
  qc.tick();
  delay(100);// время между сменой кадров
  t++;
  if (t == 100) //
  {
//  r=random(0,2);g=random(0,2);b=random(0,2);  
  qc.configure(animation_1, 256, frame, DATASTORE_IS_PROGMEM); //здесь массив эффекта берём из флеш памяти  
  }

  if (t == 200) //
  {
 //  r=random(0,2);g=random(0,2);b=random(0,2);  
  qc.configure(animation_2, 256, frame, DATASTORE_IS_PROGMEM); //здесь массив эффекта берём из флеш памяти  
  }

  if (t == 300) //
  {
  //  r=random(0,2);g=random(0,2);b=random(0,2); 
    qc.configure(animation_3, 256, frame, DATASTORE_IS_PROGMEM); //здесь массив эффекта берём из флеш памяти

  }
  if (t == 400) //
  {
 //  r=random(0,2);g=random(0,2);b=random(0,2);  
    qc.configure(animation_4, 256, frame, DATASTORE_IS_PROGMEM); //здесь массив эффекта берём из флеш памяти
 t=0;//
  }
 
}

/////////////////////////////////
void frame(QuadrumCode* _QuadrumCodeObject) {
  uint8_t cubeSideSize = _QuadrumCodeObject->getCubeSideSize();
  for (uint8_t z = 0; z < cubeSideSize; z ++) {
    for (uint8_t y = 0; y < cubeSideSize; y ++) {
      for (uint8_t x = 0; x < cubeSideSize; x ++) {
        uint8_t pixelNumber =  x + (cubeSideSize * y) + (cubeSideSize * cubeSideSize * z);
        if  (_QuadrumCodeObject->getVoxelState (y,z,cubeSideSize - 1 - x) == true) { // возвращает true, если воксель в x, y и z включен, иначе возвращает false
           leds[pixelNumber] = CRGB(r*k, g*k, b*k); //
         
        } else {
         leds[pixelNumber] =CRGB(0, 0, 0); //
        
        }
      }
    }
  }
 FastLED.show();
}
//////////////////////////////////

#include <avr/pgmspace.h>

//// волна
const uint8_t animation_1[]PROGMEM  = {0x05,0x01,0x01,0x08,0x00,0x00,0x00,0x00,0x00,0x41,0x10,0x04,0x83,0x20,0x08,0x06,0x41,0x10,0x0C,0x82,0x20,0x18,0x04,0x41,
                                       0x10,0x00,0x00,0x00,0x00,0xA2,0x20,0x08,0x44,0x41,0x10,0x88,0x82,0x20,0x10,0x05,0x41,0x20,0x0A,0x82,0x00,0x00,0x00,0x00,
                                       0x00,0x44,0x45,0x00,0x88,0x8A,0x00,0x10,0x15,0x01,0x20,0x2A,0x02,0x40,0x54,0x04,0x00,0x00,0x00,0x00,0x00,0x88,0x8A,0x00,
                                       0x10,0x15,0x01,0x20,0x2A,0x02,0x40,0x54,0x04,0x80,0xA8,0x08,0x00,0x00,0x00,0x00,0x00,0x10,0x11,0x11,0x20,0x22,0x22,0x40,
                                       0x44,0x44,0x80,0x88,0x88,0x00,0x11,0x11,0x01,0x00,0x00,0x00,0x00,0x00,0xA2,0x22,0x00,0x44,0x45,0x00,0x88,0x8A,0x00,0x10,
                                       0x15,0x01,0x20,0x2A,0x02,0x00,0x00,0x00,0x00,0x00,0x44,0x45,0x00,0x88,0x8A,0x00,0x10,0x15,0x01,0x20,0x2A,0x02,0x40,0x54,
                                       0x04,0x00,0x00,0x00,0x00,0x20,0x08,0x8A,0x40,0x10,0x14,0x81,0x20,0x28,0x02,0x41,0x50,0x04,0x82,0xA0,0x08
                                       };
////  волна-гора                                     
const uint8_t animation_2[] PROGMEM ={0x05,0x01,0x01,0x08,0x00,0x00,0x00,0x00,0x00,0x41,0x10,0x04,0x41,0x10,0x14,0x01,0x10,0x15,0x01,0x10,0x15,0x01,0x11,0x11,0x01,
                                      0x00,0x00,0x00,0x00,0xA2,0x20,0x08,0x82,0x20,0x08,0x82,0x20,0x28,0x02,0x20,0x2A,0x02,0x20,0x2A,0x02,0x00,0x00,0x00,0x00,0x44,0x45,0x00,0x44,0x41,0x10,0x04,0x41,0x10,
                                      0x04,0x41,0x10,0x04,0x40,0x90,0x04,0x00,0x00,0x00,0x00,0x88,0x8A,0x00,0x88,0x8A,0x00,0x88,0x82,0x20,0x08,0x82,0x20,0x08,0x82,0xA0,0x08,0x00,0x00,0x00,0x00,0x10,0x11,
                                      0x11,0x10,0x15,0x01,0x10,0x15,0x01,0x10,0x05,0x41,0x10,0x04,0x41,0x10,0x00,0x00,0x00,0x00,0x00,0xA2,0x22,0x20,0x22,0x22,0x20,0x2A,0x02,0x20,0x2A,0x02,0x20,0x0A,0x82,
                                      0x00,0x00,0x00,0x00,0x00,0x00,0x44,0x45,0x00,0x44,0x45,0x40,0x44,0x44,0x40,0x54,0x04,0x40,0x54,0x04,0x00,0x00,0x00,0x00,0x00,0x20,0x08,0x8A,0x00,0x88,0x8A,0x00,0x88,
                                      0x8A,0x80,0x88,0x88,0x80,0xA8,0x08,0x00
                                      };
 ////  простыня вытряхивание                                      
const uint8_t animation_3[] PROGMEM = {0x05,0x01,0x01,0x0C,0x00,0x00,0x00,0x00,0x00,0x1F,0x00,0x00,0x3E,0x00,0x00,0x7C,0x00,0x00,0xF8,0x00,0x00,0xF0,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x1F,0x00,
                                       0x00,0x3E,0x00,0x00,0x6C,0x02,0x00,0xF8,0x00,0x00,0xF0,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x1F,0x00,0x00,0xA2,0x03,0x00,0x44,0x45,0x00,0x88,0x0E,0x00,0xF0,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0xE0,
                                       0x03,0x00,0x40,0x74,0x00,0x80,0xA8,0x08,0x00,0xD1,0x01,0x00,0x3E,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x7C,0x00,0x00,0x88,0x0E,0x00,0x10,0x15,0x01,0x20,0x3A,0x00,0xC0,0x07,0x00,0x00,0x00,0x00,0x00,
                                       0x00,0x80,0x0F,0x00,0x00,0xD1,0x01,0x00,0xA2,0x03,0x00,0x44,0x07,0x00,0xF8,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xF0,0x01,0x00,0xE0,0x03,0x00,0xC0,0x07,0x00,0x80,0x0F,0x00,0x00,0x1F,0x00,0x00,0x00,
                                       0x00,0x00,0x00,0xF0,0x01,0x00,0xE0,0x03,0x00,0xC8,0x06,0x00,0x80,0x0F,0x00,0x00,0x1F,0x00,0x00,0x00,0x00,0x00,0x00,0xF0,0x01,0x00,0x2E,0x02,0x40,0x54,0x04,0x00,0xB8,0x08,0x00,0x00,0x1F,0x00,0x00,
                                       0x00,0x00,0x00,0x80,0x0F,0x00,0x70,0x11,0x00,0xA2,0x22,0x00,0xC0,0x45,0x00,0x00,0xF8,0x00,0x00,0x00,0x00,0x00,0x00,0x7C,0x00,0x80,0x8B,0x00,0x10,0x15,0x01,0x00,0x2E,0x02,0x00,0xC0,0x07,0x00,0x00,
                                       0x00,0x00,0x00,0xE0,0x03,0x00,0x5C,0x04,0x00,0xB8,0x08,0x00,0x70,0x11,0x00,0x00,0x3E,0x00,0x00
                                       };
////  рамка вперёд-назад                                      
const uint8_t animation_4[] PROGMEM ={0x05,0x01,0x01,0x08,0x00,0x00,0x00,0x00,0x00,0x21,0x84,0x10,0x02,0x00,0x20,0x04,0x00,0x40,0x08,0x00,0x80,0x10,0x42,0x08,
                                      0x01,0x00,0x00,0x00,0x00,0x42,0x08,0x21,0x04,0x00,0x40,0x08,0x00,0x80,0x10,0x00,0x00,0x21,0x84,0x10,0x02,0x00,0x00,0x00,
                                      0x00,0x84,0x10,0x42,0x08,0x00,0x80,0x10,0x00,0x00,0x21,0x00,0x00,0x42,0x08,0x21,0x04,0x00,0x00,0x00,0x00,0x08,0x21,0x84,
                                      0x10,0x00,0x00,0x21,0x00,0x00,0x42,0x00,0x00,0x84,0x10,0x42,0x08,0x00,0x00,0x00,0x00,0x10,0x42,0x08,0x21,0x00,0x00,0x42,
                                      0x00,0x00,0x84,0x00,0x00,0x08,0x21,0x84,0x10,0x00,0x00,0x00,0x00,0x08,0x21,0x84,0x10,0x00,0x00,0x21,0x00,0x00,0x42,0x00,
                                      0x00,0x84,0x10,0x42,0x08,0x00,0x00,0x00,0x00,0x84,0x10,0x42,0x08,0x00,0x80,0x10,0x00,0x00,0x21,0x00,0x00,0x42,0x08,0x21,
                                      0x04,0x00,0x00,0x00,0x00,0x42,0x08,0x21,0x04,0x00,0x40,0x08,0x00,0x80,0x10,0x00,0x00,0x21,0x84,0x10,0x02
                                      };

Глянул библиотеку фастлед - появилась новая версия, конкретно с  pl9823. Попробовал, всё равно пестрит если есть красная составляющая. Видимо дело не в программе, а в железе.