Arduino.ru

Зачётная идея!

Для гаишников пойдет)) Меня пугает немного))))

(глядя на пустую лампу на подоконнике) а что, это идея )))

Забавно. Наверное, если ленту порубить, то пайки минимум будет вообще.

Я как-то делал подобное с "бутылкой испад срецтва" - http://arduino.ru/forum/proekty/k-voprosu-utilizatsii-tary-iz-pod-sretstva

Для бутылок есть такой вариант: 

https://aliexpress.ru/item/1005001929246313.html

Я запихивал такую гирлянду в банку - так себе эффект. Но эпилептики оценят ))

Я вот в такое пихал (не для праздника, правда), тоже ничего так:

:-)

Это на камеру выглядит как проблесковый маяк, а на глаз светорассеиватель всё рассеивает. Внутри 5 размытых областей светимости - напоминают дольки.

Оказывается погорелую лампу с отстёгнутым шаром можно починить, если найти сгоревший светодиод. Его частично соскабливаем ножом и капаем припоем (лепим соплю).

замыкая один диод, ты увеличиваешь ток через остальные.  Они и так не блещут надёжностью, поэтому через некоторое, достаточно короткое время, опять найдётся слабое звено.  У мня "восстановленные" таким образом ланпы дольше 5 дней не работали 

:-)

Тогда резисторы можно подбирать, постепенно заменяя светодиоды.

Там где то резисторы есть в токозадающей цепи источника тока. Не знаю как на лампах, а на светильниках стоят впару. Один выкусываешь и ток падает % на 30-40. Падает и яркость, но не существенно, зато режим не насильственный. Всё же лучше чем ничего.)

Не проще ли новый светодиод впаять?

Только вот является ли такой ремонт экономически целесообразным?

Оторвать шарики, остальное выкинуть - тоже вроде как жалко. Там же светодиоды... правда, их хрен куда вставишь.

Я дроссели выпаиваю. Им-то много применений. А некоторых ламп (больше у "завитушек") и высоковольтные транзисторы есть.

Ну, как "хрен". Как раз одна лампа может послужить донором для починки трё-пяти других.

У меня только паяльник, боюсь их аккуратно-целыми перепаять не удастся. 

Без оборудования специализированного , менять светодиоды в лампах , идея так себе. Там подложка алюминиевая и многие диоды припаяны не только анод/катодом, но и радиатором (который даже видно не всегда)

То только в самых паскудных так. Сейчас пошти все идут с стабилизатором тока, ток там считай не меняется. И да , резистор токозадающий надо увеличивать, если их два в паралель - один нахер. Лучше в начале работы, не дожидаясь перегорания, а то выжившие диоды подгореть успеют.

Хотя чудеса китайской схемотехники бесконечны. Недавно светильник ковырял, аккуратный, дорогой, IP67 подложка с теплоотводом, большая. Так два источника тока в параллель поставлены и работает на две параллельных цепи светодиодов. Выгорает один светодиод, его цепь светодиодов разрывается, а вторая цепь быстро дожигается удвоенным током ))) Чтоб быстрей новый покупали?

Вот такая схема и гарантирует что посыпется быстро все после выхода из строя одного светодиода.

Да на 100%. Так оно и происходит. И вся эта экономия накрывается медным тазом. А продавцы испаряются вместе со своими многолетними гарантиями.)

Настало время создания умного осветительного светодиода - с самошунтированием при перегорании :-)

На мой взгляд, нужно изменить схемотехнику. Что мешает сделать несколько цепочек светодиодов, например 4, распределив равномерно по светильнику. Тогда, если одна перегорает, яркость упадет на 25%. В лампочках так не получится.( Ну и основное, не выжимать максимум из светодиодов.

У меня 8 лет лампочкам, сгорела за все время одна , и та от статики.
Просто не нужно брать туфту задешево.

Из 18 ланп от 7 до 23 Ватт  Е27  в первый год службы сгорели все, семиваттные 6 шт выписывал с Али, месяца не продержались, остальные Gauss и близкие к ним.   На 30Вт Е27 здоровые такие, из трёх сгорела одна, две другие светют больше двух лет.  А замена зеркальных галогенок со штырьками (цоколь 5.3 памойму) за четыре года из 14 штук (5-7 Ватт) сгорела одна, и то потому что в нее торцом клюшки попали.  

Схемных вариантов самошунтирования не видел :-)

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

Да и сам он явно хлипкий - раз чиркнул ножом.

Восстановил три лампы, буду пробовать живучесть их на гараже. Свет там горит 20-30 минут, 3-4 раза в неделю.

Такой драйвер стоит на всех.

Брал хвалёные Гауссы, Наносветы... Дохнут равновероятно со всеми. Икеевская только одна заморгала. Наверное от того, что несколько лет висела вверх ногами и прогревала себе конденсаторы.

Качество лампы легко проверить взвесив ее в руке.
Нормальные лампы с алюминиевым/медным радиатором и нормальным драйвером (не из трёх деталей), весят в 2-5раз тяжелее дешёвых китайских поделий.
Гаусс скатился в говно, Филлипс и Экола пока ещё вроде в адеквате. Когда то были в продаже качественные и при этом недорогие лампы Полароид, но уже давно не видел.
В целом сейчас нормальных ламп дешевле 400р не бывает.

На фотках какие то горизонтальные полосы видны, а глазами их не видно. Странно.

https://helpx.adobe.com/ru/premiere-pro/using/rolling-shutter-repair.html

Не... то https://www.youtube.com/watch?v=UPKBB62N3OM

А тут.

JPG сжатие выполняется в блоках пикселей. В сильно сжатом JPG-изображении видны края этих блоков: в исходном изображении два пикселя могут быть очень близкими по яркости и цвету, но если они находятся в разных блоках, то после сжатия и распаковки (при просмотре) каждый из их значения могут отличаться от оригинала, поэтому вы потеряете это постепенное смешивание и начнете видеть эту «блочность».

Вот типичный пример в небе - JPG сохранен с качеством 0. 

http://photopedia.su/36011/chto-takoe-artefakty-jpeg-chto-nimi-mozhno-sdelat

Здесь как то странно, на зелёном видно отчётливо, слабее на красном и фиолетовом. За границами шара нет. Показалось, что это не связано с картинкой. Может камера телефона искажает так своеобразно?

Ну, квадратичность и сжатие по шкале шакалов мне известны. Я склонен считать, что это последствия фотографирования ШИМа

Заказал метр с шагом около 16мм между пикселями. Как придёт попробую автономный шар сделать с питанием от аккумулятора внутри. Придётся искать сферу диаметром более 60мм.

Эксперименты показали :-) , что 16 млн. цветов это миф. Я рассмотрел около 20. Поэтому основную функцию включения пикселя пришлось переделать на другие аргументы - номер пикселя в ленте, номер цвета или его название по русски, условная яркость свечения. Выбрал исходной 64 ступенчатую градацию цвета.

/////////////////////////// тест цветов ШАРИК НА WS2812b
#include "Adafruit_NeoPixel.h"
#define LED_COUNT 5
#define LED_PIN 6
Adafruit_NeoPixel strip = Adafruit_NeoPixel(LED_COUNT, LED_PIN, NEO_GRB + NEO_KHZ800);// Создаем переменную strip для управления нашей лентой.
int t=2000;//

void setup () {
strip.begin();
 for (int i = 0; i < LED_COUNT; i++) {
    strip.setPixelColor(i, 0, 0, 0); //
  }
  strip.show();
  /////////////////////////////////////////////////
 }
void loop () {
  //перебор цветов из набора на яркости 25 (МАХ 85)
  for (int i = 0; i < LED_COUNT; i++){ pixel_(i,"красный",25);}strip.show();delay(t);//
  for (int i = 0; i < LED_COUNT; i++){ pixel_(i,"жёлтый",25);}strip.show();delay(t);//
  for (int i = 0; i < LED_COUNT; i++){ pixel_(i,"оранжевый",25);}strip.show();delay(t);//
  for (int i = 0; i < LED_COUNT; i++){ pixel_(i,"зелёный_1",25);}strip.show();delay(t);//
  for (int i = 0; i < LED_COUNT; i++){ pixel_(i,"зелёный_2",25);}strip.show();delay(t);//
  for (int i = 0; i < LED_COUNT; i++){ pixel_(i,"зелёный_3",25);}strip.show();delay(t);//
  for (int i = 0; i < LED_COUNT; i++){ pixel_(i,"мятный",25);}strip.show();delay(t);//
  for (int i = 0; i < LED_COUNT; i++){ pixel_(i,"голубой",25);}strip.show();delay(t);//
  for (int i = 0; i < LED_COUNT; i++){ pixel_(i,"синий_1",25);}strip.show();delay(t);//
  for (int i = 0; i < LED_COUNT; i++){ pixel_(i,"синий_2",25);}strip.show();delay(t);//
  for (int i = 0; i < LED_COUNT; i++){ pixel_(i,"сиреневый",25);}strip.show();delay(t);//
  for (int i = 0; i < LED_COUNT; i++){ pixel_(i,"малиновый",25);}strip.show();delay(t);//
  for (int i = 0; i < LED_COUNT; i++){ pixel_(i,"бирюзовый",25);}strip.show();delay(t);//
  for (int i = 0; i < LED_COUNT; i++){ pixel_(i,"розовый",25);}strip.show();delay(t);//
  for (int i = 0; i < LED_COUNT; i++){ pixel_(i,"бежевый",25);}strip.show();delay(t);//
  for (int i = 0; i < LED_COUNT; i++){ pixel_(i,"белый_1",25);}strip.show();delay(t);// 
  for (int i = 0; i < LED_COUNT; i++){ pixel_(i,"белый_2",25);}strip.show();delay(t);// 
 }
