


01 | /////////////////////////// тест ШАРИК НА WS2812b |
03 | #include "Adafruit_NeoPixel.h" |
06 | Adafruit_NeoPixel strip = Adafruit_NeoPixel(LED_COUNT, LED_PIN, NEO_GRB + NEO_KHZ800); |
07 | int r = 30; int g = 30; int b = 30; |
12 | for ( int i = 0; i < LED_COUNT; i++) { |
13 | strip.setPixelColor(i, 0, 0, 0); |
16 | ///////////////////////////////////////////////// |
20 | for ( int i = 0; i < LED_COUNT; i++) { |
21 | strip.setPixelColor(i, r, 0, 0); |
22 | if (i != LED_COUNT - 1) { |
23 | strip.setPixelColor(i + 1, 0, g, 0); |
25 | strip.setPixelColor(0, 0, g, 0); |
27 | strip.show(); delay(125); |
28 | for ( int i = 0; i < LED_COUNT; i++) { |
29 | strip.setPixelColor(i, 0, 0, 0); |
35 | ////////////////////////////////////////////////// |
Возникла мысль использовать умные пиксели в минигирляндах, внутри самодельных шаров. Немного печатных деталек, светорассеиватель от ламп... и шар готов.
Зачётная идея!
Для гаишников пойдет)) Меня пугает немного))))
(глядя на пустую лампу на подоконнике) а что, это идея )))
Забавно. Наверное, если ленту порубить, то пайки минимум будет вообще.
Я как-то делал подобное с "бутылкой испад срецтва" - http://arduino.ru/forum/proekty/k-voprosu-utilizatsii-tary-iz-pod-sretstva
Для бутылок есть такой вариант:
https://aliexpress.ru/item/1005001929246313.html
Я запихивал такую гирлянду в банку - так себе эффект. Но эпилептики оценят ))
Я вот в такое пихал (не для праздника, правда), тоже ничего так:
Для гаишников пойдет)) Меня пугает немного))))
:-)
Это на камеру выглядит как проблесковый маяк, а на глаз светорассеиватель всё рассеивает. Внутри 5 размытых областей светимости - напоминают дольки.
Оказывается погорелую лампу с отстёгнутым шаром можно починить, если найти сгоревший светодиод. Его частично соскабливаем ножом и капаем припоем (лепим соплю).
замыкая один диод, ты увеличиваешь ток через остальные. Они и так не блещут надёжностью, поэтому через некоторое, достаточно короткое время, опять найдётся слабое звено. У мня "восстановленные" таким образом ланпы дольше 5 дней не работали
:-)
Тогда резисторы можно подбирать, постепенно заменяя светодиоды.
Там где то резисторы есть в токозадающей цепи источника тока. Не знаю как на лампах, а на светильниках стоят впару. Один выкусываешь и ток падает % на 30-40. Падает и яркость, но не существенно, зато режим не насильственный. Всё же лучше чем ничего.)
:-)
Тогда резисторы можно подбирать, постепенно заменяя светодиоды.
Не проще ли новый светодиод впаять?
Только вот является ли такой ремонт экономически целесообразным?
Оторвать шарики, остальное выкинуть - тоже вроде как жалко. Там же светодиоды... правда, их хрен куда вставишь.
Я дроссели выпаиваю. Им-то много применений. А некоторых ламп (больше у "завитушек") и высоковольтные транзисторы есть.
Там же светодиоды... правда, их хрен куда вставишь.
Ну, как "хрен". Как раз одна лампа может послужить донором для починки трё-пяти других.
У меня только паяльник, боюсь их аккуратно-целыми перепаять не удастся.
Без оборудования специализированного , менять светодиоды в лампах , идея так себе. Там подложка алюминиевая и многие диоды припаяны не только анод/катодом, но и радиатором (который даже видно не всегда)
замыкая один диод, ты увеличиваешь ток через остальные. Они и так не блещут надёжностью, поэтому через некоторое, достаточно короткое время, опять найдётся слабое звено. У мня "восстановленные" таким образом ланпы дольше 5 дней не работали
То только в самых паскудных так. Сейчас пошти все идут с стабилизатором тока, ток там считай не меняется. И да , резистор токозадающий надо увеличивать, если их два в паралель - один нахер. Лучше в начале работы, не дожидаясь перегорания, а то выжившие диоды подгореть успеют.
Хотя чудеса китайской схемотехники бесконечны. Недавно светильник ковырял, аккуратный, дорогой, IP67 подложка с теплоотводом, большая. Так два источника тока в параллель поставлены и работает на две параллельных цепи светодиодов. Выгорает один светодиод, его цепь светодиодов разрывается, а вторая цепь быстро дожигается удвоенным током ))) Чтоб быстрей новый покупали?
Хотя чудеса китайской схемотехники бесконечны. Недавно светильник ковырял, аккуратный, дорогой, IP67 подложка с теплоотводом, большая. Так два источника тока в параллель поставлены и работает на две параллельных цепи светодиодов. Выгорает один светодиод, его цепь светодиодов разрывается, а вторая цепь быстро дожигается удвоенным током ))) Чтоб быстрей новый покупали?
Сплошь и рядом так. Мало того что 2 источника тока в параллель, так ещё и на 4 параллельных светодиодных цепи, а то и 5 в параллель встречал. Как правило, работают нормально в течение определённого времени (год), затем начинают сыпаться.
Вот такая схема и гарантирует что посыпется быстро все после выхода из строя одного светодиода.
Да на 100%. Так оно и происходит. И вся эта экономия накрывается медным тазом. А продавцы испаряются вместе со своими многолетними гарантиями.)
Да на 100%. Так оно и происходит. И вся эта экономия накрывается медным тазом. А продавцы испаряются вместе со своими многолетними гарантиями.)
Настало время создания умного осветительного светодиода - с самошунтированием при перегорании :-)
На мой взгляд, нужно изменить схемотехнику. Что мешает сделать несколько цепочек светодиодов, например 4, распределив равномерно по светильнику. Тогда, если одна перегорает, яркость упадет на 25%. В лампочках так не получится.( Ну и основное, не выжимать максимум из светодиодов.
У меня 8 лет лампочкам, сгорела за все время одна , и та от статики.
Просто не нужно брать туфту задешево.
Из 18 ланп от 7 до 23 Ватт Е27 в первый год службы сгорели все, семиваттные 6 шт выписывал с Али, месяца не продержались, остальные Gauss и близкие к ним. На 30Вт Е27 здоровые такие, из трёх сгорела одна, две другие светют больше двух лет. А замена зеркальных галогенок со штырьками (цоколь 5.3 памойму) за четыре года из 14 штук (5-7 Ватт) сгорела одна, и то потому что в нее торцом клюшки попали.
Настало время создания умного осветительного светодиода - с самошунтированием при перегорании :-)
Вы будете смеяться, но такие попадаются.) Перегорают и другим светить дают - сам погибай, других выручай. Но это большая редкость.
Попадаются и такие что держат удар за двоих. До поры - до времени, конечно.
Настало время создания умного осветительного светодиода - с самошунтированием при перегорании :-)
Вы будете смеяться, но такие попадаются.) Перегорают и другим светить дают - сам погибай, других выручай. Но это большая редкость.
Попадаются и такие что держат удар за двоих. До поры - до времени, конечно.
Схемных вариантов самошунтирования не видел :-)
Оказывается горелый светодиод можно и визуально найти.
Да и сам он явно хлипкий - раз чиркнул ножом.
Восстановил три лампы, буду пробовать живучесть их на гараже. Свет там горит 20-30 минут, 3-4 раза в неделю.
Такой драйвер стоит на всех.
Брал хвалёные Гауссы, Наносветы... Дохнут равновероятно со всеми. Икеевская только одна заморгала. Наверное от того, что несколько лет висела вверх ногами и прогревала себе конденсаторы.
Оказывается горелый светодиод можно и визуально найти.
Один светодиод - это ни о чём. У меня 5 из 10-ти бывают закорочены.)
Качество лампы легко проверить взвесив ее в руке.
Нормальные лампы с алюминиевым/медным радиатором и нормальным драйвером (не из трёх деталей), весят в 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 ступенчатую градацию цвета.
01
/////////////////////////// тест цветов ШАРИК НА WS2812b
02
#include "Adafruit_NeoPixel.h"
03
#define LED_COUNT 5
04
#define LED_PIN 6
05
Adafruit_NeoPixel strip = Adafruit_NeoPixel(LED_COUNT, LED_PIN, NEO_GRB + NEO_KHZ800);
// Создаем переменную strip для управления нашей лентой.
06
int
t=2000;
//
07
08
void
setup
() {
09
strip.begin();
10
for
(
int
i = 0; i < LED_COUNT; i++) {
11
strip.setPixelColor(i, 0, 0, 0);
//
12
}
13
strip.show();
14
/////////////////////////////////////////////////
15
}
16
void
loop
() {
17
//перебор цветов из набора на яркости 25 (МАХ 85)
18
for
(
int
i = 0; i < LED_COUNT; i++){ pixel_(i,
"красный"
,25);}strip.show();delay(t);
//
19
for
(
int
i = 0; i < LED_COUNT; i++){ pixel_(i,
"жёлтый"
,25);}strip.show();delay(t);
//
20
for
(
int
i = 0; i < LED_COUNT; i++){ pixel_(i,
"оранжевый"
,25);}strip.show();delay(t);
//
21
for
(
int
i = 0; i < LED_COUNT; i++){ pixel_(i,
"зелёный_1"
,25);}strip.show();delay(t);
//
22
for
(
int
i = 0; i < LED_COUNT; i++){ pixel_(i,
"зелёный_2"
,25);}strip.show();delay(t);
//
23
for
(
int
i = 0; i < LED_COUNT; i++){ pixel_(i,
"зелёный_3"
,25);}strip.show();delay(t);
//
24
for
(
int
i = 0; i < LED_COUNT; i++){ pixel_(i,
"мятный"
,25);}strip.show();delay(t);
//
25
for
(
int
i = 0; i < LED_COUNT; i++){ pixel_(i,
"голубой"
,25);}strip.show();delay(t);
//
26
for
(
int
i = 0; i < LED_COUNT; i++){ pixel_(i,
"синий_1"
,25);}strip.show();delay(t);
//
27
for
(
int
i = 0; i < LED_COUNT; i++){ pixel_(i,
"синий_2"
,25);}strip.show();delay(t);
//
28
for
(
int
i = 0; i < LED_COUNT; i++){ pixel_(i,
"сиреневый"
,25);}strip.show();delay(t);
//
29
for
(
int
i = 0; i < LED_COUNT; i++){ pixel_(i,
"малиновый"
,25);}strip.show();delay(t);
//
30
for
(
int
i = 0; i < LED_COUNT; i++){ pixel_(i,
"бирюзовый"
,25);}strip.show();delay(t);
//
31
for
(
int
i = 0; i < LED_COUNT; i++){ pixel_(i,
"розовый"
,25);}strip.show();delay(t);
//
32
for
(
int
i = 0; i < LED_COUNT; i++){ pixel_(i,
"бежевый"
,25);}strip.show();delay(t);
//
33
for
(
int
i = 0; i < LED_COUNT; i++){ pixel_(i,
"белый_1"
,25);}strip.show();delay(t);
//
34
for
(
int
i = 0; i < LED_COUNT; i++){ pixel_(i,
"белый_2"
,25);}strip.show();delay(t);
//
35
}
36
//////////////////////////////////////////////////
37
// цвет пикселя по номеру
38
void
pixel_(
int
num,
byte
cvet ,
byte
M){
39
if
(num<LED_COUNT&&cvet<63&&M<86){
40
int
b=cvet/16;
int
g=(cvet%16)/4;
int
r=cvet-4*g-16*b;
// цвета от 0 до 63
41
strip.setPixelColor(num, r*M, g*M, b*M);
42
}
43
}
44
//////////////////////////////////////////////////
45
// цвет пикселя по названию
46
void
pixel_(
int
num, String CVET ,
byte
M){
47
byte
cvet;
48
//набор цветов
49
if
(CVET==
"жёлтый"
||CVET==
"желтый"
){cvet=11;pixel_( num,cvet,M);}
50
if
(CVET==
"зелёный_1"
||CVET==
"зеленый_1"
){cvet=8;pixel_( num,cvet,M);}
51
if
(CVET==
"зелёный_3"
||CVET==
"зеленый_3"
){cvet=9;pixel_( num,cvet,M);}
52
if
(CVET==
"малиновый"
){cvet=19;pixel_( num,cvet,M);}
53
if
(CVET==
"голубой"
){cvet=52;pixel_( num,cvet,M);}
54
if
(CVET==
"розовый"
){cvet=23;pixel_( num,cvet,M);}
55
if
(CVET==
"бирюзовый"
){cvet=24;pixel_( num,cvet,M);}
56
if
(CVET==
"мятный"
){cvet=29;pixel_( num,cvet,M);}
57
if
(CVET==
"синий_1"
){cvet=37;pixel_( num,cvet,M);}
58
if
(CVET==
"белый_1"
){cvet=47;pixel_( num,cvet,M);}
59
if
(CVET==
"синий_2"
){cvet=48;pixel_( num,cvet,M);}
60
if
(CVET==
"сиреневый"
){cvet=49;pixel_( num,cvet,M);}
61
if
(CVET==
"красный"
){cvet=3;pixel_( num,cvet,M);}
62
if
(CVET==
"зелёный_2"
||CVET==
"зеленый_2"
){cvet=4;pixel_( num,cvet,M);}
63
if
(CVET==
"белый_2"
){cvet=41;pixel_( num,cvet,M);}
64
if
(CVET==
"оранжевый"
){cvet=7;pixel_( num,cvet,M);}
65
if
(CVET==
"бежевый"
){cvet=27;pixel_( num,cvet,M);}
66
}
67
/////////////////////////////////////////////////
А МК какой?
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 эффекта для одного шарика сделал.
001
/////////////////////////// тест цветов и эффектов - ШАРИК НА WS2812b
002
#include "Adafruit_NeoPixel.h"
003
#define LED_COUNT 5
004
#define LED_PIN 6
005
Adafruit_NeoPixel strip = Adafruit_NeoPixel(LED_COUNT, LED_PIN, NEO_GRB + NEO_KHZ800);
// Создаем переменную strip для управления нашей лентой.
006
void
setup
() {
007
strip.begin();
008
for
(
int
i = 0; i < LED_COUNT; i++) {
009
pixel_(i,0,0);
// выключение пикселя
010
}
011
strip.show();
012
/////////////////////////////////////////////////
013
}
014
void
loop
() {
015
FUN_1(25);
// исполнение 1 эффекта
016
FUN_2(40,50);
// исполнение 2 эффекта
017
FUN_3(50,150);
//исполнение 3 эффекта
018
}
019
//////////////////////////////////////////////////
020
// цвет пикселя по номеру (1 уровень)
021
void
pixel_(
int
num,
byte
cvet ,
byte
M){
022
if
(num<LED_COUNT&&cvet<63&&M<86){
023
int
b=cvet/16;
int
g=(cvet%16)/4;
int
r=cvet-4*g-16*b;
// цвета от 0 до 63
024
strip.setPixelColor(num, r*M, g*M, b*M);
025
}
026
}
027
//////////////////////////////////////////////////
028
//цвет пикселя по названию (2 уровень)
029
void
pixel_(
int
num, String CVET ,
byte
M){
030
byte
cvet;
031
//набор цветов
032
if
(CVET==
"жёлтый"
||CVET==
"желтый"
){cvet=11;pixel_( num,cvet,M);}
033
if
(CVET==
"зелёный_1"
||CVET==
"зеленый_1"
){cvet=8;pixel_( num,cvet,M);}
034
if
(CVET==
"зелёный_3"
||CVET==
"зеленый_3"
){cvet=9;pixel_( num,cvet,M);}
035
if
(CVET==
"малиновый"
){cvet=19;pixel_( num,cvet,M);}
036
if
(CVET==
"голубой"
){cvet=52;pixel_( num,cvet,M);}
037
if
(CVET==
"розовый"
){cvet=23;pixel_( num,cvet,M);}
038
if
(CVET==
"бирюзовый"
){cvet=24;pixel_( num,cvet,M);}
039
if
(CVET==
"мятный"
){cvet=29;pixel_( num,cvet,M);}
040
if
(CVET==
"синий_1"
){cvet=37;pixel_( num,cvet,M);}
041
if
(CVET==
"белый_1"
){cvet=47;pixel_( num,cvet,M);}
042
if
(CVET==
"синий_2"
){cvet=48;pixel_( num,cvet,M);}
043
if
(CVET==
"сиреневый"
){cvet=49;pixel_( num,cvet,M);}
044
if
(CVET==
"красный"
){cvet=3;pixel_( num,cvet,M);}
045
if
(CVET==
"зелёный_2"
||CVET==
"зеленый_2"
){cvet=4;pixel_( num,cvet,M);}
046
if
(CVET==
"белый_2"
){cvet=41;pixel_( num,cvet,M);}
047
if
(CVET==
"оранжевый"
){cvet=7;pixel_( num,cvet,M);}
048
if
(CVET==
"бежевый"
){cvet=27;pixel_( num,cvet,M);}
049
if
(CVET==
"чёрный"
||CVET==
"черный"
){cvet=0;pixel_( num,cvet,M);}
050
}
051
/////////////////////////////////////////////////
052
// бегущие 2 пикселя разных цветов по фоновому цвету (3 уровень)
053
void
fun_1( String CVET_f ,String CVET_1,String CVET_2,
byte
M,
int
T){
054
for
(
int
i = 0; i < LED_COUNT; i++) {
055
for
(
int
j = 0; j < LED_COUNT; j++) {
056
pixel_(j, CVET_f ,M);
// фоновые пиксели
057
}
058
pixel_(i, CVET_2 ,M);
// бегущий пиксель 2
059
if
(i != LED_COUNT - 1) {
060
pixel_(i+1, CVET_1 ,M);
// бегущий пиксель 1
061
}
else
{
062
pixel_(0, CVET_1 ,M);
063
}
064
strip.show(); delay(T);
065
}
066
}
067
//////////////////////////////////////////////////
068
// вариации разных комбинаций цветов 2 бегущих пикселей (4 уровень)- 1 эффект
069
void
FUN_1(
byte
M){
070
int
K=1;
//
071
byte
k=1;
//
072
byte
st_=0;
//
073
while
(st_<=4){
074
if
(st_==0){fun_1(
"мятный"
,
"красный"
,
"оранжевый"
,M,35*k);}
//
075
if
(st_==1){fun_1(
"белый_1"
,
"голубой"
,
"чёрный"
,M,35*k);}
//
076
if
(st_==2){fun_1(
"белый_2"
,
"зелёный_1"
,
"жёлтый"
,M,35*k);}
//
077
if
(st_==3){fun_1(
"малиновый"
,
"синий_2"
,
"синий_1"
,M,35*k);}
//
078
k=k+K;
if
(k==8){K=-1;}
if
(k==0){K=1;st_++;}
079
}st_=0;
080
}
081
/////////////////////////////////////////////////
082
// фоновая смена цвета свечения всего шара (3 уровень)
083
void
fun_2( String CVET_f,
byte
M,
int
T){
084
for
(
int
j = 0; j < LED_COUNT; j++) {
085
pixel_(j,
"чёрный"
,M/2);
// фоновые пиксели последовательно выключаются
086
strip.show(); delay(T);
087
}
088
089
for
(
int
j = 0; j < LED_COUNT; j++) {
090
pixel_(j, CVET_f ,M/2);
// фоновые пиксели последовательно включаются и горят
091
strip.show(); delay(T);
092
}
093
delay(40*T);
094
for
(
int
j = 0; j < LED_COUNT; j++) {
095
pixel_(j, CVET_f ,M);
// фоновые пиксели вспышка краткая
096
}
097
strip.show(); delay(6*T);
098
for
(
int
j = 0; j < LED_COUNT; j++) {
099
pixel_(j, CVET_f ,M/2);
// фоновые пиксели горят слабее некоторое время
100
}
101
strip.show(); delay(40*T);
102
}
103
//////////////////////////////////////////////////
104
// смена фоновых цветов(4 уровень)- 2 эффект
105
void
FUN_2(
byte
M,
int
T){
106
fun_2(
"красный"
,M,T);
//
107
fun_2(
"мятный"
,M,T);
//
108
fun_2(
"бежевый"
,M,T);
//
109
fun_2(
"бирюзовый"
,M,T);
//
110
fun_2(
"жёлтый"
,M,T);
//
111
fun_2(
"оранжевый"
,M,T);
//
112
fun_2(
"белый_1"
,M,T);
//
113
}
114
//////////////////////////////////////////////////
115
// фоновая смена цвета свечения всего шара (3 уровень)
116
void
fun_3( String CVET_f,
byte
M,
int
T){
117
for
(
int
j = 0; j < LED_COUNT; j++) {
118
pixel_(j,
"чёрный"
,M/2);
// фоновые пиксели последовательно выключаются
119
}
120
byte
d;
//
121
for
(
int
j = 0; j < LED_COUNT; j++) {
122
d=random(1,10);
//
123
if
(d==1){pixel_(j, CVET_f ,M);}
// фоновые пиксели псевдослучайно включаются
124
if
(d==2){pixel_(j, CVET_f ,M);}
125
if
(d==3){pixel_(j, CVET_f ,M);}
126
if
(d==4){pixel_(j, CVET_f ,M/5);}
127
if
(d==5){pixel_(j, CVET_f ,M/5);}
128
if
(d==6){pixel_(j, CVET_f ,M/5);}
129
if
(d==7){pixel_(j,CVET_f ,M/2);}
130
if
(d==8){pixel_(j,CVET_f ,M/2);}
131
if
(d==9){pixel_(j, CVET_f ,M/2);}
132
}
133
strip.show(); delay(T/d);
134
}
135
//////////////////////////////////////////////////
136
// смена фоновых цветов(4 уровень)- 3 эффект
137
void
FUN_3(
byte
M,
int
T){
138
for
(
int
i = 0; i < 100; i++) {fun_3(
"красный"
,M,T);}
//
139
for
(
int
i = 0; i < 200; i++) {fun_3(
"красный"
,M/4,T/2);}
//
140
for
(
int
i = 0; i < 100; i++) {fun_3(
"сиреневый"
,M,T);}
//
141
for
(
int
i = 0; i < 200; i++) {fun_3(
"сиреневый"
,M/4,T/2);}
//
142
for
(
int
i = 0; i < 100; i++) {fun_3(
"жёлтый"
,M,T);}
//
143
for
(
int
i = 0; i < 200; i++) {fun_3(
"жёлтый"
,M/4,T/2);}
//
144
for
(
int
i = 0; i < 100; i++) {fun_3(
"розовый"
,M,T);}
//
145
for
(
int
i = 0; i < 200; i++) {fun_3(
"розовый"
,M/4,T/2);}
//
146
for
(
int
i = 0; i < 100; i++) {fun_3(
"бирюзовый"
,M,T);}
//
147
for
(
int
i = 0; i < 200; i++) {fun_3(
"бирюзовый"
,M/4,T/2);}
//
148
}
149
//////////////////////////////////////////////////
Получилось 4 уровня функций. Но такой подход оказался недостаточным для гирлянды шаров. Позволяет сделать лишь клон-гирлянду (на всех шарах один и тот же эффект в данный момент её работы).
001
/////////////////////////// тест цветов и эффектов для гирлянды ШАРИКОВ НА WS2812b
002
#include "Adafruit_NeoPixel.h"
003
#define LED_COUNT 5 //число пикселей в шаре
004
#define LED_COUNT_N 5*LED_COUNT // число шаров в гирлянде
005
#define LED_PIN 6
006
Adafruit_NeoPixel strip = Adafruit_NeoPixel(LED_COUNT_N, LED_PIN, NEO_GRB + NEO_KHZ800);
// Создаем переменную strip для управления нашей лентой.
007
void
setup
() {
008
strip.begin();
009
for
(
int
i = 0; i < LED_COUNT; i++) {
010
pixel_(i,0,0);
// выключение пикселя
011
}
012
strip.show();
013
/////////////////////////////////////////////////
014
}
015
void
loop
() {
016
FUN_1(25);
// исполнение 1 эффекта
017
FUN_2(40,50);
// исполнение 2 эффекта
018
FUN_3(50,150);
//исполнение 3 эффекта
019
}
020
//////////////////////////////////////////////////
021
// цвет пикселя по номеру (1 уровень)
022
void
pixel_(
int
num,
byte
cvet ,
byte
M){
023
if
(num<LED_COUNT&&cvet<63&&M<86){
024
int
b=cvet/16;
int
g=(cvet%16)/4;
int
r=cvet-4*g-16*b;
// цвета от 0 до 63
025
for
(
int
i = 0; i < LED_COUNT_N/LED_COUNT; i++) {
026
strip.setPixelColor(num+i*LED_COUNT_N/LED_COUNT, r*M, g*M, b*M);
027
}
028
}
029
}
030
//////////////////////////////////////////////////
031
//цвет пикселя по названию (2 уровень)
032
void
pixel_(
int
num, String CVET ,
byte
M){
033
byte
cvet;
034
//набор цветов
035
if
(CVET==
"жёлтый"
||CVET==
"желтый"
){cvet=11;pixel_( num,cvet,M);}
036
if
(CVET==
"зелёный_1"
||CVET==
"зеленый_1"
){cvet=8;pixel_( num,cvet,M);}
037
if
(CVET==
"зелёный_3"
||CVET==
"зеленый_3"
){cvet=9;pixel_( num,cvet,M);}
038
if
(CVET==
"малиновый"
){cvet=19;pixel_( num,cvet,M);}
039
if
(CVET==
"голубой"
){cvet=52;pixel_( num,cvet,M);}
040
if
(CVET==
"розовый"
){cvet=23;pixel_( num,cvet,M);}
041
if
(CVET==
"бирюзовый"
){cvet=24;pixel_( num,cvet,M);}
042
if
(CVET==
"мятный"
){cvet=29;pixel_( num,cvet,M);}
043
if
(CVET==
"синий_1"
){cvet=37;pixel_( num,cvet,M);}
044
if
(CVET==
"белый_1"
){cvet=47;pixel_( num,cvet,M);}
045
if
(CVET==
"синий_2"
){cvet=48;pixel_( num,cvet,M);}
046
if
(CVET==
"сиреневый"
){cvet=49;pixel_( num,cvet,M);}
047
if
(CVET==
"красный"
){cvet=3;pixel_( num,cvet,M);}
048
if
(CVET==
"зелёный_2"
||CVET==
"зеленый_2"
){cvet=4;pixel_( num,cvet,M);}
049
if
(CVET==
"белый_2"
){cvet=41;pixel_( num,cvet,M);}
050
if
(CVET==
"оранжевый"
){cvet=7;pixel_( num,cvet,M);}
051
if
(CVET==
"бежевый"
){cvet=27;pixel_( num,cvet,M);}
052
if
(CVET==
"чёрный"
||CVET==
"черный"
){cvet=0;pixel_( num,cvet,M);}
053
}
054
/////////////////////////////////////////////////
055
// бегущие 2 пикселя разных цветов по фоновому цвету (3 уровень)
056
void
fun_1( String CVET_f ,String CVET_1,String CVET_2,
byte
M,
int
T){
057
for
(
int
i = 0; i < LED_COUNT; i++) {
058
for
(
int
j = 0; j < LED_COUNT; j++) {
059
pixel_(j, CVET_f ,M);
// фоновые пиксели
060
}
061
pixel_(i, CVET_2 ,M);
// бегущий пиксель 2
062
if
(i != LED_COUNT - 1) {
063
pixel_(i+1, CVET_1 ,M);
// бегущий пиксель 1
064
}
else
{
065
pixel_(0, CVET_1 ,M);
066
}
067
strip.show(); delay(T);
068
}
069
}
070
//////////////////////////////////////////////////
071
// вариации разных комбинаций цветов 2 бегущих пикселей (4 уровень)- 1 эффект
072
void
FUN_1(
byte
M){
073
int
K=1;
//
074
byte
k=1;
//
075
byte
st_=0;
//
076
while
(st_<=4){
077
if
(st_==0){fun_1(
"мятный"
,
"красный"
,
"оранжевый"
,M,35*k);}
//
078
if
(st_==1){fun_1(
"белый_1"
,
"голубой"
,
"чёрный"
,M,35*k);}
//
079
if
(st_==2){fun_1(
"белый_2"
,
"зелёный_1"
,
"жёлтый"
,M,35*k);}
//
080
if
(st_==3){fun_1(
"малиновый"
,
"синий_2"
,
"синий_1"
,M,35*k);}
//
081
k=k+K;
if
(k==8){K=-1;}
if
(k==0){K=1;st_++;}
082
}st_=0;
083
}
084
/////////////////////////////////////////////////
085
// фоновая смена цвета свечения всего шара (3 уровень)
086
void
fun_2( String CVET_f,
byte
M,
int
T){
087
for
(
int
j = 0; j < LED_COUNT; j++) {
088
pixel_(j,
"чёрный"
,M/2);
// фоновые пиксели последовательно выключаются
089
strip.show(); delay(T);
090
}
091
092
for
(
int
j = 0; j < LED_COUNT; j++) {
093
pixel_(j, CVET_f ,M/2);
// фоновые пиксели последовательно включаются и горят
094
strip.show(); delay(T);
095
}
096
delay(40*T);
097
for
(
int
j = 0; j < LED_COUNT; j++) {
098
pixel_(j, CVET_f ,M);
// фоновые пиксели вспышка краткая
099
}
100
strip.show(); delay(6*T);
101
for
(
int
j = 0; j < LED_COUNT; j++) {
102
pixel_(j, CVET_f ,M/2);
// фоновые пиксели горят слабее некоторое время
103
}
104
strip.show(); delay(40*T);
105
}
106
//////////////////////////////////////////////////
107
// смена фоновых цветов(4 уровень)- 2 эффект
108
void
FUN_2(
byte
M,
int
T){
109
fun_2(
"красный"
,M,T);
//
110
fun_2(
"мятный"
,M,T);
//
111
fun_2(
"бежевый"
,M,T);
//
112
fun_2(
"бирюзовый"
,M,T);
//
113
fun_2(
"жёлтый"
,M,T);
//
114
fun_2(
"оранжевый"
,M,T);
//
115
fun_2(
"белый_1"
,M,T);
//
116
}
117
//////////////////////////////////////////////////
118
// фоновая смена цвета свечения всего шара (3 уровень)
119
void
fun_3( String CVET_f,
byte
M,
int
T){
120
for
(
int
j = 0; j < LED_COUNT; j++) {
121
pixel_(j,
"чёрный"
,M/2);
// фоновые пиксели последовательно выключаются
122
}
123
byte
d;
//
124
for
(
int
j = 0; j < LED_COUNT; j++) {
125
d=random(1,10);
//
126
if
(d==1){pixel_(j, CVET_f ,M);}
// фоновые пиксели псевдослучайно включаются
127
if
(d==2){pixel_(j, CVET_f ,M);}
128
if
(d==3){pixel_(j, CVET_f ,M);}
129
if
(d==4){pixel_(j, CVET_f ,M/5);}
130
if
(d==5){pixel_(j, CVET_f ,M/5);}
131
if
(d==6){pixel_(j, CVET_f ,M/5);}
132
if
(d==7){pixel_(j,CVET_f ,M/2);}
133
if
(d==8){pixel_(j,CVET_f ,M/2);}
134
if
(d==9){pixel_(j, CVET_f ,M/2);}
135
}
136
strip.show(); delay(T/d);
137
}
138
//////////////////////////////////////////////////
139
// смена фоновых цветов(4 уровень)- 3 эффект
140
void
FUN_3(
byte
M,
int
T){
141
for
(
int
i = 0; i < 100; i++) {fun_3(
"красный"
,M,T);}
//
142
for
(
int
i = 0; i < 200; i++) {fun_3(
"красный"
,M/6,T/2);}
//
143
for
(
int
i = 0; i < 100; i++) {fun_3(
"сиреневый"
,M,T);}
//
144
for
(
int
i = 0; i < 200; i++) {fun_3(
"сиреневый"
,M/6,T/2);}
//
145
for
(
int
i = 0; i < 100; i++) {fun_3(
"жёлтый"
,M,T);}
//
146
for
(
int
i = 0; i < 200; i++) {fun_3(
"жёлтый"
,M/6,T/2);}
//
147
for
(
int
i = 0; i < 100; i++) {fun_3(
"розовый"
,M,T);}
//
148
for
(
int
i = 0; i < 200; i++) {fun_3(
"розовый"
,M/6,T/2);}
//
149
for
(
int
i = 0; i < 100; i++) {fun_3(
"бирюзовый"
,M,T);}
//
150
for
(
int
i = 0; i < 200; i++) {fun_3(
"бирюзовый"
,M/6,T/2);}
//
151
}
152
//////////////////////////////////////////////////
Стратегию построения функций как то надо изменить, через "миллис :-)"
Не проще ли просто начинать со случайного эффекта в каждом шаре (или в первом - с первого, во втором - со второго и т.п.)?
(или в первом - с первого, во втором - со второго и т.п.)?
В том то и загвоздка, что с таким построением скетча вести анимацию разных эффектов на разных шарах параллельно не получится. Как то надо логику изменить. Функции надо перестроить на псевдопараллельную работу, не нарушив их структуры восприятия .
Для псевдопараллельной работы нужна синхронизация, иначе все без толку.
Да, такой вариант думался - определить общий наименьший "делей" через который идёт обновление всего массива пикселей даже если в нём значение поменял только один. Это подобие светодиодных кубов, алгоритм: кадр,пауза,кадр,пауза... Но там есть смысл - в кадре, а здесь нет.
Как бы провести аналогию...
Вот праздничный стол: салат, пюре,котлетки,водочка - красота для глаз. Однако желудку это полная хрень. Ему: кусочек салатика,пюре,котлетки,водочки;повтор;повтор;повтор... красота. Но для глаз это полная блевонтина.
Придумался довольно простой ход, без переделки кода для создания "роевого поведения шаров". Теперь можно набирать любую группу-комбинацию шаров для эффекта, остальные отдыхают (статично светят). Ниже пример блинка для гирлянды и вариант с 3 эффектами.
01
/////////////////////////// БЛИНК для гирлянды ШАРИКОВ НА WS2812b
02
#include "Adafruit_NeoPixel.h"
03
#define LED_COUNT 5 //число пикселей в шаре
04
#define LED_COUNT_N 5*LED_COUNT // число шаров в гирлянде
05
#define LED_PIN 6
06
Adafruit_NeoPixel strip = Adafruit_NeoPixel(LED_COUNT_N, LED_PIN, NEO_GRB + NEO_KHZ800);
// Создаем переменную strip для управления нашей лентой.
07
String gir=
""
;
// переменная задающая участие шара в текущем эффекте
08
void
setup
() {
09
strip.begin();
10
for
(
int
i = 0; i < LED_COUNT; i++) {
11
pixel_(i,0,0);
// выключение пикселя
12
}
13
strip.show();
14
/////////////////////////////////////////////////
15
}
16
void
loop
() {
17
gir=
"**A**"
;
//центральный шар
18
pixel_(2,
"мятный"
,25);
//центральный пиксель в шаре из 5 на яркости 25
19
strip.show();delay(1000);
//пауза
20
pixel_(2,
"чёрный"
,25);
//
21
strip.show();delay(1000);
22
}
23
//////////////////////////////////////////////////
24
// цвет пикселя по номеру (1 уровень)
25
void
pixel_(
int
num,
byte
cvet ,
byte
M){
26
if
(num<LED_COUNT&&cvet<63&&M<86){
27
int
b=cvet/16;
int
g=(cvet%16)/4;
int
r=cvet-4*g-16*b;
// цвета от 0 до 63
28
for
(
int
i = 0; i < LED_COUNT_N/LED_COUNT; i++) {
29
if
( gir.substring(i, i+1)==
"A"
){
30
strip.setPixelColor(num+i*LED_COUNT_N/LED_COUNT, r*M, g*M, b*M);
31
}
32
}
33
}
34
}
35
//////////////////////////////////////////////////
36
//цвет пикселя по названию (2 уровень)
37
void
pixel_(
int
num, String CVET ,
byte
M){
38
byte
cvet;
39
//набор цветов
40
if
(CVET==
"жёлтый"
||CVET==
"желтый"
){cvet=11;pixel_( num,cvet,M);}
41
if
(CVET==
"зелёный_1"
||CVET==
"зеленый_1"
){cvet=8;pixel_( num,cvet,M);}
42
if
(CVET==
"зелёный_3"
||CVET==
"зеленый_3"
){cvet=9;pixel_( num,cvet,M);}
43
if
(CVET==
"малиновый"
){cvet=19;pixel_( num,cvet,M);}
44
if
(CVET==
"голубой"
){cvet=52;pixel_( num,cvet,M);}
45
if
(CVET==
"розовый"
){cvet=23;pixel_( num,cvet,M);}
46
if
(CVET==
"бирюзовый"
){cvet=24;pixel_( num,cvet,M);}
47
if
(CVET==
"мятный"
){cvet=29;pixel_( num,cvet,M);}
48
if
(CVET==
"синий_1"
){cvet=37;pixel_( num,cvet,M);}
49
if
(CVET==
"белый_1"
){cvet=47;pixel_( num,cvet,M);}
50
if
(CVET==
"синий_2"
){cvet=48;pixel_( num,cvet,M);}
51
if
(CVET==
"сиреневый"
){cvet=49;pixel_( num,cvet,M);}
52
if
(CVET==
"красный"
){cvet=3;pixel_( num,cvet,M);}
53
if
(CVET==
"зелёный_2"
||CVET==
"зеленый_2"
){cvet=4;pixel_( num,cvet,M);}
54
if
(CVET==
"белый_2"
){cvet=41;pixel_( num,cvet,M);}
55
if
(CVET==
"оранжевый"
){cvet=7;pixel_( num,cvet,M);}
56
if
(CVET==
"бежевый"
){cvet=27;pixel_( num,cvet,M);}
57
if
(CVET==
"чёрный"
||CVET==
"черный"
){cvet=0;pixel_( num,cvet,M);}
58
}
59
/////////////////////////////////////////////////
001
/////////////////////////// тест цветов и эффектов для гирлянды ШАРИКОВ НА WS2812b
002
#include "Adafruit_NeoPixel.h"
003
#define LED_COUNT 5 //число пикселей в шаре
004
#define LED_COUNT_N 5*LED_COUNT // число шаров в гирлянде
005
#define LED_PIN 6
006
Adafruit_NeoPixel strip = Adafruit_NeoPixel(LED_COUNT_N, LED_PIN, NEO_GRB + NEO_KHZ800);
// Создаем переменную strip для управления нашей лентой.
007
String gir=
""
;
// переменная задающая участие шара в текущем эффекте
008
void
setup
() {
009
strip.begin();
010
for
(
int
i = 0; i < LED_COUNT; i++) {
011
pixel_(i,0,0);
// выключение пикселя
012
}
013
strip.show();
014
/////////////////////////////////////////////////
015
}
016
void
loop
() {
017
gir=
"AAAAA"
;FUN_1(25);
// исполнение 1 эффекта на всех шарах
018
gir=
"**A**"
;FUN_2(40,50);
// исполнение 2 эффекта только на центральном шаре,остальные статичны
019
gir=
"A***A"
;FUN_3(50,150);
//исполнение 3 эффекта только на крайних шарах,остальные статичны
020
}
021
//////////////////////////////////////////////////
022
// цвет пикселя по номеру (1 уровень)
023
void
pixel_(
int
num,
byte
cvet ,
byte
M){
024
if
(num<LED_COUNT&&cvet<63&&M<86){
025
int
b=cvet/16;
int
g=(cvet%16)/4;
int
r=cvet-4*g-16*b;
// цвета от 0 до 63
026
for
(
int
i = 0; i < LED_COUNT_N/LED_COUNT; i++) {
027
if
( gir.substring(i, i+1)==
"A"
){
028
strip.setPixelColor(num+i*LED_COUNT_N/LED_COUNT, r*M, g*M, b*M);
029
}
030
}
031
}
032
}
033
//////////////////////////////////////////////////
034
//цвет пикселя по названию (2 уровень)
035
void
pixel_(
int
num, String CVET ,
byte
M){
036
byte
cvet;
037
//набор цветов
038
if
(CVET==
"жёлтый"
||CVET==
"желтый"
){cvet=11;pixel_( num,cvet,M);}
039
if
(CVET==
"зелёный_1"
||CVET==
"зеленый_1"
){cvet=8;pixel_( num,cvet,M);}
040
if
(CVET==
"зелёный_3"
||CVET==
"зеленый_3"
){cvet=9;pixel_( num,cvet,M);}
041
if
(CVET==
"малиновый"
){cvet=19;pixel_( num,cvet,M);}
042
if
(CVET==
"голубой"
){cvet=52;pixel_( num,cvet,M);}
043
if
(CVET==
"розовый"
){cvet=23;pixel_( num,cvet,M);}
044
if
(CVET==
"бирюзовый"
){cvet=24;pixel_( num,cvet,M);}
045
if
(CVET==
"мятный"
){cvet=29;pixel_( num,cvet,M);}
046
if
(CVET==
"синий_1"
){cvet=37;pixel_( num,cvet,M);}
047
if
(CVET==
"белый_1"
){cvet=47;pixel_( num,cvet,M);}
048
if
(CVET==
"синий_2"
){cvet=48;pixel_( num,cvet,M);}
049
if
(CVET==
"сиреневый"
){cvet=49;pixel_( num,cvet,M);}
050
if
(CVET==
"красный"
){cvet=3;pixel_( num,cvet,M);}
051
if
(CVET==
"зелёный_2"
||CVET==
"зеленый_2"
){cvet=4;pixel_( num,cvet,M);}
052
if
(CVET==
"белый_2"
){cvet=41;pixel_( num,cvet,M);}
053
if
(CVET==
"оранжевый"
){cvet=7;pixel_( num,cvet,M);}
054
if
(CVET==
"бежевый"
){cvet=27;pixel_( num,cvet,M);}
055
if
(CVET==
"чёрный"
||CVET==
"черный"
){cvet=0;pixel_( num,cvet,M);}
056
}
057
/////////////////////////////////////////////////
058
// бегущие 2 пикселя разных цветов по фоновому цвету (3 уровень)
059
void
fun_1( String CVET_f ,String CVET_1,String CVET_2,
byte
M,
int
T){
060
for
(
int
i = 0; i < LED_COUNT; i++) {
061
for
(
int
j = 0; j < LED_COUNT; j++) {
062
pixel_(j, CVET_f ,M);
// фоновые пиксели
063
}
064
pixel_(i, CVET_2 ,M);
// бегущий пиксель 2
065
if
(i != LED_COUNT - 1) {
066
pixel_(i+1, CVET_1 ,M);
// бегущий пиксель 1
067
}
else
{
068
pixel_(0, CVET_1 ,M);
069
}
070
strip.show(); delay(T);
071
}
072
}
073
//////////////////////////////////////////////////
074
// вариации разных комбинаций цветов 2 бегущих пикселей (4 уровень)- 1 эффект
075
void
FUN_1(
byte
M){
076
int
K=1;
//
077
byte
k=1;
//
078
byte
st_=0;
//
079
while
(st_<=4){
080
if
(st_==0){fun_1(
"мятный"
,
"красный"
,
"оранжевый"
,M,35*k);}
//
081
if
(st_==1){fun_1(
"белый_1"
,
"голубой"
,
"чёрный"
,M,35*k);}
//
082
if
(st_==2){fun_1(
"белый_2"
,
"зелёный_1"
,
"жёлтый"
,M,35*k);}
//
083
if
(st_==3){fun_1(
"малиновый"
,
"синий_2"
,
"синий_1"
,M,35*k);}
//
084
k=k+K;
if
(k==8){K=-1;}
if
(k==0){K=1;st_++;}
085
}st_=0;
086
}
087
/////////////////////////////////////////////////
088
// фоновая смена цвета свечения всего шара (3 уровень)
089
void
fun_2( String CVET_f,
byte
M,
int
T){
090
for
(
int
j = 0; j < LED_COUNT; j++) {
091
pixel_(j,
"чёрный"
,M/2);
// фоновые пиксели последовательно выключаются
092
strip.show(); delay(T);
093
}
094
095
for
(
int
j = 0; j < LED_COUNT; j++) {
096
pixel_(j, CVET_f ,M/2);
// фоновые пиксели последовательно включаются и горят
097
strip.show(); delay(T);
098
}
099
delay(40*T);
100
for
(
int
j = 0; j < LED_COUNT; j++) {
101
pixel_(j, CVET_f ,M);
// фоновые пиксели вспышка краткая
102
}
103
strip.show(); delay(6*T);
104
for
(
int
j = 0; j < LED_COUNT; j++) {
105
pixel_(j, CVET_f ,M/2);
// фоновые пиксели горят слабее некоторое время
106
}
107
strip.show(); delay(40*T);
108
}
109
//////////////////////////////////////////////////
110
// смена фоновых цветов(4 уровень)- 2 эффект
111
void
FUN_2(
byte
M,
int
T){
112
fun_2(
"красный"
,M,T);
//
113
fun_2(
"мятный"
,M,T);
//
114
fun_2(
"бежевый"
,M,T);
//
115
fun_2(
"бирюзовый"
,M,T);
//
116
fun_2(
"жёлтый"
,M,T);
//
117
fun_2(
"оранжевый"
,M,T);
//
118
fun_2(
"белый_1"
,M,T);
//
119
}
120
//////////////////////////////////////////////////
121
// фоновая смена цвета свечения всего шара (3 уровень)
122
void
fun_3( String CVET_f,
byte
M,
int
T){
123
for
(
int
j = 0; j < LED_COUNT; j++) {
124
pixel_(j,
"чёрный"
,M/2);
// фоновые пиксели последовательно выключаются
125
}
126
byte
d;
//
127
for
(
int
j = 0; j < LED_COUNT; j++) {
128
d=random(1,10);
//
129
if
(d==1){pixel_(j, CVET_f ,M);}
// фоновые пиксели псевдослучайно включаются
130
if
(d==2){pixel_(j, CVET_f ,M);}
131
if
(d==3){pixel_(j, CVET_f ,M);}
132
if
(d==4){pixel_(j, CVET_f ,M/5);}
133
if
(d==5){pixel_(j, CVET_f ,M/5);}
134
if
(d==6){pixel_(j, CVET_f ,M/5);}
135
if
(d==7){pixel_(j,CVET_f ,M/2);}
136
if
(d==8){pixel_(j,CVET_f ,M/2);}
137
if
(d==9){pixel_(j, CVET_f ,M/2);}
138
}
139
strip.show(); delay(T/d);
140
}
141
//////////////////////////////////////////////////
142
// смена фоновых цветов(4 уровень)- 3 эффект
143
void
FUN_3(
byte
M,
int
T){
144
for
(
int
i = 0; i < 100; i++) {fun_3(
"красный"
,M,T);}
//
145
for
(
int
i = 0; i < 200; i++) {fun_3(
"красный"
,M/6,T/2);}
//
146
for
(
int
i = 0; i < 100; i++) {fun_3(
"сиреневый"
,M,T);}
//
147
for
(
int
i = 0; i < 200; i++) {fun_3(
"сиреневый"
,M/6,T/2);}
//
148
for
(
int
i = 0; i < 100; i++) {fun_3(
"жёлтый"
,M,T);}
//
149
for
(
int
i = 0; i < 200; i++) {fun_3(
"жёлтый"
,M/6,T/2);}
//
150
for
(
int
i = 0; i < 100; i++) {fun_3(
"розовый"
,M,T);}
//
151
for
(
int
i = 0; i < 200; i++) {fun_3(
"розовый"
,M/6,T/2);}
//
152
for
(
int
i = 0; i < 100; i++) {fun_3(
"бирюзовый"
,M,T);}
//
153
for
(
int
i = 0; i < 200; i++) {fun_3(
"бирюзовый"
,M/6,T/2);}
//
154
}
155
//////////////////////////////////////////////////
Пришла лента, с отрезками её - легче монтировать. Подправил код, была неточность.
001
/////////////////////////// тест цветов и эффектов для гирлянды ШАРИКОВ НА WS2812b
002
#include "Adafruit_NeoPixel.h"
003
#define LED_COUNT 5 //число пикселей в шаре
004
#define N 3 // число шаров в гирлянде
005
#define LED_COUNT_N N*LED_COUNT // число пикселей в ленте
006
#define LED_PIN 6
007
Adafruit_NeoPixel strip = Adafruit_NeoPixel(LED_COUNT_N, LED_PIN, NEO_GRB + NEO_KHZ800);
// Создаем переменную strip для управления нашей лентой.
008
String gir=
""
;
// переменная задающая участие шара в текущем эффекте
009
void
setup
() {
010
strip.begin();
011
for
(
int
i = 0; i < LED_COUNT_N; i++) {
012
pixel_(i,0,0);
// выключение пикселя
013
}
014
strip.show();
015
/////////////////////////////////////////////////
016
}
017
void
loop
() {
018
gir=
"AAA"
;FUN_1(25);
// исполнение 1 эффекта на всех шарах
019
gir=
"*A*"
;FUN_2(40,50);
// исполнение 2 эффекта только на центральном шаре,остальные статичны
020
gir=
"A*A"
;FUN_3(50,150);
//исполнение 3 эффекта только на крайних шарах,остальные статичны
021
}
022
//////////////////////////////////////////////////
023
// цвет пикселя по номеру (1 уровень)
024
void
pixel_(
int
num,
byte
cvet ,
byte
M){
025
if
(num<LED_COUNT&&cvet<63&&M<86){
026
int
b=cvet/16;
int
g=(cvet%16)/4;
int
r=cvet-4*g-16*b;
// цвета от 0 до 63
027
for
(
int
i = 0; i < N; i++) {
028
if
( gir.substring(i, i+1)==
"A"
){
029
strip.setPixelColor(num+i*LED_COUNT, r*M, g*M, b*M);
030
}
031
}
032
}
033
}
034
//////////////////////////////////////////////////
035
//цвет пикселя по названию (2 уровень)
036
void
pixel_(
int
num, String CVET ,
byte
M){
037
byte
cvet;
038
//набор цветов
039
if
(CVET==
"жёлтый"
||CVET==
"желтый"
){cvet=11;pixel_( num,cvet,M);}
040
if
(CVET==
"зелёный_1"
||CVET==
"зеленый_1"
){cvet=8;pixel_( num,cvet,M);}
041
if
(CVET==
"зелёный_3"
||CVET==
"зеленый_3"
){cvet=9;pixel_( num,cvet,M);}
042
if
(CVET==
"малиновый"
){cvet=19;pixel_( num,cvet,M);}
043
if
(CVET==
"голубой"
){cvet=52;pixel_( num,cvet,M);}
044
if
(CVET==
"розовый"
){cvet=23;pixel_( num,cvet,M);}
045
if
(CVET==
"бирюзовый"
){cvet=24;pixel_( num,cvet,M);}
046
if
(CVET==
"мятный"
){cvet=29;pixel_( num,cvet,M);}
047
if
(CVET==
"синий_1"
){cvet=37;pixel_( num,cvet,M);}
048
if
(CVET==
"белый_1"
){cvet=47;pixel_( num,cvet,M);}
049
if
(CVET==
"синий_2"
){cvet=48;pixel_( num,cvet,M);}
050
if
(CVET==
"сиреневый"
){cvet=49;pixel_( num,cvet,M);}
051
if
(CVET==
"красный"
){cvet=3;pixel_( num,cvet,M);}
052
if
(CVET==
"зелёный_2"
||CVET==
"зеленый_2"
){cvet=4;pixel_( num,cvet,M);}
053
if
(CVET==
"белый_2"
){cvet=41;pixel_( num,cvet,M);}
054
if
(CVET==
"оранжевый"
){cvet=7;pixel_( num,cvet,M);}
055
if
(CVET==
"бежевый"
){cvet=27;pixel_( num,cvet,M);}
056
if
(CVET==
"чёрный"
||CVET==
"черный"
){cvet=0;pixel_( num,cvet,M);}
057
}
058
/////////////////////////////////////////////////
059
// бегущие 2 пикселя разных цветов по фоновому цвету (3 уровень)
060
void
fun_1( String CVET_f ,String CVET_1,String CVET_2,
byte
M,
int
T){
061
for
(
int
i = 0; i < LED_COUNT; i++) {
062
for
(
int
j = 0; j < LED_COUNT; j++) {
063
pixel_(j, CVET_f ,M);
// фоновые пиксели
064
}
065
pixel_(i, CVET_2 ,M);
// бегущий пиксель 2
066
if
(i != LED_COUNT - 1) {
067
pixel_(i+1, CVET_1 ,M);
// бегущий пиксель 1
068
}
else
{
069
pixel_(0, CVET_1 ,M);
070
}
071
strip.show(); delay(T);
072
}
073
}
074
//////////////////////////////////////////////////
075
// вариации разных комбинаций цветов 2 бегущих пикселей (4 уровень)- 1 эффект
076
void
FUN_1(
byte
M){
077
int
K=1;
//
078
byte
k=1;
//
079
byte
st_=0;
//
080
while
(st_<=4){
081
if
(st_==0){fun_1(
"мятный"
,
"красный"
,
"оранжевый"
,M,35*k);}
//
082
if
(st_==1){fun_1(
"белый_1"
,
"голубой"
,
"чёрный"
,M,35*k);}
//
083
if
(st_==2){fun_1(
"белый_2"
,
"зелёный_1"
,
"жёлтый"
,M,35*k);}
//
084
if
(st_==3){fun_1(
"малиновый"
,
"синий_2"
,
"синий_1"
,M,35*k);}
//
085
k=k+K;
if
(k==8){K=-1;}
if
(k==0){K=1;st_++;}
086
}st_=0;
087
}
088
/////////////////////////////////////////////////
089
// фоновая смена цвета свечения всего шара (3 уровень)
090
void
fun_2( String CVET_f,
byte
M,
int
T){
091
for
(
int
j = 0; j < LED_COUNT; j++) {
092
pixel_(j,
"чёрный"
,M/2);
// фоновые пиксели последовательно выключаются
093
strip.show(); delay(T);
094
}
095
096
for
(
int
j = 0; j < LED_COUNT; j++) {
097
pixel_(j, CVET_f ,M/2);
// фоновые пиксели последовательно включаются и горят
098
strip.show(); delay(T);
099
}
100
delay(40*T);
101
for
(
int
j = 0; j < LED_COUNT; j++) {
102
pixel_(j, CVET_f ,M);
// фоновые пиксели вспышка краткая
103
}
104
strip.show(); delay(6*T);
105
for
(
int
j = 0; j < LED_COUNT; j++) {
106
pixel_(j, CVET_f ,M/2);
// фоновые пиксели горят слабее некоторое время
107
}
108
strip.show(); delay(40*T);
109
}
110
//////////////////////////////////////////////////
111
// смена фоновых цветов(4 уровень)- 2 эффект
112
void
FUN_2(
byte
M,
int
T){
113
fun_2(
"красный"
,M,T);
//
114
fun_2(
"мятный"
,M,T);
//
115
fun_2(
"бежевый"
,M,T);
//
116
fun_2(
"бирюзовый"
,M,T);
//
117
fun_2(
"жёлтый"
,M,T);
//
118
fun_2(
"оранжевый"
,M,T);
//
119
fun_2(
"белый_1"
,M,T);
//
120
}
121
//////////////////////////////////////////////////
122
// фоновая смена цвета свечения всего шара (3 уровень)
123
void
fun_3( String CVET_f,
byte
M,
int
T){
124
for
(
int
j = 0; j < LED_COUNT; j++) {
125
pixel_(j,
"чёрный"
,M/2);
// фоновые пиксели последовательно выключаются
126
}
127
byte
d;
//
128
for
(
int
j = 0; j < LED_COUNT; j++) {
129
d=random(1,10);
//
130
if
(d==1){pixel_(j, CVET_f ,M);}
// фоновые пиксели псевдослучайно включаются
131
if
(d==2){pixel_(j, CVET_f ,M);}
132
if
(d==3){pixel_(j, CVET_f ,M);}
133
if
(d==4){pixel_(j, CVET_f ,M/5);}
134
if
(d==5){pixel_(j, CVET_f ,M/5);}
135
if
(d==6){pixel_(j, CVET_f ,M/5);}
136
if
(d==7){pixel_(j,CVET_f ,M/2);}
137
if
(d==8){pixel_(j,CVET_f ,M/2);}
138
if
(d==9){pixel_(j, CVET_f ,M/2);}
139
}
140
strip.show(); delay(T/d);
141
}
142
//////////////////////////////////////////////////
143
// смена фоновых цветов(4 уровень)- 3 эффект
144
void
FUN_3(
byte
M,
int
T){
145
for
(
int
i = 0; i < 100; i++) {fun_3(
"красный"
,M,T);}
//
146
for
(
int
i = 0; i < 200; i++) {fun_3(
"красный"
,M/6,T/2);}
//
147
for
(
int
i = 0; i < 100; i++) {fun_3(
"сиреневый"
,M,T);}
//
148
for
(
int
i = 0; i < 200; i++) {fun_3(
"сиреневый"
,M/6,T/2);}
//
149
for
(
int
i = 0; i < 100; i++) {fun_3(
"жёлтый"
,M,T);}
//
150
for
(
int
i = 0; i < 200; i++) {fun_3(
"жёлтый"
,M/6,T/2);}
//
151
for
(
int
i = 0; i < 100; i++) {fun_3(
"розовый"
,M,T);}
//
152
for
(
int
i = 0; i < 200; i++) {fun_3(
"розовый"
,M/6,T/2);}
//
153
for
(
int
i = 0; i < 100; i++) {fun_3(
"бирюзовый"
,M,T);}
//
154
for
(
int
i = 0; i < 200; i++) {fun_3(
"бирюзовый"
,M/6,T/2);}
//
155
}
156
//////////////////////////////////////////////////
:-)
Интересное явление, явно неземного происхождения мне приходиться наблюдать.
001
/////////////////////////// тест цветов и эффектов для гирлянды ШАРИКОВ НА WS2812b с дистанционной заливкой скетчей на pro mini 168
002
#include "Adafruit_NeoPixel.h"
003
#define LED_COUNT 5 //число пикселей в шаре
004
#define N 3 // число шаров в гирлянде
005
#define LED_COUNT_N N*LED_COUNT // число пикселей в ленте
006
#define LED_PIN 6
007
Adafruit_NeoPixel strip = Adafruit_NeoPixel(LED_COUNT_N, LED_PIN, NEO_GRB + NEO_KHZ800);
// Создаем переменную strip для управления нашей лентой.
008
String gir=
""
;
// переменная задающая участие шара в текущем эффекте
009
int
t=3000;
// переменная задающая паузу между эффектами
010
011
long
Y=0;
//пременная хранения моментов времени
012
int
komanda=400;
// переменная хранения
013
014
void
setup
()
015
{
016
Serial
.begin(19200);
// скорость 19200 для Arduino pro mini ,
017
// может быть разная для разных моделей плат
018
strip.begin();
019
for
(
int
i = 0; i < LED_COUNT_N; i++) {
020
pixel_(i,0,0);
// выключение пикселя
021
}
022
strip.show();
023
/////////////////////////////////////////////////
024
025
}
026
027
void
loop
()
028
{
029
//сценарий переключения шаров
030
gir=
"AAA"
;FUN_1(
"мятный"
,
"красный"
,
"оранжевый"
,25);
//
031
gir=
"A*A"
;FUN_1(
"малиновый"
,
"синий_2"
,
"синий_1"
,25);
//
032
gir=
"*A*"
;FUN_1(
"белый_1"
,
"голубой"
,
"чёрный"
,25);
//
033
gir=
"A*A"
;FUN_1(
"белый_2"
,
"зелёный_1"
,
"жёлтый"
,25);
//
034
delay_(t);
035
gir=
"AAA"
;fun_2(
"мятный"
,40,50);
//
036
fun_2(
"жёлтый"
,40,50);
//
037
fun_2(
"оранжевый"
,40,50);
//
038
fun_2(
"сиреневый"
,40,50);
//
039
delay_(t);
040
gir=
"A**"
;FUN_3(
"синий_2"
,50,150);
//
041
gir=
"*A*"
;FUN_3(
"сиреневый"
,50,150);
//
042
gir=
"**A"
;FUN_3(
"жёлтый"
,50,150);
//
043
delay_(t);
044
gir=
"AAA"
;FUN_3(
"зелёный_1"
,50,150);
//
045
delay_(t);
046
//
047
gir=
"AAA"
;FUN_1(
"белый_1"
,
"красный"
,
"синий_2"
,25);
//
048
gir=
"A*A"
;FUN_1(
"сиреневый"
,
"синий_2"
,
"синий_2"
,25);
//
049
gir=
"*A*"
;FUN_1(
"белый_1"
,
"белый_2"
,
"чёрный"
,25);
//
050
gir=
"A*A"
;FUN_1(
"розовый"
,
"зелёный_1"
,
"сиреневый"
,25);
//
051
delay_(t);
052
gir=
"AAA"
;fun_2(
"сиреневый"
,40,50);
//
053
fun_2(
"белый_1"
,40,50);
//
054
fun_2(
"синий_2"
,40,50);
//
055
fun_2(
"красный"
,40,50);
//
056
delay_(t);
057
gir=
"A**"
;FUN_3(
"бежевый"
,50,150);
//
058
gir=
"*A*"
;FUN_3(
"сиреневый"
,50,150);
//
059
gir=
"**A"
;FUN_3(
"красный"
,50,150);
//
060
delay_(t);
061
gir=
"AAA"
;FUN_3(
"голубой"
,50,150);
//
062
delay_(t);
063
}
064
//////////////////////////////////////////////////
065
// цвет пикселя по номеру (1 уровень)
066
void
pixel_(
int
num,
byte
cvet ,
byte
M){
067
if
(num<LED_COUNT&&cvet<63&&M<86){
068
int
b=cvet/16;
int
g=(cvet%16)/4;
int
r=cvet-4*g-16*b;
// цвета от 0 до 63
069
for
(
int
i = 0; i < N; i++) {
070
if
( gir.substring(i, i+1)==
"A"
){
071
strip.setPixelColor(num+i*LED_COUNT, r*M, g*M, b*M);
072
}
073
}
074
}
075
}
076
//////////////////////////////////////////////////
077
//цвет пикселя по названию (2 уровень)
078
void
pixel_(
int
num, String CVET ,
byte
M){
079
byte
cvet;
080
//набор цветов
081
if
(CVET==
"жёлтый"
||CVET==
"желтый"
){cvet=11;pixel_( num,cvet,M);}
082
if
(CVET==
"зелёный_1"
||CVET==
"зеленый_1"
){cvet=8;pixel_( num,cvet,M);}
083
if
(CVET==
"зелёный_3"
||CVET==
"зеленый_3"
){cvet=9;pixel_( num,cvet,M);}
084
if
(CVET==
"малиновый"
){cvet=19;pixel_( num,cvet,M);}
085
if
(CVET==
"голубой"
){cvet=52;pixel_( num,cvet,M);}
086
if
(CVET==
"розовый"
){cvet=23;pixel_( num,cvet,M);}
087
if
(CVET==
"бирюзовый"
){cvet=24;pixel_( num,cvet,M);}
088
if
(CVET==
"мятный"
){cvet=29;pixel_( num,cvet,M);}
089
if
(CVET==
"синий_1"
){cvet=37;pixel_( num,cvet,M);}
090
if
(CVET==
"белый_1"
){cvet=47;pixel_( num,cvet,M);}
091
if
(CVET==
"синий_2"
){cvet=48;pixel_( num,cvet,M);}
092
if
(CVET==
"сиреневый"
){cvet=49;pixel_( num,cvet,M);}
093
if
(CVET==
"красный"
){cvet=3;pixel_( num,cvet,M);}
094
if
(CVET==
"зелёный_2"
||CVET==
"зеленый_2"
){cvet=4;pixel_( num,cvet,M);}
095
if
(CVET==
"белый_2"
){cvet=41;pixel_( num,cvet,M);}
096
if
(CVET==
"оранжевый"
){cvet=7;pixel_( num,cvet,M);}
097
if
(CVET==
"бежевый"
){cvet=27;pixel_( num,cvet,M);}
098
if
(CVET==
"чёрный"
||CVET==
"черный"
){cvet=0;pixel_( num,cvet,M);}
099
}
100
/////////////////////////////////////////////////
101
// бегущие 2 пикселя разных цветов по фоновому цвету (3 уровень)
102
void
fun_1( String CVET_f ,String CVET_1,String CVET_2,
byte
M,
int
T){
103
for
(
int
i = 0; i < LED_COUNT; i++) {
104
for
(
int
j = 0; j < LED_COUNT; j++) {
105
pixel_(j, CVET_f ,M);
// фоновые пиксели
106
}
107
pixel_(i, CVET_2 ,M);
// бегущий пиксель 2
108
if
(i != LED_COUNT - 1) {
109
pixel_(i+1, CVET_1 ,M);
// бегущий пиксель 1
110
}
else
{
111
pixel_(0, CVET_1 ,M);
112
}
113
strip.show(); delay_(T);
114
}
115
}
116
//////////////////////////////////////////////////
117
// вариации разных комбинаций цветов 2 бегущих пикселей (4 уровень)- 1 эффект
118
void
FUN_1(String CVET_f ,String CVET_1,String CVET_2,
byte
M){
119
int
K=1;
//
120
byte
k=1;
//
121
byte
st_=0;
//
122
while
(st_<=4){
123
if
(st_==0){fun_1(CVET_f,CVET_1,CVET_2,M,35*k);}
//
124
k=k+K;
if
(k==8){K=-1;}
if
(k==0){K=1;st_++;}
125
}st_=0;
126
}
127
/////////////////////////////////////////////////
128
// фоновая смена цвета свечения всего шара (3 уровень)
129
void
fun_2( String CVET_f,
byte
M,
int
T){
130
for
(
int
j = 0; j < LED_COUNT; j++) {
131
pixel_(j,
"чёрный"
,M/2);
// фоновые пиксели последовательно выключаются
132
strip.show(); delay_(T);
133
}
134
135
for
(
int
j = 0; j < LED_COUNT; j++) {
136
pixel_(j, CVET_f ,M/2);
// фоновые пиксели последовательно включаются и горят
137
strip.show(); delay_(T);
138
}
139
delay_(40*T);
140
for
(
int
j = 0; j < LED_COUNT; j++) {
141
pixel_(j, CVET_f ,M);
// фоновые пиксели вспышка краткая
142
}
143
strip.show(); delay_(6*T);
144
for
(
int
j = 0; j < LED_COUNT; j++) {
145
pixel_(j, CVET_f ,M/2);
// фоновые пиксели горят слабее некоторое время
146
}
147
strip.show(); delay_(40*T);
148
}
149
//////////////////////////////////////////////////
150
// смена фоновых цветов(4 уровень)- 2 эффект
151
void
FUN_2(
byte
M,
int
T){
152
fun_2(
"красный"
,M,T);
//
153
fun_2(
"мятный"
,M,T);
//
154
fun_2(
"бежевый"
,M,T);
//
155
fun_2(
"бирюзовый"
,M,T);
//
156
fun_2(
"жёлтый"
,M,T);
//
157
fun_2(
"оранжевый"
,M,T);
//
158
fun_2(
"белый_1"
,M,T);
//
159
}
160
//////////////////////////////////////////////////
161
// фоновая смена цвета свечения всего шара (3 уровень)
162
void
fun_3( String CVET_f,
byte
M,
int
T){
163
for
(
int
j = 0; j < LED_COUNT; j++) {
164
pixel_(j,
"чёрный"
,M/2);
// фоновые пиксели последовательно выключаются
165
}
166
byte
d;
//
167
for
(
int
j = 0; j < LED_COUNT; j++) {
168
d=random(1,10);
//
169
if
(d==1){pixel_(j, CVET_f ,M);}
// фоновые пиксели псевдослучайно включаются
170
if
(d==2){pixel_(j, CVET_f ,M);}
171
if
(d==3){pixel_(j, CVET_f ,M);}
172
if
(d==4){pixel_(j, CVET_f ,M/5);}
173
if
(d==5){pixel_(j, CVET_f ,M/5);}
174
if
(d==6){pixel_(j, CVET_f ,M/5);}
175
if
(d==7){pixel_(j,CVET_f ,M/2);}
176
if
(d==8){pixel_(j,CVET_f ,M/2);}
177
if
(d==9){pixel_(j, CVET_f ,M/2);}
178
}
179
strip.show(); delay_(T/d);
180
}
181
//////////////////////////////////////////////////
182
// смена фоновых цветов(4 уровень)- 3 эффект
183
void
FUN_3(String CVET_f,
byte
M,
int
T){
184
for
(
int
i = 0; i < 100; i++) {fun_3( CVET_f,M,T);}
//
185
for
(
int
i = 0; i < 200; i++) {fun_3(CVET_f,M/8,T/2);}
//
186
}
187
//////////////////////////////////////////////////
188
/////////////////////////////////////////////////////////////////////////////////
189
// функция временной задержки с проверкой поступающих данных
190
void
delay_(
int
T1)
191
{
192
Y=millis();
193
while
(millis()-Y<T1){komanda=CheckSerial();}
//по поступившей команде выполняем действие
194
195
}
К про мини 168 подключён блютуз модуль и идёт заливка скетча по воздуху. После заливки таинственно исчезает исполнение строк 30,31,50. Шары на время исполнение переключений пикселей в этих строках просто замирают на предыдущих цветах, как бы берут паузу.
Первое, что подумал - кривой вариант скетча. Перезалил его на уно, потом на нано - исполнение всех строк вернулось. Второе, что подумал - часть строк испаряется в воздухе, пока заливается. Залил скетч по шнуру прямо в платку и вернул её в схему - строки потерялись.
Третье: подумал, что виноват блютуз модуль и соединения лишние (провод с вывода на ресет) - убрал лишнее, только шары, аккумулятор и платка. Строки теряются на исполнении.
Четвёртое: про мини не может воспроизводить конкретно эти строки кода. Собрал исходную схему и по воздуху залил такой вариант , со строкой 30. Он работает как надо.
001
/////////////////////////// тест цветов и эффектов для гирлянды ШАРИКОВ НА WS2812b с дистанционной заливкой скетчей на pro mini 168
002
#include "Adafruit_NeoPixel.h"
003
#define LED_COUNT 5 //число пикселей в шаре
004
#define N 3 // число шаров в гирлянде
005
#define LED_COUNT_N N*LED_COUNT // число пикселей в ленте
006
#define LED_PIN 6
007
Adafruit_NeoPixel strip = Adafruit_NeoPixel(LED_COUNT_N, LED_PIN, NEO_GRB + NEO_KHZ800);
// Создаем переменную strip для управления нашей лентой.
008
String gir=
""
;
// переменная задающая участие шара в текущем эффекте
009
int
t=3000;
// переменная задающая паузу между эффектами
010
011
long
Y=0;
//пременная хранения моментов времени
012
int
komanda=400;
// переменная хранения
013
014
void
setup
()
015
{
016
Serial
.begin(19200);
// скорость 19200 для Arduino pro mini ,
017
// может быть разная для разных моделей плат
018
strip.begin();
019
for
(
int
i = 0; i < LED_COUNT_N; i++) {
020
pixel_(i,0,0);
// выключение пикселя
021
}
022
strip.show();
023
/////////////////////////////////////////////////
024
025
}
026
027
void
loop
()
028
{
029
//сценарий переключения шаров
030
gir=
"AAA"
;FUN_1(
"мятный"
,
"красный"
,
"оранжевый"
,25);
//
031
delay_(2*t);
032
033
}
034
//////////////////////////////////////////////////
035
// цвет пикселя по номеру (1 уровень)
036
void
pixel_(
int
num,
byte
cvet ,
byte
M){
037
if
(num<LED_COUNT&&cvet<63&&M<86){
038
int
b=cvet/16;
int
g=(cvet%16)/4;
int
r=cvet-4*g-16*b;
// цвета от 0 до 63
039
for
(
int
i = 0; i < N; i++) {
040
if
( gir.substring(i, i+1)==
"A"
){
041
strip.setPixelColor(num+i*LED_COUNT, r*M, g*M, b*M);
042
}
043
}
044
}
045
}
046
//////////////////////////////////////////////////
047
//цвет пикселя по названию (2 уровень)
048
void
pixel_(
int
num, String CVET ,
byte
M){
049
byte
cvet;
050
//набор цветов
051
if
(CVET==
"жёлтый"
||CVET==
"желтый"
){cvet=11;pixel_( num,cvet,M);}
052
if
(CVET==
"зелёный_1"
||CVET==
"зеленый_1"
){cvet=8;pixel_( num,cvet,M);}
053
if
(CVET==
"зелёный_3"
||CVET==
"зеленый_3"
){cvet=9;pixel_( num,cvet,M);}
054
if
(CVET==
"малиновый"
){cvet=19;pixel_( num,cvet,M);}
055
if
(CVET==
"голубой"
){cvet=52;pixel_( num,cvet,M);}
056
if
(CVET==
"розовый"
){cvet=23;pixel_( num,cvet,M);}
057
if
(CVET==
"бирюзовый"
){cvet=24;pixel_( num,cvet,M);}
058
if
(CVET==
"мятный"
){cvet=29;pixel_( num,cvet,M);}
059
if
(CVET==
"синий_1"
){cvet=37;pixel_( num,cvet,M);}
060
if
(CVET==
"белый_1"
){cvet=47;pixel_( num,cvet,M);}
061
if
(CVET==
"синий_2"
){cvet=48;pixel_( num,cvet,M);}
062
if
(CVET==
"сиреневый"
){cvet=49;pixel_( num,cvet,M);}
063
if
(CVET==
"красный"
){cvet=3;pixel_( num,cvet,M);}
064
if
(CVET==
"зелёный_2"
||CVET==
"зеленый_2"
){cvet=4;pixel_( num,cvet,M);}
065
if
(CVET==
"белый_2"
){cvet=41;pixel_( num,cvet,M);}
066
if
(CVET==
"оранжевый"
){cvet=7;pixel_( num,cvet,M);}
067
if
(CVET==
"бежевый"
){cvet=27;pixel_( num,cvet,M);}
068
if
(CVET==
"чёрный"
||CVET==
"черный"
){cvet=0;pixel_( num,cvet,M);}
069
}
070
/////////////////////////////////////////////////
071
// бегущие 2 пикселя разных цветов по фоновому цвету (3 уровень)
072
void
fun_1( String CVET_f ,String CVET_1,String CVET_2,
byte
M,
int
T){
073
for
(
int
i = 0; i < LED_COUNT; i++) {
074
for
(
int
j = 0; j < LED_COUNT; j++) {
075
pixel_(j, CVET_f ,M);
// фоновые пиксели
076
}
077
pixel_(i, CVET_2 ,M);
// бегущий пиксель 2
078
if
(i != LED_COUNT - 1) {
079
pixel_(i+1, CVET_1 ,M);
// бегущий пиксель 1
080
}
else
{
081
pixel_(0, CVET_1 ,M);
082
}
083
strip.show(); delay_(T);
084
}
085
}
086
//////////////////////////////////////////////////
087
// вариации разных комбинаций цветов 2 бегущих пикселей (4 уровень)- 1 эффект
088
void
FUN_1(String CVET_f ,String CVET_1,String CVET_2,
byte
M){
089
int
K=1;
//
090
byte
k=1;
//
091
byte
st_=0;
//
092
while
(st_<=4){
093
if
(st_==0){fun_1(CVET_f,CVET_1,CVET_2,M,35*k);}
//
094
k=k+K;
if
(k==8){K=-1;}
if
(k==0){K=1;st_++;}
095
}st_=0;
096
}
097
/////////////////////////////////////////////////
098
// фоновая смена цвета свечения всего шара (3 уровень)
099
void
fun_2( String CVET_f,
byte
M,
int
T){
100
for
(
int
j = 0; j < LED_COUNT; j++) {
101
pixel_(j,
"чёрный"
,M/2);
// фоновые пиксели последовательно выключаются
102
strip.show(); delay_(T);
103
}
104
105
for
(
int
j = 0; j < LED_COUNT; j++) {
106
pixel_(j, CVET_f ,M/2);
// фоновые пиксели последовательно включаются и горят
107
strip.show(); delay_(T);
108
}
109
delay_(40*T);
110
for
(
int
j = 0; j < LED_COUNT; j++) {
111
pixel_(j, CVET_f ,M);
// фоновые пиксели вспышка краткая
112
}
113
strip.show(); delay_(6*T);
114
for
(
int
j = 0; j < LED_COUNT; j++) {
115
pixel_(j, CVET_f ,M/2);
// фоновые пиксели горят слабее некоторое время
116
}
117
strip.show(); delay_(40*T);
118
}
119
//////////////////////////////////////////////////
120
// смена фоновых цветов(4 уровень)- 2 эффект
121
void
FUN_2(
byte
M,
int
T){
122
fun_2(
"красный"
,M,T);
//
123
fun_2(
"мятный"
,M,T);
//
124
fun_2(
"бежевый"
,M,T);
//
125
fun_2(
"бирюзовый"
,M,T);
//
126
fun_2(
"жёлтый"
,M,T);
//
127
fun_2(
"оранжевый"
,M,T);
//
128
fun_2(
"белый_1"
,M,T);
//
129
}
130
//////////////////////////////////////////////////
131
// фоновая смена цвета свечения всего шара (3 уровень)
132
void
fun_3( String CVET_f,
byte
M,
int
T){
133
for
(
int
j = 0; j < LED_COUNT; j++) {
134
pixel_(j,
"чёрный"
,M/2);
// фоновые пиксели последовательно выключаются
135
}
136
byte
d;
//
137
for
(
int
j = 0; j < LED_COUNT; j++) {
138
d=random(1,10);
//
139
if
(d==1){pixel_(j, CVET_f ,M);}
// фоновые пиксели псевдослучайно включаются
140
if
(d==2){pixel_(j, CVET_f ,M);}
141
if
(d==3){pixel_(j, CVET_f ,M);}
142
if
(d==4){pixel_(j, CVET_f ,M/5);}
143
if
(d==5){pixel_(j, CVET_f ,M/5);}
144
if
(d==6){pixel_(j, CVET_f ,M/5);}
145
if
(d==7){pixel_(j,CVET_f ,M/2);}
146
if
(d==8){pixel_(j,CVET_f ,M/2);}
147
if
(d==9){pixel_(j, CVET_f ,M/2);}
148
}
149
strip.show(); delay_(T/d);
150
}
151
//////////////////////////////////////////////////
152
// смена фоновых цветов(4 уровень)- 3 эффект
153
void
FUN_3(String CVET_f,
byte
M,
int
T){
154
for
(
int
i = 0; i < 100; i++) {fun_3( CVET_f,M,T);}
//
155
for
(
int
i = 0; i < 200; i++) {fun_3(CVET_f,M/8,T/2);}
//
156
}
157
//////////////////////////////////////////////////
158
/////////////////////////////////////////////////////////////////////////////////
159
// функция временной задержки с проверкой поступающих данных
160
void
delay_(
int
T1)
161
{
162
Y=millis();
163
while
(millis()-Y<T1){komanda=CheckSerial();}
//по поступившей команде выполняем действие
164
165
}
Вопрос... где секрет явления?