//////////////////////////////////////////////////
// цвет пикселя по номеру
void pixel_(int num, byte cvet ,byte M){
if(num<LED_COUNT&&cvet<63&&M<86){
  int b=cvet/16;int g=(cvet%16)/4;int r=cvet-4*g-16*b;// цвета от 0 до 63
  strip.setPixelColor(num, r*M, g*M, b*M);
 }
}
//////////////////////////////////////////////////
// цвет пикселя по названию
void pixel_(int num, String CVET ,byte M){
byte cvet;
//набор цветов
if(CVET=="жёлтый"||CVET=="желтый"){cvet=11;pixel_( num,cvet,M);}
if(CVET=="зелёный_1"||CVET=="зеленый_1"){cvet=8;pixel_( num,cvet,M);} 
if(CVET=="зелёный_3"||CVET=="зеленый_3"){cvet=9;pixel_( num,cvet,M);}
if(CVET=="малиновый"){cvet=19;pixel_( num,cvet,M);} 
if(CVET=="голубой"){cvet=52;pixel_( num,cvet,M);} 
if(CVET=="розовый"){cvet=23;pixel_( num,cvet,M);} 
if(CVET=="бирюзовый"){cvet=24;pixel_( num,cvet,M);}
if(CVET=="мятный"){cvet=29;pixel_( num,cvet,M);} 
if(CVET=="синий_1"){cvet=37;pixel_( num,cvet,M);} 
if(CVET=="белый_1"){cvet=47;pixel_( num,cvet,M);} 
if(CVET=="синий_2"){cvet=48;pixel_( num,cvet,M);}
if(CVET=="сиреневый"){cvet=49;pixel_( num,cvet,M);} 
if(CVET=="красный"){cvet=3;pixel_( num,cvet,M);} 
if(CVET=="зелёный_2"||CVET=="зеленый_2"){cvet=4;pixel_( num,cvet,M);} 
if(CVET=="белый_2"){cvet=41;pixel_( num,cvet,M);}
if(CVET=="оранжевый"){cvet=7;pixel_( num,cvet,M);} 
if(CVET=="бежевый"){cvet=27;pixel_( num,cvet,M);}    
}
/////////////////////////////////////////////////

А МК какой?

16 777 216 = 2^24

Так что "количество цветов" - понятие математическое, а не человеческое. Человек дай бог 65к различит. Некоторые даже, типа меня, за 8-битный цвет не вылезают.

В пределах цветовой плоскости человек различает порядка 4000 оттенков.

Еще - порядка 200 градаций яркости.

Перемножением получаем цифру 800 000. Но при условии, что цветовое пространство - цилиндр. На практике оно ближе к конусу (по мере удаления от "оптимальной" яркости число различаемых оттенков сокращается). Т.е. получаем 250-300 тыс. оттенков.

На практике с ШИМ стоит рассчитывать на 300тыщ (18 бит) или все же стоит наполовину прирезать битность? Были ли такие эксперименты? Если на WS2812 эти оттенки не получить, то не стоит на них и выч.ресурс тратить.

Вроде какое-то цветокодирование есть... RGB565 что ли - его не зря выдумали, поди.

Ну про 16 миллионов вычитал где то давно из соображений авторов - 255 ступеней яркости (без 0) на каждый цвет, следовательно 255*255*255 комбинаций, а с 0 ещё больше :-)

На практике допускаю, что какие то экзотические цвета пропустил, а так в пределах 20 нашёл из 64 комбинаций пропорций rgb. 

Его выдумали, чтобы закодировать цвет в двух байтах. Поскольку для ретрокомпов (в т.ч. игровых приставок) на то время одного байта уже было мало, а три ещё много. 5+5+5 = 15. И чтобы 1 бит не пропадал зря, его отдали зеленому каналу, так как к нему наш глаз более чувствителен, чем к красному и синему.

Подготовил под пробы гирлянды шары. Тест на 3 эффекта для одного шарика сделал.

/////////////////////////// тест цветов и эффектов - ШАРИК НА WS2812b
#include "Adafruit_NeoPixel.h"
#define LED_COUNT 5
#define LED_PIN 6
Adafruit_NeoPixel strip = Adafruit_NeoPixel(LED_COUNT, LED_PIN, NEO_GRB + NEO_KHZ800);// Создаем переменную strip для управления нашей лентой.
void setup () {
strip.begin();
 for (int i = 0; i < LED_COUNT; i++) {
   pixel_(i,0,0);// выключение пикселя 
  }
  strip.show();
  /////////////////////////////////////////////////
 }
void loop () {
FUN_1(25);// исполнение 1 эффекта
FUN_2(40,50);// исполнение 2 эффекта
FUN_3(50,150);//исполнение 3 эффекта
}
//////////////////////////////////////////////////
// цвет пикселя по номеру (1 уровень)
void pixel_(int num, byte cvet ,byte M){
if(num<LED_COUNT&&cvet<63&&M<86){
  int b=cvet/16;int g=(cvet%16)/4;int r=cvet-4*g-16*b;// цвета от 0 до 63
  strip.setPixelColor(num, r*M, g*M, b*M);
 }
}
//////////////////////////////////////////////////
//цвет пикселя по названию (2 уровень)
void pixel_(int num, String CVET ,byte M){
byte cvet;
//набор цветов
if(CVET=="жёлтый"||CVET=="желтый"){cvet=11;pixel_( num,cvet,M);}
if(CVET=="зелёный_1"||CVET=="зеленый_1"){cvet=8;pixel_( num,cvet,M);} 
if(CVET=="зелёный_3"||CVET=="зеленый_3"){cvet=9;pixel_( num,cvet,M);}
if(CVET=="малиновый"){cvet=19;pixel_( num,cvet,M);} 
if(CVET=="голубой"){cvet=52;pixel_( num,cvet,M);} 
if(CVET=="розовый"){cvet=23;pixel_( num,cvet,M);} 
if(CVET=="бирюзовый"){cvet=24;pixel_( num,cvet,M);}
if(CVET=="мятный"){cvet=29;pixel_( num,cvet,M);} 
if(CVET=="синий_1"){cvet=37;pixel_( num,cvet,M);} 
if(CVET=="белый_1"){cvet=47;pixel_( num,cvet,M);} 
if(CVET=="синий_2"){cvet=48;pixel_( num,cvet,M);}
if(CVET=="сиреневый"){cvet=49;pixel_( num,cvet,M);} 
if(CVET=="красный"){cvet=3;pixel_( num,cvet,M);} 
if(CVET=="зелёный_2"||CVET=="зеленый_2"){cvet=4;pixel_( num,cvet,M);} 
if(CVET=="белый_2"){cvet=41;pixel_( num,cvet,M);}
if(CVET=="оранжевый"){cvet=7;pixel_( num,cvet,M);} 
if(CVET=="бежевый"){cvet=27;pixel_( num,cvet,M);} 
if(CVET=="чёрный"||CVET=="черный"){cvet=0;pixel_( num,cvet,M);}       
}
/////////////////////////////////////////////////
// бегущие 2 пикселя разных цветов по фоновому цвету (3 уровень)
void fun_1( String CVET_f ,String CVET_1,String CVET_2,byte M,int T){
 for (int i = 0; i < LED_COUNT; i++) {
  for (int j = 0; j < LED_COUNT; j++) {
     pixel_(j, CVET_f ,M);// фоновые пиксели
    }
    pixel_(i, CVET_2 ,M);// бегущий пиксель 2
    if (i != LED_COUNT - 1) {
      pixel_(i+1, CVET_1 ,M);// бегущий пиксель 1
    } else {
       pixel_(0, CVET_1 ,M);
    }
    strip.show(); delay(T);
     }  
}
//////////////////////////////////////////////////
// вариации разных комбинаций цветов 2 бегущих пикселей (4 уровень)- 1 эффект
void FUN_1(byte M){
int K=1;//
byte k=1;//
byte st_=0;// 
 while(st_<=4){
 if(st_==0){fun_1("мятный","красный","оранжевый",M,35*k);}//
 if(st_==1){fun_1("белый_1","голубой","чёрный",M,35*k);}//
 if(st_==2){fun_1("белый_2","зелёный_1","жёлтый",M,35*k);}//
 if(st_==3){fun_1("малиновый","синий_2","синий_1",M,35*k);}//
 k=k+K;if(k==8){K=-1;}if(k==0){K=1;st_++;}
 }st_=0;  
}
/////////////////////////////////////////////////
// фоновая смена цвета свечения всего шара (3 уровень)
void fun_2( String CVET_f,byte M,int T){
 for (int j = 0; j < LED_COUNT; j++) {
     pixel_(j,"чёрный",M/2);// фоновые пиксели последовательно выключаются
     strip.show(); delay(T); 
     }
    
  for (int j = 0; j < LED_COUNT; j++) {
     pixel_(j, CVET_f ,M/2);// фоновые пиксели последовательно включаются и горят
     strip.show(); delay(T);
     }
    delay(40*T);
    for (int j = 0; j < LED_COUNT; j++) {
     pixel_(j, CVET_f ,M);// фоновые пиксели вспышка краткая
     }
    strip.show(); delay(6*T); 
     for (int j = 0; j < LED_COUNT; j++) {
     pixel_(j, CVET_f ,M/2);// фоновые пиксели горят слабее некоторое время
    }
     strip.show(); delay(40*T);  
  }
//////////////////////////////////////////////////
// смена фоновых цветов(4 уровень)- 2 эффект
void FUN_2(byte M,int T){
fun_2("красный",M,T);//
fun_2("мятный",M,T);//
fun_2("бежевый",M,T);//
fun_2("бирюзовый",M,T);//
fun_2("жёлтый",M,T);//  
fun_2("оранжевый",M,T);//
fun_2("белый_1",M,T);//    
}
//////////////////////////////////////////////////
// фоновая смена цвета свечения всего шара (3 уровень)
void fun_3( String CVET_f,byte M,int T){
 for (int j = 0; j < LED_COUNT; j++) {
     pixel_(j,"чёрный",M/2);// фоновые пиксели последовательно выключаются
      }
      byte d;//
     for (int j = 0; j < LED_COUNT; j++) {
    d=random(1,10);//
    if(d==1){pixel_(j, CVET_f ,M);}// фоновые пиксели псевдослучайно включаются
    if(d==2){pixel_(j, CVET_f ,M);}
    if(d==3){pixel_(j, CVET_f ,M);}
    if(d==4){pixel_(j, CVET_f ,M/5);}
     if(d==5){pixel_(j, CVET_f ,M/5);}
    if(d==6){pixel_(j, CVET_f ,M/5);}
    if(d==7){pixel_(j,CVET_f   ,M/2);}
     if(d==8){pixel_(j,CVET_f  ,M/2);}
    if(d==9){pixel_(j, CVET_f  ,M/2);}
     }
    strip.show(); delay(T/d);   
  }
//////////////////////////////////////////////////
// смена фоновых цветов(4 уровень)- 3 эффект
void FUN_3(byte M,int T){
for (int i = 0; i < 100; i++) {fun_3("красный",M,T);}//
for (int i = 0; i < 200; i++) {fun_3("красный",M/4,T/2);}//
for (int i = 0; i < 100; i++) {fun_3("сиреневый",M,T);}//
for (int i = 0; i < 200; i++) {fun_3("сиреневый",M/4,T/2);}//
for (int i = 0; i < 100; i++) {fun_3("жёлтый",M,T);}//
for (int i = 0; i < 200; i++) {fun_3("жёлтый",M/4,T/2);}//
for (int i = 0; i < 100; i++) {fun_3("розовый",M,T);}//
for (int i = 0; i < 200; i++) {fun_3("розовый",M/4,T/2);}//
for (int i = 0; i < 100; i++) {fun_3("бирюзовый",M,T);}//
for (int i = 0; i < 200; i++) {fun_3("бирюзовый",M/4,T/2);}//
}
//////////////////////////////////////////////////

Получилось 4 уровня функций. Но такой подход оказался недостаточным для гирлянды шаров. Позволяет сделать лишь клон-гирлянду (на всех шарах один и тот же эффект в данный момент её работы).

/////////////////////////// тест цветов и эффектов для гирлянды ШАРИКОВ НА WS2812b
#include "Adafruit_NeoPixel.h"
#define LED_COUNT 5               //число пикселей в шаре
#define LED_COUNT_N 5*LED_COUNT   // число шаров в гирлянде
#define LED_PIN 6
Adafruit_NeoPixel strip = Adafruit_NeoPixel(LED_COUNT_N, LED_PIN, NEO_GRB + NEO_KHZ800);// Создаем переменную strip для управления нашей лентой.
void setup () {
strip.begin();
 for (int i = 0; i < LED_COUNT; i++) {
   pixel_(i,0,0);// выключение пикселя 
  }
  strip.show();
  /////////////////////////////////////////////////
 }
void loop () {
FUN_1(25);// исполнение 1 эффекта
FUN_2(40,50);// исполнение 2 эффекта
FUN_3(50,150);//исполнение 3 эффекта
}
//////////////////////////////////////////////////
// цвет пикселя по номеру (1 уровень)
void pixel_(int num, byte cvet ,byte M){
if(num<LED_COUNT&&cvet<63&&M<86){
  int b=cvet/16;int g=(cvet%16)/4;int r=cvet-4*g-16*b;// цвета от 0 до 63
   for (int i = 0; i < LED_COUNT_N/LED_COUNT; i++) {
  strip.setPixelColor(num+i*LED_COUNT_N/LED_COUNT, r*M, g*M, b*M);
   }
 }
}
//////////////////////////////////////////////////
//цвет пикселя по названию (2 уровень)
void pixel_(int num, String CVET ,byte M){
byte cvet;
//набор цветов
if(CVET=="жёлтый"||CVET=="желтый"){cvet=11;pixel_( num,cvet,M);}
if(CVET=="зелёный_1"||CVET=="зеленый_1"){cvet=8;pixel_( num,cvet,M);} 
if(CVET=="зелёный_3"||CVET=="зеленый_3"){cvet=9;pixel_( num,cvet,M);}
if(CVET=="малиновый"){cvet=19;pixel_( num,cvet,M);} 
if(CVET=="голубой"){cvet=52;pixel_( num,cvet,M);} 
if(CVET=="розовый"){cvet=23;pixel_( num,cvet,M);} 
if(CVET=="бирюзовый"){cvet=24;pixel_( num,cvet,M);}
if(CVET=="мятный"){cvet=29;pixel_( num,cvet,M);} 
if(CVET=="синий_1"){cvet=37;pixel_( num,cvet,M);} 
if(CVET=="белый_1"){cvet=47;pixel_( num,cvet,M);} 
if(CVET=="синий_2"){cvet=48;pixel_( num,cvet,M);}
if(CVET=="сиреневый"){cvet=49;pixel_( num,cvet,M);} 
if(CVET=="красный"){cvet=3;pixel_( num,cvet,M);} 
if(CVET=="зелёный_2"||CVET=="зеленый_2"){cvet=4;pixel_( num,cvet,M);} 
if(CVET=="белый_2"){cvet=41;pixel_( num,cvet,M);}
if(CVET=="оранжевый"){cvet=7;pixel_( num,cvet,M);} 
if(CVET=="бежевый"){cvet=27;pixel_( num,cvet,M);} 
if(CVET=="чёрный"||CVET=="черный"){cvet=0;pixel_( num,cvet,M);}       
}
/////////////////////////////////////////////////
// бегущие 2 пикселя разных цветов по фоновому цвету (3 уровень)
void fun_1( String CVET_f ,String CVET_1,String CVET_2,byte M,int T){
 for (int i = 0; i < LED_COUNT; i++) {
  for (int j = 0; j < LED_COUNT; j++) {
     pixel_(j, CVET_f ,M);// фоновые пиксели
    }
    pixel_(i, CVET_2 ,M);// бегущий пиксель 2
    if (i != LED_COUNT - 1) {
      pixel_(i+1, CVET_1 ,M);// бегущий пиксель 1
    } else {
       pixel_(0, CVET_1 ,M);
    }
    strip.show(); delay(T);
     }  
}
//////////////////////////////////////////////////
// вариации разных комбинаций цветов 2 бегущих пикселей (4 уровень)- 1 эффект
void FUN_1(byte M){
int K=1;//
byte k=1;//
byte st_=0;// 
 while(st_<=4){
 if(st_==0){fun_1("мятный","красный","оранжевый",M,35*k);}//
 if(st_==1){fun_1("белый_1","голубой","чёрный",M,35*k);}//
 if(st_==2){fun_1("белый_2","зелёный_1","жёлтый",M,35*k);}//
 if(st_==3){fun_1("малиновый","синий_2","синий_1",M,35*k);}//
 k=k+K;if(k==8){K=-1;}if(k==0){K=1;st_++;}
 }st_=0;  
}
/////////////////////////////////////////////////
// фоновая смена цвета свечения всего шара (3 уровень)
void fun_2( String CVET_f,byte M,int T){
 for (int j = 0; j < LED_COUNT; j++) {
     pixel_(j,"чёрный",M/2);// фоновые пиксели последовательно выключаются
     strip.show(); delay(T); 
     }
    
  for (int j = 0; j < LED_COUNT; j++) {
     pixel_(j, CVET_f ,M/2);// фоновые пиксели последовательно включаются и горят
     strip.show(); delay(T);
     }
    delay(40*T);
    for (int j = 0; j < LED_COUNT; j++) {
     pixel_(j, CVET_f ,M);// фоновые пиксели вспышка краткая
     }
    strip.show(); delay(6*T); 
     for (int j = 0; j < LED_COUNT; j++) {
     pixel_(j, CVET_f ,M/2);// фоновые пиксели горят слабее некоторое время
    }
     strip.show(); delay(40*T);  
  }
//////////////////////////////////////////////////
// смена фоновых цветов(4 уровень)- 2 эффект
void FUN_2(byte M,int T){
fun_2("красный",M,T);//
fun_2("мятный",M,T);//
fun_2("бежевый",M,T);//
fun_2("бирюзовый",M,T);//
fun_2("жёлтый",M,T);//  
fun_2("оранжевый",M,T);//
fun_2("белый_1",M,T);//    
}
//////////////////////////////////////////////////
// фоновая смена цвета свечения всего шара (3 уровень)
void fun_3( String CVET_f,byte M,int T){
 for (int j = 0; j < LED_COUNT; j++) {
     pixel_(j,"чёрный",M/2);// фоновые пиксели последовательно выключаются
      }
      byte d;//
     for (int j = 0; j < LED_COUNT; j++) {
    d=random(1,10);//
    if(d==1){pixel_(j, CVET_f ,M);}// фоновые пиксели псевдослучайно включаются
    if(d==2){pixel_(j, CVET_f ,M);}
    if(d==3){pixel_(j, CVET_f ,M);}
    if(d==4){pixel_(j, CVET_f ,M/5);}
     if(d==5){pixel_(j, CVET_f ,M/5);}
    if(d==6){pixel_(j, CVET_f ,M/5);}
    if(d==7){pixel_(j,CVET_f   ,M/2);}
     if(d==8){pixel_(j,CVET_f  ,M/2);}
    if(d==9){pixel_(j, CVET_f  ,M/2);}
     }
    strip.show(); delay(T/d);   
  }
//////////////////////////////////////////////////
// смена фоновых цветов(4 уровень)- 3 эффект
void FUN_3(byte M,int T){
for (int i = 0; i < 100; i++) {fun_3("красный",M,T);}//
for (int i = 0; i < 200; i++) {fun_3("красный",M/6,T/2);}//
for (int i = 0; i < 100; i++) {fun_3("сиреневый",M,T);}//
for (int i = 0; i < 200; i++) {fun_3("сиреневый",M/6,T/2);}//
for (int i = 0; i < 100; i++) {fun_3("жёлтый",M,T);}//
for (int i = 0; i < 200; i++) {fun_3("жёлтый",M/6,T/2);}//
for (int i = 0; i < 100; i++) {fun_3("розовый",M,T);}//
for (int i = 0; i < 200; i++) {fun_3("розовый",M/6,T/2);}//
for (int i = 0; i < 100; i++) {fun_3("бирюзовый",M,T);}//
for (int i = 0; i < 200; i++) {fun_3("бирюзовый",M/6,T/2);}//
}
//////////////////////////////////////////////////

Стратегию построения функций как то надо изменить, через "миллис :-)"

Не проще ли просто начинать со случайного эффекта в каждом шаре (или в первом - с первого, во втором - со второго и т.п.)?

В том то и загвоздка, что с таким построением скетча вести анимацию разных эффектов на разных шарах параллельно  не получится. Как то надо логику изменить. Функции надо перестроить на псевдопараллельную работу, не нарушив их структуры восприятия .   

Для псевдопараллельной работы нужна синхронизация, иначе все без толку.

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

Как бы провести аналогию...

Вот праздничный стол: салат, пюре,котлетки,водочка - красота для глаз. Однако желудку это полная хрень. Ему: кусочек салатика,пюре,котлетки,водочки;повтор;повтор;повтор... красота. Но для глаз это полная блевонтина.

Придумался довольно простой ход, без переделки кода для создания "роевого поведения шаров". Теперь можно набирать любую группу-комбинацию шаров для эффекта, остальные отдыхают (статично светят). Ниже пример блинка для гирлянды и вариант с 3 эффектами.

/////////////////////////// БЛИНК для гирлянды ШАРИКОВ НА WS2812b
#include "Adafruit_NeoPixel.h"
#define LED_COUNT 5               //число пикселей в шаре
#define LED_COUNT_N 5*LED_COUNT   // число шаров в гирлянде
#define LED_PIN 6
Adafruit_NeoPixel strip = Adafruit_NeoPixel(LED_COUNT_N, LED_PIN, NEO_GRB + NEO_KHZ800);// Создаем переменную strip для управления нашей лентой.
String gir="";// переменная задающая участие шара в текущем эффекте
void setup () {
strip.begin();
 for (int i = 0; i < LED_COUNT; i++) {
   pixel_(i,0,0);// выключение пикселя 
  }
  strip.show();
  /////////////////////////////////////////////////
 }
void loop () {
gir="**A**";//центральный шар
pixel_(2,"мятный" ,25);//центральный пиксель в шаре из 5 на яркости 25
strip.show();delay(1000);//пауза
pixel_(2,"чёрный" ,25);//
strip.show();delay(1000);
}
//////////////////////////////////////////////////
// цвет пикселя по номеру (1 уровень)
void pixel_(int num, byte cvet ,byte M){
if(num<LED_COUNT&&cvet<63&&M<86){
  int b=cvet/16;int g=(cvet%16)/4;int r=cvet-4*g-16*b;// цвета от 0 до 63
   for (int i = 0; i < LED_COUNT_N/LED_COUNT; i++) {
 if( gir.substring(i, i+1)=="A"){
  strip.setPixelColor(num+i*LED_COUNT_N/LED_COUNT, r*M, g*M, b*M);
   }
   }
 }
}
//////////////////////////////////////////////////
//цвет пикселя по названию (2 уровень)
void pixel_(int num, String CVET ,byte M){
byte cvet;
//набор цветов
if(CVET=="жёлтый"||CVET=="желтый"){cvet=11;pixel_( num,cvet,M);}
if(CVET=="зелёный_1"||CVET=="зеленый_1"){cvet=8;pixel_( num,cvet,M);} 
if(CVET=="зелёный_3"||CVET=="зеленый_3"){cvet=9;pixel_( num,cvet,M);}
if(CVET=="малиновый"){cvet=19;pixel_( num,cvet,M);} 
if(CVET=="голубой"){cvet=52;pixel_( num,cvet,M);} 
if(CVET=="розовый"){cvet=23;pixel_( num,cvet,M);} 
if(CVET=="бирюзовый"){cvet=24;pixel_( num,cvet,M);}
if(CVET=="мятный"){cvet=29;pixel_( num,cvet,M);} 
if(CVET=="синий_1"){cvet=37;pixel_( num,cvet,M);} 
if(CVET=="белый_1"){cvet=47;pixel_( num,cvet,M);} 
if(CVET=="синий_2"){cvet=48;pixel_( num,cvet,M);}
if(CVET=="сиреневый"){cvet=49;pixel_( num,cvet,M);} 
if(CVET=="красный"){cvet=3;pixel_( num,cvet,M);} 
if(CVET=="зелёный_2"||CVET=="зеленый_2"){cvet=4;pixel_( num,cvet,M);} 
if(CVET=="белый_2"){cvet=41;pixel_( num,cvet,M);}
if(CVET=="оранжевый"){cvet=7;pixel_( num,cvet,M);} 
if(CVET=="бежевый"){cvet=27;pixel_( num,cvet,M);} 
if(CVET=="чёрный"||CVET=="черный"){cvet=0;pixel_( num,cvet,M);}       
}
/////////////////////////////////////////////////

/////////////////////////// тест цветов и эффектов для гирлянды ШАРИКОВ НА WS2812b
#include "Adafruit_NeoPixel.h"
#define LED_COUNT 5               //число пикселей в шаре
#define LED_COUNT_N 5*LED_COUNT   // число шаров в гирлянде
#define LED_PIN 6
Adafruit_NeoPixel strip = Adafruit_NeoPixel(LED_COUNT_N, LED_PIN, NEO_GRB + NEO_KHZ800);// Создаем переменную strip для управления нашей лентой.
String gir="";// переменная задающая участие шара в текущем эффекте
void setup () {
strip.begin();
 for (int i = 0; i < LED_COUNT; i++) {
   pixel_(i,0,0);// выключение пикселя 
  }
  strip.show();
  /////////////////////////////////////////////////
 }
void loop () {
gir="AAAAA";FUN_1(25);// исполнение 1 эффекта на всех шарах
gir="**A**";FUN_2(40,50);// исполнение 2 эффекта только на центральном шаре,остальные статичны
gir="A***A";FUN_3(50,150);//исполнение 3 эффекта только на крайних шарах,остальные статичны
}
//////////////////////////////////////////////////
// цвет пикселя по номеру (1 уровень)
void pixel_(int num, byte cvet ,byte M){
if(num<LED_COUNT&&cvet<63&&M<86){
  int b=cvet/16;int g=(cvet%16)/4;int r=cvet-4*g-16*b;// цвета от 0 до 63
   for (int i = 0; i < LED_COUNT_N/LED_COUNT; i++) {
 if( gir.substring(i, i+1)=="A"){
  strip.setPixelColor(num+i*LED_COUNT_N/LED_COUNT, r*M, g*M, b*M);
   }
   }
 }
}
//////////////////////////////////////////////////
//цвет пикселя по названию (2 уровень)
void pixel_(int num, String CVET ,byte M){
byte cvet;
//набор цветов
if(CVET=="жёлтый"||CVET=="желтый"){cvet=11;pixel_( num,cvet,M);}
if(CVET=="зелёный_1"||CVET=="зеленый_1"){cvet=8;pixel_( num,cvet,M);} 
if(CVET=="зелёный_3"||CVET=="зеленый_3"){cvet=9;pixel_( num,cvet,M);}
if(CVET=="малиновый"){cvet=19;pixel_( num,cvet,M);} 
if(CVET=="голубой"){cvet=52;pixel_( num,cvet,M);} 
if(CVET=="розовый"){cvet=23;pixel_( num,cvet,M);} 
if(CVET=="бирюзовый"){cvet=24;pixel_( num,cvet,M);}
if(CVET=="мятный"){cvet=29;pixel_( num,cvet,M);} 
if(CVET=="синий_1"){cvet=37;pixel_( num,cvet,M);} 
if(CVET=="белый_1"){cvet=47;pixel_( num,cvet,M);} 
if(CVET=="синий_2"){cvet=48;pixel_( num,cvet,M);}
if(CVET=="сиреневый"){cvet=49;pixel_( num,cvet,M);} 
if(CVET=="красный"){cvet=3;pixel_( num,cvet,M);} 
if(CVET=="зелёный_2"||CVET=="зеленый_2"){cvet=4;pixel_( num,cvet,M);} 
if(CVET=="белый_2"){cvet=41;pixel_( num,cvet,M);}
if(CVET=="оранжевый"){cvet=7;pixel_( num,cvet,M);} 
if(CVET=="бежевый"){cvet=27;pixel_( num,cvet,M);} 
if(CVET=="чёрный"||CVET=="черный"){cvet=0;pixel_( num,cvet,M);}       
}
/////////////////////////////////////////////////
// бегущие 2 пикселя разных цветов по фоновому цвету (3 уровень)
void fun_1( String CVET_f ,String CVET_1,String CVET_2,byte M,int T){
 for (int i = 0; i < LED_COUNT; i++) {
  for (int j = 0; j < LED_COUNT; j++) {
     pixel_(j, CVET_f ,M);// фоновые пиксели
    }
    pixel_(i, CVET_2 ,M);// бегущий пиксель 2
    if (i != LED_COUNT - 1) {
      pixel_(i+1, CVET_1 ,M);// бегущий пиксель 1
    } else {
       pixel_(0, CVET_1 ,M);
    }
    strip.show(); delay(T);
     }  
}
//////////////////////////////////////////////////
// вариации разных комбинаций цветов 2 бегущих пикселей (4 уровень)- 1 эффект
void FUN_1(byte M){
int K=1;//
byte k=1;//
byte st_=0;// 
 while(st_<=4){
 if(st_==0){fun_1("мятный","красный","оранжевый",M,35*k);}//
 if(st_==1){fun_1("белый_1","голубой","чёрный",M,35*k);}//
 if(st_==2){fun_1("белый_2","зелёный_1","жёлтый",M,35*k);}//
 if(st_==3){fun_1("малиновый","синий_2","синий_1",M,35*k);}//
 k=k+K;if(k==8){K=-1;}if(k==0){K=1;st_++;}
 }st_=0;  
}
/////////////////////////////////////////////////
// фоновая смена цвета свечения всего шара (3 уровень)
void fun_2( String CVET_f,byte M,int T){
 for (int j = 0; j < LED_COUNT; j++) {
     pixel_(j,"чёрный",M/2);// фоновые пиксели последовательно выключаются
     strip.show(); delay(T); 
     }
    
  for (int j = 0; j < LED_COUNT; j++) {
     pixel_(j, CVET_f ,M/2);// фоновые пиксели последовательно включаются и горят
     strip.show(); delay(T);
     }
    delay(40*T);
    for (int j = 0; j < LED_COUNT; j++) {
     pixel_(j, CVET_f ,M);// фоновые пиксели вспышка краткая
     }
    strip.show(); delay(6*T); 
     for (int j = 0; j < LED_COUNT; j++) {
     pixel_(j, CVET_f ,M/2);// фоновые пиксели горят слабее некоторое время
    }
     strip.show(); delay(40*T);  
  }
//////////////////////////////////////////////////
// смена фоновых цветов(4 уровень)- 2 эффект
void FUN_2(byte M,int T){
fun_2("красный",M,T);//
fun_2("мятный",M,T);//
fun_2("бежевый",M,T);//
fun_2("бирюзовый",M,T);//
fun_2("жёлтый",M,T);//  
fun_2("оранжевый",M,T);//
fun_2("белый_1",M,T);//    
}
//////////////////////////////////////////////////
// фоновая смена цвета свечения всего шара (3 уровень)
void fun_3( String CVET_f,byte M,int T){
 for (int j = 0; j < LED_COUNT; j++) {
     pixel_(j,"чёрный",M/2);// фоновые пиксели последовательно выключаются
      }
      byte d;//
     for (int j = 0; j < LED_COUNT; j++) {
    d=random(1,10);//
    if(d==1){pixel_(j, CVET_f ,M);}// фоновые пиксели псевдослучайно включаются
    if(d==2){pixel_(j, CVET_f ,M);}
    if(d==3){pixel_(j, CVET_f ,M);}
    if(d==4){pixel_(j, CVET_f ,M/5);}
     if(d==5){pixel_(j, CVET_f ,M/5);}
    if(d==6){pixel_(j, CVET_f ,M/5);}
    if(d==7){pixel_(j,CVET_f   ,M/2);}
     if(d==8){pixel_(j,CVET_f  ,M/2);}
    if(d==9){pixel_(j, CVET_f  ,M/2);}
     }
    strip.show(); delay(T/d);   
  }
//////////////////////////////////////////////////
// смена фоновых цветов(4 уровень)- 3 эффект
void FUN_3(byte M,int T){
for (int i = 0; i < 100; i++) {fun_3("красный",M,T);}//
for (int i = 0; i < 200; i++) {fun_3("красный",M/6,T/2);}//
for (int i = 0; i < 100; i++) {fun_3("сиреневый",M,T);}//
for (int i = 0; i < 200; i++) {fun_3("сиреневый",M/6,T/2);}//
for (int i = 0; i < 100; i++) {fun_3("жёлтый",M,T);}//
for (int i = 0; i < 200; i++) {fun_3("жёлтый",M/6,T/2);}//
for (int i = 0; i < 100; i++) {fun_3("розовый",M,T);}//
for (int i = 0; i < 200; i++) {fun_3("розовый",M/6,T/2);}//
for (int i = 0; i < 100; i++) {fun_3("бирюзовый",M,T);}//
for (int i = 0; i < 200; i++) {fun_3("бирюзовый",M/6,T/2);}//
}
//////////////////////////////////////////////////

Пришла лента, с отрезками её - легче монтировать. Подправил код, была неточность.

/////////////////////////// тест цветов и эффектов для гирлянды ШАРИКОВ НА WS2812b
#include "Adafruit_NeoPixel.h"
#define LED_COUNT 5               //число пикселей в шаре
#define N 3                      // число шаров в гирлянде 
#define LED_COUNT_N  N*LED_COUNT   // число пикселей в ленте
#define LED_PIN 6
Adafruit_NeoPixel strip = Adafruit_NeoPixel(LED_COUNT_N, LED_PIN, NEO_GRB + NEO_KHZ800);// Создаем переменную strip для управления нашей лентой.
String gir="";// переменная задающая участие шара в текущем эффекте
void setup () {
strip.begin();
 for (int i = 0; i < LED_COUNT_N; i++) {
   pixel_(i,0,0);// выключение пикселя 
  }
  strip.show();
  /////////////////////////////////////////////////
 }
void loop () {
gir="AAA";FUN_1(25);// исполнение 1 эффекта на всех шарах
gir="*A*";FUN_2(40,50);// исполнение 2 эффекта только на центральном шаре,остальные статичны
gir="A*A";FUN_3(50,150);//исполнение 3 эффекта только на крайних шарах,остальные статичны
}
//////////////////////////////////////////////////
// цвет пикселя по номеру (1 уровень)
void pixel_(int num, byte cvet ,byte M){
if(num<LED_COUNT&&cvet<63&&M<86){
  int b=cvet/16;int g=(cvet%16)/4;int r=cvet-4*g-16*b;// цвета от 0 до 63
   for (int i = 0; i < N; i++) {
 if( gir.substring(i, i+1)=="A"){
  strip.setPixelColor(num+i*LED_COUNT, r*M, g*M, b*M);
   }
   }
 }
}
//////////////////////////////////////////////////
//цвет пикселя по названию (2 уровень)
void pixel_(int num, String CVET ,byte M){
byte cvet;
//набор цветов
if(CVET=="жёлтый"||CVET=="желтый"){cvet=11;pixel_( num,cvet,M);}
if(CVET=="зелёный_1"||CVET=="зеленый_1"){cvet=8;pixel_( num,cvet,M);} 
if(CVET=="зелёный_3"||CVET=="зеленый_3"){cvet=9;pixel_( num,cvet,M);}
if(CVET=="малиновый"){cvet=19;pixel_( num,cvet,M);} 
if(CVET=="голубой"){cvet=52;pixel_( num,cvet,M);} 
if(CVET=="розовый"){cvet=23;pixel_( num,cvet,M);} 
if(CVET=="бирюзовый"){cvet=24;pixel_( num,cvet,M);}
if(CVET=="мятный"){cvet=29;pixel_( num,cvet,M);} 
if(CVET=="синий_1"){cvet=37;pixel_( num,cvet,M);} 
if(CVET=="белый_1"){cvet=47;pixel_( num,cvet,M);} 
if(CVET=="синий_2"){cvet=48;pixel_( num,cvet,M);}
if(CVET=="сиреневый"){cvet=49;pixel_( num,cvet,M);} 
if(CVET=="красный"){cvet=3;pixel_( num,cvet,M);} 
if(CVET=="зелёный_2"||CVET=="зеленый_2"){cvet=4;pixel_( num,cvet,M);} 
if(CVET=="белый_2"){cvet=41;pixel_( num,cvet,M);}
if(CVET=="оранжевый"){cvet=7;pixel_( num,cvet,M);} 
if(CVET=="бежевый"){cvet=27;pixel_( num,cvet,M);} 
if(CVET=="чёрный"||CVET=="черный"){cvet=0;pixel_( num,cvet,M);}       
}
/////////////////////////////////////////////////
// бегущие 2 пикселя разных цветов по фоновому цвету (3 уровень)
void fun_1( String CVET_f ,String CVET_1,String CVET_2,byte M,int T){
 for (int i = 0; i < LED_COUNT; i++) {
  for (int j = 0; j < LED_COUNT; j++) {
     pixel_(j, CVET_f ,M);// фоновые пиксели
    }
    pixel_(i, CVET_2 ,M);// бегущий пиксель 2
    if (i != LED_COUNT - 1) {
      pixel_(i+1, CVET_1 ,M);// бегущий пиксель 1
    } else {
       pixel_(0, CVET_1 ,M);
    }
    strip.show(); delay(T);
     }  
}
//////////////////////////////////////////////////
// вариации разных комбинаций цветов 2 бегущих пикселей (4 уровень)- 1 эффект
void FUN_1(byte M){
int K=1;//
byte k=1;//
byte st_=0;// 
 while(st_<=4){
 if(st_==0){fun_1("мятный","красный","оранжевый",M,35*k);}//
 if(st_==1){fun_1("белый_1","голубой","чёрный",M,35*k);}//
 if(st_==2){fun_1("белый_2","зелёный_1","жёлтый",M,35*k);}//
 if(st_==3){fun_1("малиновый","синий_2","синий_1",M,35*k);}//
 k=k+K;if(k==8){K=-1;}if(k==0){K=1;st_++;}
 }st_=0;  
}
/////////////////////////////////////////////////
// фоновая смена цвета свечения всего шара (3 уровень)
void fun_2( String CVET_f,byte M,int T){
 for (int j = 0; j < LED_COUNT; j++) {
     pixel_(j,"чёрный",M/2);// фоновые пиксели последовательно выключаются
     strip.show(); delay(T); 
     }
    
  for (int j = 0; j < LED_COUNT; j++) {
     pixel_(j, CVET_f ,M/2);// фоновые пиксели последовательно включаются и горят
     strip.show(); delay(T);
     }
    delay(40*T);
    for (int j = 0; j < LED_COUNT; j++) {
     pixel_(j, CVET_f ,M);// фоновые пиксели вспышка краткая
     }
    strip.show(); delay(6*T); 
     for (int j = 0; j < LED_COUNT; j++) {
     pixel_(j, CVET_f ,M/2);// фоновые пиксели горят слабее некоторое время
    }
     strip.show(); delay(40*T);  
  }
//////////////////////////////////////////////////
// смена фоновых цветов(4 уровень)- 2 эффект
void FUN_2(byte M,int T){
fun_2("красный",M,T);//
fun_2("мятный",M,T);//
fun_2("бежевый",M,T);//
fun_2("бирюзовый",M,T);//
fun_2("жёлтый",M,T);//  
fun_2("оранжевый",M,T);//
fun_2("белый_1",M,T);//    
}
//////////////////////////////////////////////////
// фоновая смена цвета свечения всего шара (3 уровень)
void fun_3( String CVET_f,byte M,int T){
 for (int j = 0; j < LED_COUNT; j++) {
     pixel_(j,"чёрный",M/2);// фоновые пиксели последовательно выключаются
      }
      byte d;//
     for (int j = 0; j < LED_COUNT; j++) {
    d=random(1,10);//
    if(d==1){pixel_(j, CVET_f ,M);}// фоновые пиксели псевдослучайно включаются
    if(d==2){pixel_(j, CVET_f ,M);}
    if(d==3){pixel_(j, CVET_f ,M);}
    if(d==4){pixel_(j, CVET_f ,M/5);}
     if(d==5){pixel_(j, CVET_f ,M/5);}
    if(d==6){pixel_(j, CVET_f ,M/5);}
    if(d==7){pixel_(j,CVET_f   ,M/2);}
     if(d==8){pixel_(j,CVET_f  ,M/2);}
    if(d==9){pixel_(j, CVET_f  ,M/2);}
     }
    strip.show(); delay(T/d);   
  }
//////////////////////////////////////////////////
// смена фоновых цветов(4 уровень)- 3 эффект
void FUN_3(byte M,int T){
for (int i = 0; i < 100; i++) {fun_3("красный",M,T);}//
for (int i = 0; i < 200; i++) {fun_3("красный",M/6,T/2);}//
for (int i = 0; i < 100; i++) {fun_3("сиреневый",M,T);}//
for (int i = 0; i < 200; i++) {fun_3("сиреневый",M/6,T/2);}//
for (int i = 0; i < 100; i++) {fun_3("жёлтый",M,T);}//
for (int i = 0; i < 200; i++) {fun_3("жёлтый",M/6,T/2);}//
for (int i = 0; i < 100; i++) {fun_3("розовый",M,T);}//
for (int i = 0; i < 200; i++) {fun_3("розовый",M/6,T/2);}//
for (int i = 0; i < 100; i++) {fun_3("бирюзовый",M,T);}//
for (int i = 0; i < 200; i++) {fun_3("бирюзовый",M/6,T/2);}//
}
//////////////////////////////////////////////////

:-)

Интересное явление, явно неземного происхождения мне приходиться наблюдать.

/////////////////////////// тест цветов и эффектов для гирлянды ШАРИКОВ НА WS2812b с дистанционной заливкой скетчей на pro mini 168
#include "Adafruit_NeoPixel.h"
#define LED_COUNT 5               //число пикселей в шаре
#define N 3                      // число шаров в гирлянде 
#define LED_COUNT_N  N*LED_COUNT   // число пикселей в ленте
#define LED_PIN 6
Adafruit_NeoPixel strip = Adafruit_NeoPixel(LED_COUNT_N, LED_PIN, NEO_GRB + NEO_KHZ800);// Создаем переменную strip для управления нашей лентой.
String gir="";// переменная задающая участие шара в текущем эффекте
int t=3000;// переменная задающая паузу между эффектами

long Y=0;//пременная хранения моментов времени
int komanda=400;// переменная хранения 

void setup()
{
  Serial.begin(19200);  // скорость 19200 для Arduino pro mini , 
                         // может быть разная для разных моделей плат
 strip.begin();
 for (int i = 0; i < LED_COUNT_N; i++) {
   pixel_(i,0,0);// выключение пикселя 
  }
  strip.show();
  /////////////////////////////////////////////////
 
}

void loop()
{
//сценарий переключения шаров
gir="AAA";FUN_1("мятный","красный","оранжевый",25);//
gir="A*A";FUN_1("малиновый","синий_2","синий_1",25);//
gir="*A*";FUN_1("белый_1","голубой","чёрный",25);//
gir="A*A";FUN_1("белый_2","зелёный_1","жёлтый",25);//
delay_(t);
gir="AAA";fun_2("мятный",40,50);//
fun_2("жёлтый",40,50);//  
fun_2("оранжевый",40,50);//
fun_2("сиреневый",40,50);// 
delay_(t);
gir="A**";FUN_3("синий_2",50,150);//
gir="*A*";FUN_3("сиреневый",50,150);//
gir="**A";FUN_3("жёлтый",50,150);//
delay_(t);
gir="AAA";FUN_3("зелёный_1",50,150);//
delay_(t);
//
gir="AAA";FUN_1("белый_1","красный","синий_2",25);//
gir="A*A";FUN_1("сиреневый","синий_2","синий_2",25);//
gir="*A*";FUN_1("белый_1","белый_2","чёрный",25);//
gir="A*A";FUN_1("розовый","зелёный_1","сиреневый",25);// 
delay_(t);
gir="AAA";fun_2("сиреневый",40,50);//
fun_2("белый_1",40,50);//  
fun_2("синий_2",40,50);//
fun_2("красный",40,50);// 
delay_(t);
gir="A**";FUN_3("бежевый",50,150);//
gir="*A*";FUN_3("сиреневый",50,150);//
gir="**A";FUN_3("красный",50,150);//
delay_(t);
gir="AAA";FUN_3("голубой",50,150);//
delay_(t);
}
//////////////////////////////////////////////////
// цвет пикселя по номеру (1 уровень)
void pixel_(int num, byte cvet ,byte M){
if(num<LED_COUNT&&cvet<63&&M<86){
  int b=cvet/16;int g=(cvet%16)/4;int r=cvet-4*g-16*b;// цвета от 0 до 63
   for (int i = 0; i < N; i++) {
 if( gir.substring(i, i+1)=="A"){
  strip.setPixelColor(num+i*LED_COUNT, r*M, g*M, b*M);
   }
   }
 }
}
//////////////////////////////////////////////////
//цвет пикселя по названию (2 уровень)
void pixel_(int num, String CVET ,byte M){
byte cvet;
//набор цветов
if(CVET=="жёлтый"||CVET=="желтый"){cvet=11;pixel_( num,cvet,M);}
if(CVET=="зелёный_1"||CVET=="зеленый_1"){cvet=8;pixel_( num,cvet,M);} 
if(CVET=="зелёный_3"||CVET=="зеленый_3"){cvet=9;pixel_( num,cvet,M);}
if(CVET=="малиновый"){cvet=19;pixel_( num,cvet,M);} 
if(CVET=="голубой"){cvet=52;pixel_( num,cvet,M);} 
if(CVET=="розовый"){cvet=23;pixel_( num,cvet,M);} 
if(CVET=="бирюзовый"){cvet=24;pixel_( num,cvet,M);}
if(CVET=="мятный"){cvet=29;pixel_( num,cvet,M);} 
if(CVET=="синий_1"){cvet=37;pixel_( num,cvet,M);} 
if(CVET=="белый_1"){cvet=47;pixel_( num,cvet,M);} 
if(CVET=="синий_2"){cvet=48;pixel_( num,cvet,M);}
if(CVET=="сиреневый"){cvet=49;pixel_( num,cvet,M);} 
if(CVET=="красный"){cvet=3;pixel_( num,cvet,M);} 
if(CVET=="зелёный_2"||CVET=="зеленый_2"){cvet=4;pixel_( num,cvet,M);} 
if(CVET=="белый_2"){cvet=41;pixel_( num,cvet,M);}
if(CVET=="оранжевый"){cvet=7;pixel_( num,cvet,M);} 
if(CVET=="бежевый"){cvet=27;pixel_( num,cvet,M);} 
if(CVET=="чёрный"||CVET=="черный"){cvet=0;pixel_( num,cvet,M);}       
}
/////////////////////////////////////////////////
// бегущие 2 пикселя разных цветов по фоновому цвету (3 уровень)
void fun_1( String CVET_f ,String CVET_1,String CVET_2,byte M,int T){
 for (int i = 0; i < LED_COUNT; i++) {
  for (int j = 0; j < LED_COUNT; j++) {
     pixel_(j, CVET_f ,M);// фоновые пиксели
    }
    pixel_(i, CVET_2 ,M);// бегущий пиксель 2
    if (i != LED_COUNT - 1) {
      pixel_(i+1, CVET_1 ,M);// бегущий пиксель 1
    } else {
       pixel_(0, CVET_1 ,M);
    }
    strip.show(); delay_(T);
     }  
}
//////////////////////////////////////////////////
// вариации разных комбинаций цветов 2 бегущих пикселей (4 уровень)- 1 эффект
void FUN_1(String CVET_f ,String CVET_1,String CVET_2,byte M){
int K=1;//
byte k=1;//
byte st_=0;// 
 while(st_<=4){
 if(st_==0){fun_1(CVET_f,CVET_1,CVET_2,M,35*k);}//
 k=k+K;if(k==8){K=-1;}if(k==0){K=1;st_++;}
 }st_=0;  
}
/////////////////////////////////////////////////
// фоновая смена цвета свечения всего шара (3 уровень)
void fun_2( String CVET_f,byte M,int T){
 for (int j = 0; j < LED_COUNT; j++) {
     pixel_(j,"чёрный",M/2);// фоновые пиксели последовательно выключаются
     strip.show(); delay_(T); 
     }
    
  for (int j = 0; j < LED_COUNT; j++) {
     pixel_(j, CVET_f ,M/2);// фоновые пиксели последовательно включаются и горят
     strip.show(); delay_(T);
     }
    delay_(40*T);
    for (int j = 0; j < LED_COUNT; j++) {
     pixel_(j, CVET_f ,M);// фоновые пиксели вспышка краткая
     }
    strip.show(); delay_(6*T); 
     for (int j = 0; j < LED_COUNT; j++) {
     pixel_(j, CVET_f ,M/2);// фоновые пиксели горят слабее некоторое время
    }
     strip.show(); delay_(40*T);  
  }
//////////////////////////////////////////////////
// смена фоновых цветов(4 уровень)- 2 эффект
void FUN_2(byte M,int T){
fun_2("красный",M,T);//
fun_2("мятный",M,T);//
fun_2("бежевый",M,T);//
fun_2("бирюзовый",M,T);//
fun_2("жёлтый",M,T);//  
fun_2("оранжевый",M,T);//
fun_2("белый_1",M,T);//    
}
//////////////////////////////////////////////////
// фоновая смена цвета свечения всего шара (3 уровень)
void fun_3( String CVET_f,byte M,int T){
 for (int j = 0; j < LED_COUNT; j++) {
     pixel_(j,"чёрный",M/2);// фоновые пиксели последовательно выключаются
      }
      byte d;//
     for (int j = 0; j < LED_COUNT; j++) {
    d=random(1,10);//
    if(d==1){pixel_(j, CVET_f ,M);}// фоновые пиксели псевдослучайно включаются
    if(d==2){pixel_(j, CVET_f ,M);}
    if(d==3){pixel_(j, CVET_f ,M);}
    if(d==4){pixel_(j, CVET_f ,M/5);}
     if(d==5){pixel_(j, CVET_f ,M/5);}
    if(d==6){pixel_(j, CVET_f ,M/5);}
    if(d==7){pixel_(j,CVET_f   ,M/2);}
     if(d==8){pixel_(j,CVET_f  ,M/2);}
    if(d==9){pixel_(j, CVET_f  ,M/2);}
     }
    strip.show(); delay_(T/d);   
  }
//////////////////////////////////////////////////
// смена фоновых цветов(4 уровень)- 3 эффект
void FUN_3(String CVET_f,byte M,int T){
for (int i = 0; i < 100; i++) {fun_3( CVET_f,M,T);}//
for (int i = 0; i < 200; i++) {fun_3(CVET_f,M/8,T/2);}//
}
//////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////
// функция временной задержки с проверкой поступающих данных
void delay_(int T1)
{
Y=millis();  
while(millis()-Y<T1){komanda=CheckSerial();}//по поступившей команде выполняем действие

}
 

К про мини 168 подключён блютуз модуль и идёт заливка скетча по воздуху. После заливки таинственно исчезает исполнение строк 30,31,50. Шары на время исполнение переключений пикселей в этих строках просто замирают на предыдущих цветах, как бы берут паузу.

Первое, что подумал - кривой вариант скетча. Перезалил его на уно, потом на нано -  исполнение всех строк вернулось. Второе, что подумал - часть строк испаряется в воздухе, пока заливается. Залил скетч по шнуру прямо в платку и вернул её в схему - строки потерялись.

Третье: подумал, что виноват блютуз модуль и соединения лишние (провод с вывода на ресет) - убрал лишнее, только шары, аккумулятор и платка. Строки теряются на исполнении. 

Четвёртое: про мини не может воспроизводить конкретно эти строки кода. Собрал исходную схему и по воздуху залил такой вариант , со строкой 30. Он работает как надо.

/////////////////////////// тест цветов и эффектов для гирлянды ШАРИКОВ НА WS2812b с дистанционной заливкой скетчей на pro mini 168
#include "Adafruit_NeoPixel.h"
#define LED_COUNT 5               //число пикселей в шаре
#define N 3                      // число шаров в гирлянде 
#define LED_COUNT_N  N*LED_COUNT   // число пикселей в ленте
#define LED_PIN 6
Adafruit_NeoPixel strip = Adafruit_NeoPixel(LED_COUNT_N, LED_PIN, NEO_GRB + NEO_KHZ800);// Создаем переменную strip для управления нашей лентой.
String gir="";// переменная задающая участие шара в текущем эффекте
int t=3000;// переменная задающая паузу между эффектами

long Y=0;//пременная хранения моментов времени
int komanda=400;// переменная хранения 

void setup()
{
  Serial.begin(19200);  // скорость 19200 для Arduino pro mini , 
                         // может быть разная для разных моделей плат
 strip.begin();
 for (int i = 0; i < LED_COUNT_N; i++) {
   pixel_(i,0,0);// выключение пикселя 
  }
  strip.show();
  /////////////////////////////////////////////////
 
}

void loop()
{
//сценарий переключения шаров
gir="AAA";FUN_1("мятный","красный","оранжевый",25);//
delay_(2*t);

}
//////////////////////////////////////////////////
// цвет пикселя по номеру (1 уровень)
void pixel_(int num, byte cvet ,byte M){
if(num<LED_COUNT&&cvet<63&&M<86){
  int b=cvet/16;int g=(cvet%16)/4;int r=cvet-4*g-16*b;// цвета от 0 до 63
   for (int i = 0; i < N; i++) {
 if( gir.substring(i, i+1)=="A"){
  strip.setPixelColor(num+i*LED_COUNT, r*M, g*M, b*M);
   }
   }
 }
}
//////////////////////////////////////////////////
//цвет пикселя по названию (2 уровень)
void pixel_(int num, String CVET ,byte M){
byte cvet;
//набор цветов
if(CVET=="жёлтый"||CVET=="желтый"){cvet=11;pixel_( num,cvet,M);}
if(CVET=="зелёный_1"||CVET=="зеленый_1"){cvet=8;pixel_( num,cvet,M);} 
if(CVET=="зелёный_3"||CVET=="зеленый_3"){cvet=9;pixel_( num,cvet,M);}
if(CVET=="малиновый"){cvet=19;pixel_( num,cvet,M);} 
if(CVET=="голубой"){cvet=52;pixel_( num,cvet,M);} 
if(CVET=="розовый"){cvet=23;pixel_( num,cvet,M);} 
if(CVET=="бирюзовый"){cvet=24;pixel_( num,cvet,M);}
if(CVET=="мятный"){cvet=29;pixel_( num,cvet,M);} 
if(CVET=="синий_1"){cvet=37;pixel_( num,cvet,M);} 
if(CVET=="белый_1"){cvet=47;pixel_( num,cvet,M);} 
if(CVET=="синий_2"){cvet=48;pixel_( num,cvet,M);}
if(CVET=="сиреневый"){cvet=49;pixel_( num,cvet,M);} 
if(CVET=="красный"){cvet=3;pixel_( num,cvet,M);} 
if(CVET=="зелёный_2"||CVET=="зеленый_2"){cvet=4;pixel_( num,cvet,M);} 
if(CVET=="белый_2"){cvet=41;pixel_( num,cvet,M);}
if(CVET=="оранжевый"){cvet=7;pixel_( num,cvet,M);} 
if(CVET=="бежевый"){cvet=27;pixel_( num,cvet,M);} 
if(CVET=="чёрный"||CVET=="черный"){cvet=0;pixel_( num,cvet,M);}       
}
/////////////////////////////////////////////////
// бегущие 2 пикселя разных цветов по фоновому цвету (3 уровень)
void fun_1( String CVET_f ,String CVET_1,String CVET_2,byte M,int T){
 for (int i = 0; i < LED_COUNT; i++) {
  for (int j = 0; j < LED_COUNT; j++) {
     pixel_(j, CVET_f ,M);// фоновые пиксели
    }
    pixel_(i, CVET_2 ,M);// бегущий пиксель 2
    if (i != LED_COUNT - 1) {
      pixel_(i+1, CVET_1 ,M);// бегущий пиксель 1
    } else {
       pixel_(0, CVET_1 ,M);
    }
    strip.show(); delay_(T);
     }  
}
//////////////////////////////////////////////////
// вариации разных комбинаций цветов 2 бегущих пикселей (4 уровень)- 1 эффект
void FUN_1(String CVET_f ,String CVET_1,String CVET_2,byte M){
int K=1;//
byte k=1;//
byte st_=0;// 
 while(st_<=4){
 if(st_==0){fun_1(CVET_f,CVET_1,CVET_2,M,35*k);}//
 k=k+K;if(k==8){K=-1;}if(k==0){K=1;st_++;}
 }st_=0;  
}
/////////////////////////////////////////////////
// фоновая смена цвета свечения всего шара (3 уровень)
void fun_2( String CVET_f,byte M,int T){
 for (int j = 0; j < LED_COUNT; j++) {
     pixel_(j,"чёрный",M/2);// фоновые пиксели последовательно выключаются
     strip.show(); delay_(T); 
     }
    
  for (int j = 0; j < LED_COUNT; j++) {
     pixel_(j, CVET_f ,M/2);// фоновые пиксели последовательно включаются и горят
     strip.show(); delay_(T);
     }
    delay_(40*T);
    for (int j = 0; j < LED_COUNT; j++) {
     pixel_(j, CVET_f ,M);// фоновые пиксели вспышка краткая
     }
    strip.show(); delay_(6*T); 
     for (int j = 0; j < LED_COUNT; j++) {
     pixel_(j, CVET_f ,M/2);// фоновые пиксели горят слабее некоторое время
    }
     strip.show(); delay_(40*T);  
  }
//////////////////////////////////////////////////
// смена фоновых цветов(4 уровень)- 2 эффект
void FUN_2(byte M,int T){
fun_2("красный",M,T);//
fun_2("мятный",M,T);//
fun_2("бежевый",M,T);//
fun_2("бирюзовый",M,T);//
fun_2("жёлтый",M,T);//  
fun_2("оранжевый",M,T);//
fun_2("белый_1",M,T);//    
}
//////////////////////////////////////////////////
// фоновая смена цвета свечения всего шара (3 уровень)
void fun_3( String CVET_f,byte M,int T){
 for (int j = 0; j < LED_COUNT; j++) {
     pixel_(j,"чёрный",M/2);// фоновые пиксели последовательно выключаются
      }
      byte d;//
     for (int j = 0; j < LED_COUNT; j++) {
    d=random(1,10);//
    if(d==1){pixel_(j, CVET_f ,M);}// фоновые пиксели псевдослучайно включаются
    if(d==2){pixel_(j, CVET_f ,M);}
    if(d==3){pixel_(j, CVET_f ,M);}
    if(d==4){pixel_(j, CVET_f ,M/5);}
     if(d==5){pixel_(j, CVET_f ,M/5);}
    if(d==6){pixel_(j, CVET_f ,M/5);}
    if(d==7){pixel_(j,CVET_f   ,M/2);}
     if(d==8){pixel_(j,CVET_f  ,M/2);}
    if(d==9){pixel_(j, CVET_f  ,M/2);}
     }
    strip.show(); delay_(T/d);   
  }
//////////////////////////////////////////////////
// смена фоновых цветов(4 уровень)- 3 эффект
void FUN_3(String CVET_f,byte M,int T){
for (int i = 0; i < 100; i++) {fun_3( CVET_f,M,T);}//
for (int i = 0; i < 200; i++) {fun_3(CVET_f,M/8,T/2);}//
}
//////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////
// функция временной задержки с проверкой поступающих данных
void delay_(int T1)
{
Y=millis();  
while(millis()-Y<T1){komanda=CheckSerial();}//по поступившей команде выполняем действие

}
 

Вопрос... где секрет явления?