Ёлочная гирлянда из WS2811 и старый БП от компа

Focus
Offline
Зарегистрирован: 05.04.2015

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

Видео работы гирлянды можно посмотреть тут

Вид аппарата на данный момент:

Пару лет назад пришлось справлять этот волшебный праздник (для кого этот праздник не является волшебным/сказочным могут закрыть эту страницу и дальше не читать ;) ) с обычной китайской гирляндой из лампочек накаливания, которые от старости выцвели и светили стрёмным жёлтым цветом. И была найдена зависимость: какая гирлянда - такой и новый год.

Год назад (перед 2016 нг) заказал с китаю гирлянду в 100 диодов с чипами ws2811, Ехала долго, думал не успеет, но мне повезло - гирлянда приехала до нового года. Побыстрому отрыл старый БП от компа ватт на 250, выдрал лишние провода и заменил вспухшие кондёры, почистил естественно и перепаял 80 вентилятор с 12в на 5в чтоб меньше жужжал, предварительно смазав его литолом. Впихал туда нану, кнопочки, крутилочки... Мегает! ))

Ёлка у меня искуственная но высокая и пышная, прикинул по вышине - 25 диодов получилось в самый раз, поэтому кирлянда была распилина на 4 куска по 25 диодов. (позже я добавил ещё 4 таких куска, но об этом позже)

Одна крутилка регулирует яркость гирлянды, вторая скорость еффектов, третья будет менять скорость смены цвета в радуге, ну или ещё чего на неё повешать - незнаю.

Кнопка из 3х задействована одна. Она переключает эффекты и записывает в ЕЕПРОМ, для того, чтобы при включении показывался ранее выбраный эффект. На две другие пока думаю чего навешать. можно например ночной режим - яркость на минимум, скорость на минимум, эффект радуга. Или можно определённые, самые любимые эффекты на них повешать.

Из эффектов пока 6 штук из библтотеки FastLED и ещё несколько самопальных :) В том числе "снегопад"

Зачем запихал в такую большую коробку? Потому что старых БП от компа у меня много :) . И сейчас будут подключаться 100 диодов (4 обрезка по 25шт) это на полной яркости белого цвета почти 6А, К следующему новому году наверно добавлю ещё 4 таких обрезка, будет уже 12А. Тот БП что я использовал выдаёт 18А по 5в линии, тоесть ещё запас на 4 обрезка по 25 диодов останется.

А теперь как я туда чего запихивал, высверливал и протачивал...

Нашёл свободное место, подальше от высокочастотных и силовых узлов (разъём 220 не в счет :) )

К тому же будет доступ к USB разъёму.

Для органов управления так же найдено место, подальше от всего опасного...

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

Паяем выходы, те что пойдут на гирлянды. Для безопасности делаем это через резистор. Советуют 470ом, но у меня были в наличии на 330, сойдёт...

Распаял кнопки и переменники. Кнопки замыкают на массу и используется внутренняя подтяжка к плюсу, поэтому лишних резисторов не ставим. Все переменники подключены одним концом на массу, другим все в кучу, кондёрами (100мкф и 0.1мкф) на массу и через 200 ом резистор (ну вдруг там чего замкнёт) на +5в. Ползунки переменников идут в ардуино.

Подаём питание... И поскольку очень много говорят про всякие там помехи, фильтры - поставил пару кондёров (100мкф и 0.1мкф) Не потому что я чегото там просчитал, а просто у меня есть кондёры только 100мкф и 0.1мкф :D

Всё паялось обычным 40вт паялом, без всякого заземления со вставленой в панель ардуиной и как ни странно, всё работает :)

Был написан скетч по быстрому на базе библиотеки FastLED и весело отпразднован новый год. После чего, гирлянда вместе с ёлкой были упрятаны в коробку и отправлены в дальний угол ожидать следующего нового года.

И вот "на горизонте" обозначился очередной 2017 новый год. заказана и уже доставлена ещё одна гирлянда из 100 диодов с чипами WS2811 (правда у другого продавца. у предыдущего в наличии их не оказалось). Досталась прошлогодняя гирлянда и работы продолжились...

Было решено заменить самопальные разъёмы на нормальные типа "Джек". Был так же докуплен провод и термоусадка.

Выбрано место, куда бы эти 8 джеков влезли - единственным местом оказалось пространство над высоковольтной частью блока питания. Боимся, но делаем...

Готово! Теперь надо паять к ним провода...

В прошлом году гирлянд было 4, распаял на 6, но в задумке было 8, поэтому допаиваем недостающие 2 провода с резисторами.

И припаиваем это всё к джекам, не забывая надевать термоусадки (я на плюс забыл одеть)...

Вычитал также что надо конденсатор ближе к гирляндам поставить, под руку попался 1000мкф х 25в. Паяю его прямо к джекам.

Чтоб провода не лезли к вентелятору и высоковольтной части БП - фиксирую их бумажным скотчем и для верности - клеющим пистолетом.

Собираем корпус

Припаивал провода метра по полтора от джека до куска гирлянды, закрывая все стыки термоусадкой

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

Подошло время для скетча... Первая версия была переработана, инициализация лент была запихана в массив, вызов эффектов был переделан под использование этого массива, что дало возможность делать горизонтальные эффекты. Сделал 1-2 эффекта простых (между лентами) и после нескольких дней обдумывания изобретён эффект "снегопад". Если бы вместо гирлянд были ленты с высокой плотностью диодов, то эффект можно было назвать "капающие сосульки", а на гирлянде только "снегопад" :) Для меня версия скетча "v2 рабочая", вам нужно егорассматривать как "преальфа" :)

Библиотеку FastLED качаем здесь

#include <EEPROM.h>
#include "FastLED.h"
const int bright_rezistor_pin = A7; // Резистор регулировки яркости (10к)
const int rainbowspeed_rezistor_pin = A6; // Резистор регулировки скорости смены цвета в радуге (10к)
const int fps_rezistor_pin = A5; // Общая скорость эффектов (кадров в секунду) (10к)
const int btn_changeeffect_pin = 2; // Кнопка смены эффектов
const int btn_2_pin = 3; // Резерв
const int btn_3_pin = 4; // Резерв

int bright_rezistor = 400; // Стартовое значение резистора яркости
int fps_rezistor = 400; // Стартовое значение резистора скорости еффектов (fps)

int btn_changeeffect_flag = 0;
int btn_changeeffect_state = HIGH;
int last_btn_changeeffect_state = HIGH;
long last_btn_changeeffect_debounce_time = 0;
const int debounceDelay = 80;
byte current_effect = 0;
const int eeprom_addr = 4;

int pos1 = 0;
int color_x = 0;

FASTLED_USING_NAMESPACE
#if FASTLED_VERSION < 3001000
#error "Requires FastLED 3.1 or later; check github for latest code."
#endif

#define DATA_PIN_1  5  // Определяем пин для ленты #1
#define DATA_PIN_2  6  // Определяем пин для ленты #2
#define DATA_PIN_3  7  // Определяем пин для ленты #3
#define DATA_PIN_4  8  // Определяем пин для ленты #4
#define DATA_PIN_5  9  // Определяем пин для ленты #5
#define DATA_PIN_6  10 // Определяем пин для ленты #6
#define DATA_PIN_7  11 // Определяем пин для ленты #7
#define DATA_PIN_8  12 // Определяем пин для ленты #8

#define LED_TYPE    WS2811
#define COLOR_ORDER RGB
#define NUM_LEDS    25
#define NUM_STRIPS  8
CRGB leds[NUM_STRIPS][NUM_LEDS];

#define BRIGHTNESS         150  // Стартовое значение яркости
#define FRAMES_PER_SECOND  1   // Стартовое значение скорости эффектов

void setup() {
  Serial.begin(9600); // Для отладки
  
  pinMode(bright_rezistor_pin, INPUT);
  pinMode(rainbowspeed_rezistor_pin, INPUT);
  pinMode(fps_rezistor_pin, INPUT);
  
  pinMode(btn_changeeffect_pin, INPUT);
  digitalWrite(btn_changeeffect_pin, HIGH); // Используем встроенную верхнюю подтяжку
  pinMode(btn_2_pin, INPUT);
  digitalWrite(btn_2_pin, HIGH); // Используем встроенную верхнюю подтяжку
  pinMode(btn_3_pin, INPUT);
  digitalWrite(btn_3_pin, HIGH); // Используем встроенную верхнюю подтяжку
  
  delay(1000); // 3 second delay for recovery
  
  // tell FastLED about the LED strip configuration
  FastLED.addLeds<LED_TYPE,DATA_PIN_1,COLOR_ORDER>(leds[0], NUM_LEDS).setCorrection(TypicalLEDStrip);
  FastLED.addLeds<LED_TYPE,DATA_PIN_2,COLOR_ORDER>(leds[1], NUM_LEDS).setCorrection(TypicalLEDStrip);
  FastLED.addLeds<LED_TYPE,DATA_PIN_3,COLOR_ORDER>(leds[2], NUM_LEDS).setCorrection(TypicalLEDStrip);
  FastLED.addLeds<LED_TYPE,DATA_PIN_4,COLOR_ORDER>(leds[3], NUM_LEDS).setCorrection(TypicalLEDStrip);
  FastLED.addLeds<LED_TYPE,DATA_PIN_5,COLOR_ORDER>(leds[4], NUM_LEDS).setCorrection(TypicalLEDStrip);
  FastLED.addLeds<LED_TYPE,DATA_PIN_6,COLOR_ORDER>(leds[5], NUM_LEDS).setCorrection(TypicalLEDStrip);
  FastLED.addLeds<LED_TYPE,DATA_PIN_7,COLOR_ORDER>(leds[6], NUM_LEDS).setCorrection(TypicalLEDStrip);
  FastLED.addLeds<LED_TYPE,DATA_PIN_8,COLOR_ORDER>(leds[7], NUM_LEDS).setCorrection(TypicalLEDStrip);

  // set master brightness control
  FastLED.setBrightness(BRIGHTNESS);
  current_effect = EEPROM.read(eeprom_addr);
}


// List of patterns to cycle through.  Each is defined as a separate function below.
typedef void (*SimplePatternList[])();
SimplePatternList gPatterns = { rainbow, rainbowWithGlitter, confetti, sinelon, juggle, bpm, horizont_2, snow_2 };

uint8_t gCurrentPatternNumber = 0; // Index number of which pattern is current
uint8_t gHue = 0; // rotating "base color" used by many of the patterns
  
void loop()
{
  bright_rezistor = map(analogRead(bright_rezistor_pin), 0, 985 ,10 ,255);
  fps_rezistor = map(analogRead(fps_rezistor_pin), 0, 985 ,5 ,255);
  
  // Городим жуткую защиту от дребезга для кнопки переключения эффектов...
  int btn_changeeffect_reading = digitalRead(btn_changeeffect_pin);
  if(btn_changeeffect_reading != last_btn_changeeffect_state){
    last_btn_changeeffect_debounce_time = millis();
  }
  if((millis() - last_btn_changeeffect_debounce_time) > debounceDelay) {
    if(btn_changeeffect_reading != btn_changeeffect_state) {
      btn_changeeffect_state = btn_changeeffect_reading;
      if(btn_changeeffect_state == LOW && btn_changeeffect_flag == 0){ // Если кнопка нажата...
        current_effect ++; // Увиличиваем номер эффекта
        EEPROM.write(eeprom_addr, current_effect); // Записываем номер эффекта в ЭСППЗУ
        btn_changeeffect_flag = 1;
        if(current_effect > 9){      // Если номер эффекта превышает существующее
          current_effect = 0;        // то отсчет начинается с нуля
        }
      }
      if(btn_changeeffect_state == HIGH && btn_changeeffect_flag == 1){
        btn_changeeffect_flag = 0;
      }
    }
  }
  last_btn_changeeffect_state = btn_changeeffect_reading;
  
  FastLED.setBrightness(bright_rezistor);
  //Serial.println(current_effect);
  //delay(1);
  if(current_effect == 0){
    EVERY_N_SECONDS( 10 ) { nextPattern(); } // change patterns periodically
    gPatterns[gCurrentPatternNumber]();
  }
  if(current_effect == 1){
    rainbow();
  }
  if(current_effect == 2){
    rainbowWithGlitter();
  }
  if(current_effect == 3){
    confetti();
  }
  if(current_effect == 4){
    sinelon();
  }
  if(current_effect == 5){
    juggle();
  }
  if(current_effect == 6){
    bpm();
  }
  if(current_effect == 7){
    horizont_2();
  }
  if(current_effect == 8){
    snow_1();
  }
  if(current_effect == 9){
    snow_2();
  }

  // send the 'leds' array out to the actual LED strip
  FastLED.show();  
  // insert a delay to keep the framerate modest
  FastLED.delay(1000/fps_rezistor); 

  // do some periodic updates
  EVERY_N_MILLISECONDS( 1 ) { gHue++; } // slowly cycle the "base color" through the rainbow
}

#define ARRAY_SIZE(A) (sizeof(A) / sizeof((A)[0]))

void nextPattern()
{
  // add one to the current pattern number, and wrap around at the end
  gCurrentPatternNumber = (gCurrentPatternNumber + 1) % ARRAY_SIZE( gPatterns);
}

void rainbow(){
  // FastLED's built-in rainbow generator
  for(int i=0; i < NUM_STRIPS; i++){
    fill_rainbow( leds[i], NUM_LEDS, gHue, 7);
  }
}

void rainbowWithGlitter(){
  // built-in FastLED rainbow, plus some random sparkly glitter
  rainbow();
  addGlitter(80);
}

void addGlitter( fract8 chanceOfGlitter){
  if( random8() < chanceOfGlitter) {
    for(int i=0; i < NUM_STRIPS; i++){
      leds[i][ random16(NUM_LEDS) ] += CRGB::White;
    }
  }
}

void confetti(){
  // random colored speckles that blink in and fade smoothly
  for(int i=0; i < NUM_STRIPS; i++){
    fadeToBlackBy( leds[i], NUM_LEDS, 10);
  }
  int pos = random16(NUM_LEDS);
  for(int i=0; i < NUM_STRIPS; i++){
    leds[i][pos] += CHSV( gHue + random8(64), 200, 255);
  }
}

void sinelon(){
  // a colored dot sweeping back and forth, with fading trails
  for(int i=0; i < NUM_STRIPS; i++){
    fadeToBlackBy( leds[i], NUM_LEDS, 20);
  }
  int pos = beatsin16(13,0,NUM_LEDS);
  for(int i=0; i < NUM_STRIPS; i++){
    leds[i][pos] += CHSV( gHue, 255, 192);
  }
}

void bpm(){
  // colored stripes pulsing at a defined Beats-Per-Minute (BPM)
  uint8_t BeatsPerMinute = 62;
  CRGBPalette16 palette = PartyColors_p;
  uint8_t beat = beatsin8( BeatsPerMinute, 64, 255);
  for( int ii = 0; ii < NUM_LEDS; ii++) { //9948
    for(int i=0; i < NUM_STRIPS; i++){
      leds[i][ii] = ColorFromPalette(palette, gHue+(ii*2), beat-gHue+(ii*10));
    }
  }
}

void juggle(){
  // eight colored dots, weaving in and out of sync with each other
  for(int i=0; i < NUM_STRIPS; i++){
    fadeToBlackBy( leds[i], NUM_LEDS, 20);
  }
  byte dothue = 0;
  for( int ii = 0; ii < 8; ii++) {
    for(int i=0; i < NUM_STRIPS; i++){
      leds[i][beatsin16(ii+7,0,NUM_LEDS)] |= CHSV(dothue, 200, 255);
    }
    dothue += 32;
  }
}

void horizont_2(){
  for(int i=0; i < NUM_STRIPS; i++){
    fadeToBlackBy( leds[i], NUM_LEDS, 100);
  }
  if(pos1 > NUM_STRIPS-1) {pos1 = 0; color_x = color_x+1;}
  if(color_x > 3) color_x = 0;
  CRGB color[] = {CRGB(255, 0, 0), CRGB(0, 255, 0), CRGB(0, 0, 255), CRGB(255, 255, 255),
                  CRGB(255, 0, 255), CRGB(0, 255, 255), CRGB(255, 255, 0), CRGB(255, 150, 150)};
  for (int i=0; i <= NUM_LEDS-1; i++){
    leds[pos1][i] = color[color_x];
  }
  pos1 = pos1+1;
}

void horizont_3(){
  for(int i=0; i < NUM_STRIPS; i++){
    fadeToBlackBy( leds[i], NUM_LEDS, 100);
  }
  if(pos1 > NUM_STRIPS-1) pos1 = 0;
  for (int i=0; i <= NUM_LEDS-1; i++){
    leds[pos1][i] = CHSV( gHue, 255, 192);
  }
  pos1 = pos1+1;
}
void snow_1(){
  if(pos1 > NUM_LEDS*2-1) pos1 = 0;
  for(int i=0; i < NUM_STRIPS; i++){
    fadeToBlackBy( leds[i], NUM_LEDS, 50);
  }
  for(int i=0; i < NUM_STRIPS; i++){
    leds[i][NUM_LEDS-pos1/2-1] = CRGB(255, 255, 255);
  }
  pos1 = pos1+1;
}

struct snow_line{   // объявляем структуру для ленты снега
    byte pos;
    long end_time;
    int  start_delay;
} type;
snow_line snow_2_vars[NUM_STRIPS];
void snow_2(){  
  for(int i=0; i < NUM_STRIPS; i++){
    fadeToBlackBy( leds[i], NUM_LEDS, 40);
  }
  
  for(byte i=0; i < NUM_STRIPS; i++){
    if(snow_2_vars[i].pos > NUM_LEDS*2-1){   // Если дошли до конца ленты то...
      snow_2_vars[i].pos = 0;              // Сбрасываем позицию на ноль
      snow_2_vars[i].end_time = millis();  // Записываем время окончания эффекта
      
    }
    if(snow_2_vars[i].pos == 0){           //  Если задана нулевая позиция - значит начало, то...
      snow_2_vars[i].start_delay = random(10, 3000);    // Генерируем врменную задержку запуска эффекта (до 3х секунд)
    }
    if(millis() > snow_2_vars[i].end_time+snow_2_vars[i].start_delay){  // Если вышла задержка перед запуском эффекта, запускаем...
      leds[i][NUM_LEDS-snow_2_vars[i].pos/2-1] = CRGB(255, 255, 200);
      snow_2_vars[i].pos++; 
    }
  }
}

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

Если не считать скетч, то остаётся обклеить БП винилом или покрасить в более ёлочно-новогодние цвета, прикрыть дыру, где торчит ардуина и готово.

Если кто будет чикать гирлянду как я пополам - у гирлянды есть вход и выход. Тоесть есть разница куда подавать сигнал. Нельзя просто взять и перевернуть гирлянду.

Питается всё от 5 вольт. Слышал про 12 вольтовые подобные гирлянды, но сам не видел, может врут :)

Ещё пару слов о железе и библиотеке: Новая версия библиотеки умеет работать с ESP8266, учитывая что сервис RemoteXY сейчас стал бесплатным до 5 элементов (кто незнает что это такое - погуглите) то вполне можно было бы спаять и на ней, управляя со смартфона, но там я нашёл только 7 GPIO с которыми работает библиотека, а мне нужно было 8. В принципе гирлянду можно было не разрезать, управлять по одному проводу всеми 200 диодами, но нужно было бы чтото решать с питанием (если зажеч эту гирлянду со 100 диодами белым и на полной яркости, подать с одной стороны 5в, то до последнего светодиода дойдёт только 2.5в) Да и управлять неразрывной гирляндой лично для меня было бы значительно путанней :)

Начинал я описывать гирлянду в этой ветке но решил сделать отдельной темой. Если кто умеет затирать сообщения - там можно удалить :)

arduinec
Offline
Зарегистрирован: 01.09.2015

Focus пишет:

может эффект какой добавлю

На восьми параллельных гирляндах можно бегущую строку написась ("С Новым годом!" например).
https://yadi.sk/i/KjPlzioNjskYL
 

Focus
Offline
Зарегистрирован: 05.04.2015

В моей гирлянде всего 25 диодов на полосу и расстояние между ними 7см, к тому же висеть будут на ёлке, получается трапеция, даже треугольник. Бегущая строка в таком виде будет выглядеть не так симпатично :) Хотя написать число 2017 я всё же попробую, когда на ёлку повешаю.

macros
Offline
Зарегистрирован: 07.11.2016

Посмотрите еще https://github.com/nicoyn/YALO-PureArduino

и https://github.com/atuline/FastLED-Demos

Я делал грилянду на елку в итоге в ней сейчас: два эфекта светомузыки и прикрутил туда 10-ок спецэфектов без участия микрофона.

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

Больше всего мне нравится YALO.

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

Serzh
Offline
Зарегистрирован: 31.12.2016

Хорошая гирлянда получилась. Побольше интересных эфектов бы, будет класс! Где то видел такой, называется "салют", например горит вся гирлянда жолтым цветом и втечении 3-5 секунд угосает примерно на 50%  затем с низу к макушке летят например красного цвета как у тебя эфект "снегопад" только не вниз , а к верху.   на макушке первый ряд мигает часто 3 раза и по ряду падает в низ наполнением как заполнится вся елка красным цветом она угасает на 50% и все заново.

Попрубуй на елке выглядело красиво . 

Serzh
Offline
Зарегистрирован: 31.12.2016

прислали и мне  гирлянду к жалко новый год кончился.

залил я код в ардуино, а гирянды не горя т воооще

позвольте спросить, Focus, я не подключал резисторы и кнопки к ардуино поэтому у меня нечего не мигает ???

macros
Offline
Зарегистрирован: 07.11.2016

Serzh пишет:

залил я код в ардуино, а гирянды не горя т воооще

Примеры из библиотеки FastLED пробывали?

Еще важно какой стороной грилянду цепляете к контролеру, попробуйте поменять.

Focus
Offline
Зарегистрирован: 05.04.2015

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

На счёт перевернуть - если наоборот подать, да ещё без резистора, ws2811 выживет?

 

А так да, на примерах библиотеки FastLED надо попробовать, работает ли вообще гирлянда, ws2811 там?

macros
Offline
Зарегистрирован: 07.11.2016

Focus пишет:

На счёт перевернуть - если наоборот подать, да ещё без резистора, ws2811 выживет?

Теорию не знаю, но у меня выжила. Я вначале собирал по схеме найденой в интернете без резистров и подключил грилянду не той стороной (там же стороны не различимы), она просто не зажглась. Схема была с mysku.ru, там же в комментарии прочитал что если перепутать сторону грильянды, тогда она не горит. 

Serzh
Offline
Зарегистрирован: 31.12.2016

да библиотеку конечно подключаю

заливаю код от http://www.getchip.net/posts/117-12-ti-kanalnyjj-meteor-na-svetodiodnykh-lentakh-ws2812b-arduino/ метеора все гирлянды мегают как положено только ваш код не мигает

Serzh
Offline
Зарегистрирован: 31.12.2016

Serzh пишет:

прислали и мне  гирлянду к жалко новый год кончился.

залил я код в ардуино, а гирянды не горя т воооще

позвольте спросить, Focus, я не подключал резисторы и кнопки к ардуино поэтому у меня нечего не мигает ???

я имел ввиду переменные резисторы на 10 кОм. а на упровляющий контакт гирлянд я прицепил 470 Ом на каждую

macros
Offline
Зарегистрирован: 07.11.2016

Serzh пишет:

да библиотеку конечно подключаю

по вашей ссылке WS2812b, код немного отличается от WS2811 (строка 038). У вас какой чип в грилянде?

Serzh
Offline
Зарегистрирован: 31.12.2016

 

[/quote]

Примеры из библиотеки FastLED пробывали?

 

[/quote]

сейчас попробывал пример из библиотеки FastLED пример ColorPalette РАБОТАЕТ

Focus
Offline
Зарегистрирован: 05.04.2015

Serzh пишет:

да библиотеку конечно подключаю

заливаю код от http://www.getchip.net/posts/117-12-ti-kanalnyjj-meteor-na-svetodiodnykh-lentakh-ws2812b-arduino/ метеора все гирлянды мегают как положено только ваш код не мигает

Ну тогда надо кнопку эффектов понажимать или прописать номер эффекта в скетче

вместо current_effect = EEPROM.read(eeprom_addr);

прописать current_effect = 1; например

вместо 

bright_rezistor = map(analogRead(bright_rezistor_pin), 0, 985 ,10 ,255);
    fps_rezistor = map(analogRead(fps_rezistor_pin), 0, 985 ,5 ,255);

 

прописать:

bright_rezistor = 255;
    fps_rezistor = 100;

это яркость и скорость. 

И да - какой чип у ленты?

Serzh
Offline
Зарегистрирован: 31.12.2016

 

[/quote]

 У вас какой чип в грилянде?

[/quote]

не знаю вот такую покупл проводками соединил https://ru.aliexpress.com/item/100x-WS2812B-LED-With-Heatsink-10mm-3mm-DC5V-5050-SMD-RGB-WS2811-IC-Built-in/32378187271.html?spm=2114.13010608.0.0.9JmtAY

Focus
Offline
Зарегистрирован: 05.04.2015

заменяйте это #define LED_TYPE WS2811

на это #define LED_TYPE WS2812B

хотя не понятно что там за чип вроде как 2812B, а вроде как обычный ргб диод, а под ним 2811

В примере из библиотеки FastLED какой чип ставили? такой же и тут ставте. Ну и раз нет резисторов и кнопок - то замены сделайте, которые я выше привёл.

Serzh
Offline
Зарегистрирован: 31.12.2016

спасибо большое , что ответили на мой вопрос

все что посоветовали попробую и отпишусь чуть попозже 

уроки застовляют учить

Serzh
Offline
Зарегистрирован: 31.12.2016

УРА заработало УРА УРА !!!!!!!!!!!!!!!!!!!!!!!!!!

СПАСИБО ОГРОМНОЕ, ЧТО МОГЛИ НАСТРОИТЬ КОД

я заменил, как ВЫ посоветовали, 75 строчку 

current_effect = EEPROM.read(eeprom_addr); на

current_effect = 0;

и все заработало ОГРОМНОЕ СПАСИБО !!!

Serzh
Offline
Зарегистрирован: 31.12.2016

я придумал новый эфект, но вставить его в код не получаетя, помогите .

точне если я стираю ниже void horizont_3() и вставляю свой эфект то все работае.

и напишите какие строчки поменяли желательно с коментариями.

и еще один вопрос

  for (int i = 0; i < NUM_STRIPS; i++) {
    fadeToBlackBy( leds[i], NUM_LEDS, 40);
я так понимаю она перебирает по очереди линии и тушит светики плавно ТАК ? что означает цыфра 40 и как ее расчитать ?
 
Zuid - West()
{
  for (int i = 0; i < NUM_STRIPS; i++) {
    fadeToBlackBy( leds[i], NUM_LEDS, 400);
  }
  if (color_x < NUM_LEDS) color_x = 0;
  for (int x = 0; x < NUM_STRIPS; x++) {
    CRGB color[] = {CRGB(255, 0, 0), CRGB(0, 255, 0), CRGB(0, 0, 255),
                    CRGB(255, 255, 255), CRGB(255, 0, 255), CRGB(0, 255, 255),
                    CRGB(255, 255, 0), CRGB(255, 150, 150)
                   };
    if (y > NUM_LEDS ) y = 0;
    leds[x][y]  = color[color_x];
    leds[x][y + 1]  = color[color_x];
    leds[x][y + 2]  = color[color_x];
    y = y + 1 ;
    color_x = color_x + 1;
    delay(200);    
    FastLED.show();
    leds[x][y] = CRGB(0, 0, 0);
    leds[x][y + 1] = CRGB(0, 0, 0);
    leds[x][y + 2] = CRGB(0, 0, 0);
  }
}
 
 
[code]
void horizont_3()
 
[/code]

 

Serzh
Offline
Зарегистрирован: 31.12.2016
вот еще эффект получился из вашего неплохой

void circular() {
  for (int i = 0; i < NUM_STRIPS; i++) {

    fadeToBlackBy( leds[i], NUM_LEDS, 100);
  }
  if (pos1 > NUM_LEDS - 1) {
    pos1 = 0;
    color_x = color_x + 1;
  }
  if (color_x > 3) color_x = 0;
  CRGB color[] = {CRGB(255, 0, 0), CRGB(0, 255, 0), CRGB(0, 0, 255), CRGB(255, 255, 255),
                  CRGB(255, 0, 255), CRGB(0, 255, 255), CRGB(255, 255, 0), CRGB(255, 150, 150)
                 };
  for (int i = 0; i <= NUM_STRIPS - 1; i++) {

    leds[i][pos1] = color[color_x];

    delay(60);
    FastLED.show();

  }
  pos1 = pos1 + 1;
}

 

 
      
Focus
Offline
Зарегистрирован: 05.04.2015

Чтоб добавить эффект:

1. добавляем свой эффект гденибудь внизу void circular() {...}

2. найти 

if(current_effect > 9){      // Если номер эффекта превышает существующее
    current_effect = 0;        // то отсчет начинается с нуля
}

и поменять 9 на 10 (ну или 11 или 12, в зависимости сколько у вас эффектов)

3. найти этот код 

 if(current_effect == 0){
    EVERY_N_SECONDS( 10 ) { nextPattern(); } // change patterns periodically
    gPatterns[gCurrentPatternNumber]();
  }
  if(current_effect == 1){
    rainbow();
  }
  if(current_effect == 2){
    rainbowWithGlitter();
  }
  if(current_effect == 3){
    confetti();
  }
  if(current_effect == 4){
    sinelon();
  }
  if(current_effect == 5){
    juggle();
  }
  if(current_effect == 6){
    bpm();
  }
  if(current_effect == 7){
    horizont_2();
  }
  if(current_effect == 8){
    snow_1();
  }
  if(current_effect == 9){
    snow_2();
  }

И добавить туда свой эффект (эффекты)

if(current_effect == 10){
  circular();
}
//все последующие если есть
if(current_effect == 11){
  moy_super_effect_2();
}
if(current_effect == 12){
  moy_super_effect_3();
}

Вроде ничего не забыл.

Focus
Offline
Зарегистрирован: 05.04.2015
for (int i = 0; i < NUM_STRIPS; i++) {
  fadeToBlackBy( leds[i], NUM_LEDS, 400);
}

Да, затухание. меняя цифру - затухать будет за меньшее количество "кадров" или за большее. Как расчитать? Методом тыка! :D Ну я лично так делал )

Serzh
Offline
Зарегистрирован: 31.12.2016

окЕЙ воткнул за мигали !!!!!!!!! Спасибо большое!!

про затухание примерно так и думал.

сейчас делаю другой эффект нужен счетчик который досчила бы до 8 и обнулился

и снова считал как в бейсике я нашeл For i=0 To 8 Step 1   а ардуине не найду

подскажите

Focus
Offline
Зарегистрирован: 05.04.2015

mmm... Basic, Spectrum - ностальгия ))

Дык вот выше, где я про затухание писал и есть цикл

for (int i = 0; i <= 8; i++) {
  ...
}

про циклы читат тут

Serzh
Offline
Зарегистрирован: 31.12.2016

ну ни как нехотят светики бежать в сторону правильно 

посмотрите пожалуста опытным глазом, где ошибка, куда копать, в какую сторону глядеть???

void Zuid_West()() {

  for (int pos1 = 0; pos1 < NUM_STRIPS - 1;   ) {

    for (int x = pos1; x < NUM_STRIPS - 1; ) {

      for (int y = 0; y < NUM_LEDS; ) {

        leds[x ][y]  = CRGB(150, 40, 150);
        FastLED.show();
        leds[x ][y]  = CRGB(0, 0, 0);

        delay(700);
        y = y + 1;
        x = x + 1;
      }
      y = 0;    
    }
    x = 0;
    pos1 = pos1 + 1;
  }
  pos1 = 0;
}

 

Focus
Offline
Зарегистрирован: 05.04.2015

Serzh пишет:

void Zuid_West()() 

Может так: void Zuid_West(. (. ) :D

А по делу...

Цикл всего эффекта не должен выполняться за одно выполнение функции, за одно выполнение функции должен рисоваться всего 1 кадр. Следующее выполнение функции должно рисовать следующий кадр и т.д.

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

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

И delay() в функции эффекта использовать нельзя, для этого (вне функции эффекта) есть FastLED.delay(1000/fps_rezistor); Если без резистора, то просто указывается FastLED.delay(700) например.

Serzh
Offline
Зарегистрирован: 31.12.2016
  вот так правильно за один проход функции рисуется 1 кадр 
в аурдине не чего не изменилось оин светик x0y0=0, x1e1=1 x2y2=2 ....x7e7=7 и опять x0y0=0



void Zuid_West() {
for (int pos1 = 0; pos1 > NUM_STRIPS - 1;   ) {

    pos1 = 0;
  }
  for (int x = pos1; x > NUM_STRIPS - 1; ) {
    x = 0;
    pos1 = pos1 + 1;
  }
  for (int y = 0; y > NUM_LEDS; ) {
    y = 0;
  }
  leds[x ][y]  = CRGB(150, 40, 150);
  FastLED.delay(700);
  leds[x ][y]  = CRGB(0, 0, 0);
  y = y + 1;
  x = x + 1;
}

 

Focus
Offline
Зарегистрирован: 05.04.2015

это что то вообще страшное, даже не скомпилируется наверно. в отдельном скетче опробуйте свои цыклы с выводом в сериал например.

вот например первый цикл что делает: будет крутиться, пока pos1 не станет больше NUM_STRIPS - 1.

к самой pos1 мы ничего не добавляем не убавляем, а только записываем в неё ноль в теле цикла, значит pos1 никогда не станет больше NUM_STRIPS - 1

тут я показал пример цикла for http://arduino.ru/forum/proekty/elochnaya-girlyanda-iz-ws2811-i-staryi-bp-ot-kompa#comment-256417

там задаётся +1 к переменной цикла.

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

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

Serzh
Offline
Зарегистрирован: 31.12.2016

а почему вы взяли за основу именно эту библидтеку 

в этой Adafruit_NeoPixel красивее эффекты

//***********************************************************************
//***********************************************************************
#include <Adafruit_NeoPixel.h>
#ifdef __AVR__
#include <avr/power.h>
#endif
#define PIN 6
#define PixNum 6 //количество пикселей в ленте
Adafruit_NeoPixel strip = Adafruit_NeoPixel(6, PIN, NEO_RGB + NEO_KHZ800);
//***********************************************************************
//***********************************************************************
void setup() 
{
  Serial.begin(9600);
  strip.setBrightness(255);
  strip.begin();
  strip.show(); // Initialize all pixels to 'off'
  randomSeed(analogRead(0));
}
//***********************************************************************
//***********************************************************************
void loop() 
{
    //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    //++++++++++++++++++ Перебор эффектов в разных сочетаниях с разными цветами и временем выполнения +++++++++++++++++++++++++++++++++++++++++++++++
    //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    FvdFillPixels(50, 0, 0, 0); OncomingPixels(90, 200, 80, 0, 200, 80, 0); FvdRunOnePixel(20, 200, 80, 0); RevRunOnePixel(20, 200, 80, 0); 
    FvdRunOnePixel(25, 0, 255, 0); RevRunOnePixel(30, 0, 255, 0); FvdRunOnePixel(25, 0, 0, 255); RevRunOnePixel(30, 0, 0, 255); 
    RevFillPixels(100, 225, 100, 0); BlinkAllPix(15, 15, 15, 100, 225, 0, 255, 0, 0); delay(200); FvdTurnOffAllPix(3,2); 
    FvdFillPixels(100, 225, 100, 0); RevTurnOffAllPix(3,2); RevRunMixPixel(50, 200, 20, 30); FvdRunMixPixel(50, 30, 20, 70);
    FvdFillPixels(50, 55, 55, 55); FvdRunOnePixel(35, 255, 0, 0);  RevRunOnePixel(40, 255, 0, 0);  RevFillPixels(50, 55, 10, 10);
    FvdRunOnePixel(35, 0, 255, 0); RevRunOnePixel(40, 0, 255, 0); RevFillPixels(50, 10, 55, 10); FvdRunOnePixel(35, 0, 0, 255);
    RevRunOnePixel(40, 0, 0, 255); RevFillPixels(50, 10, 10, 55); FvdRunOnePixel(35, 255, 0, 0); RevRunOnePixel(40, 255, 0, 0); 
    RevFillPixels(50, 0, 0, 0); RevRunOnePixel(25, 255, 165, 0); FvdRunOnePixel(30, 255, 165, 0); RevRunOnePixel(25, 255, 165, 0); 
    FvdRunOnePixel(30, 100, 255, 0); RevRunOnePixel(25, 100, 0, 255); FvdRunOnePixel(30, 100, 0, 255); RevFillPixels(100, 200, 30, 0);
    FvdTurnOffAllPix(3,2); FvdFillPixels(100, 200, 30, 0); RevTurnOffAllPix(3,2); RevRunMixPixel(50, 20, 80, 50); 
    FvdRunMixPixel(50, 40, 50, 100); RevFillPixels(50, 25, 75, 15); RevRunOnePixel(35, 255, 0, 0); FvdRunOnePixel(40, 255, 0, 0);
    FvdFillPixels(50, 15, 70, 90); RevRunOnePixel(35, 0, 255, 0); FvdRunOnePixel(40, 0, 255, 0); FvdFillPixels(50, 40, 155, 10);
    RevRunOnePixel(35, 0, 0, 255); FvdRunOnePixel(40, 0, 0, 255); FvdFillPixels(50, 200, 20, 0); BlinkAllPix(15, 15, 15, 200, 40, 0, 0, 0, 0); 
    RevRunOnePixel(35, 200, 20, 0); FvdRunOnePixel(40, 200, 20, 0); RevFillPixels(70, 225, 100, 0); BlinkAllPix(15, 15, 15, 225, 100, 0, 0, 0, 0); 
    FvdTurnOffAllPix(3,2); FvdFillPixels(70, 225, 100, 0); RevTurnOffAllPix(3,2); RevRunMixPixel(50, 200, 20, 60); FvdRunMixPixel(50, 80, 120, 60);
    //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    FvdRunMixPixel(20,255,255,255); delay(100); FvdTurnOffAllPix(40,2); RevRunMixPixel(20,255,255,255); delay(100); RevTurnOffAllPix(40,2);
    RevRiseAllPixel(30,2,255,255,255); BlinkAllPix(15, 15, 15, 255, 255, 255, 0, 0, 0); FvdShadowAllPixel(15, 1, 255, 255, 255);
    RevFillPixels(1, 0, 0, 255); OncomingPixels(100, 255, 0, 0, 0, 255, 0); FvdFillPixels(40,0,255,0); FvdTurnOffAllPix(40,2);
    RevFillPixels(40,0,100,255); OncomingPixels(100, 255, 0, 0, 0, 255, 0); RevFillPixels(40,255,0,0); FvdTurnOffAllPix(40,2);
    OncomingPixels(100, 0, 255, 0, 255, 0, 0); RevFillPixels(40,0,255,0); FvdTurnOffAllPix(40,2); FvdRunOnePixel(40,0,255,0);
    RevRunOnePixel(40,0,255,0); FvdFillPixels(40, 0, 255, 0); BlinkAllPix(15, 15, 15, 0, 255, 0, 0, 0, 0); 
    FvdShadowAllPixel(15, 1, 0, 255, 0); RevRiseAllPixel(30,2,0,0,255); BlinkAllPix(15, 15, 15, 0, 0, 255, 0, 0, 0); delay(200);
    //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

  //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  //++++++++++++++++ Все функции и параметры ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  //FvdShadowAllPixel(0,0,0,0,0);            //Плавное гашение всех пикселей (задержка, шаг гашения, отдельные цвета R,G,B каждого из 3 пикселей )
  //RevRiseAllPixel(0,0,0,0,0);              //Плавное включение всех пикселей (задержка, шаг включения, отдельные цвета R,G,B каждого из 3 пикселей )
  //RevFillPixels(0,0,0,0);                  //Заполнение пикселей выбранным цветом в обратном направлении (задержка, цвет R,G,B каждого пикселя)
  //FvdFillPixels(0,0,0,0);                  //Заполнение пикселей выбранным цветом в обратном направлении (задержка, цвет R,G,B каждого пикселя)
  //FvdRunOnePixel(0,0,0,0);                 //Один бегущий пиксель в прямом направлении (задержка,цвет R,G,B перемещаемого пикселя)
  //RevRunOnePixel(0,0,0,0);                 //Один бегущий пиксель в обратном направлении (задержка, цвет R,G,B перемещаемого пикселя)
  //FvdTurnOffAllPix(0,0);                   //Плавное гашение пикселей по очереди в прямом направлении (задержка, шаг гашения)
  //RevTurnOffAllPix(0,0);                   //Плавное гашение пикселей по очереди в обратном направлении (задержка, шаг гашения)
  //FvdRunMixPixel(0,0,0,0);                 //Заполнение ленты цветными пикселями выбранных цветов в прямом направлении (задержка, отдельные цвета R,G,B каждого из 3 пикселей)
  //RevRunMixPixel(0,0,0,0);                 //Заполнение ленты цветными пикселями выбранных цветов в прямом направлении (задержка, отдельные цвета R,G,B каждого из 3 пикселей)
  //BlinkAllPix(0,0,0,0,0,0,0,0,0);          //Мерцание всех пикселей(длительность мерцания, время отключения, время свечения, цвет свечения R,G,B каждого пикселя, цвет мерцания R,G,B каждого пикселя)  
  //OncomingPixels(0,0,0,0,0,0,0);           //Два бегущих пикселя во встречном направлении (задержка,цвет R,G,B перемещаемого пикселя)
  //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
}         
//***********************************************************************

//***********************************************************************
void RevRunOnePixel(uint8_t pause, byte r, byte g, byte b)
       {
         uint8_t curr_r, curr_g, curr_b;
         uint16_t j;
         long i;
         for(j=0; j<PixNum+1; j++)
           {
              strip.setPixelColor(j-1, curr_r, curr_g, curr_b);
              //--------------------------------------- 
               i = strip.getPixelColor(j);
               curr_r = (uint8_t)((i >> 16) & 0xff),
               curr_g = (uint8_t)((i >> 8) & 0xff),
               curr_b = (uint8_t)(i & 0xff);
               strip.setPixelColor(j, r, g, b);
             //--------------------------------------- 
               strip.show();
               if(j==PixNum-1)
               strip.setPixelColor(j, curr_r, curr_g, curr_b);
               delay(pause);
               strip.show();
               delay(pause);
           }
      }
//***********************************************************************

//***********************************************************************
void FvdRunOnePixel(uint8_t pause, byte r, byte g, byte b)
       {
         uint8_t curr_r=0, curr_g=0, curr_b=0;
         uint16_t j;
         long i;
         for(j=PixNum; j>0; j--)
           {
              strip.setPixelColor(j, curr_r, curr_g, curr_b);
              //--------------------------------------- 
               i = strip.getPixelColor(j-1);
               curr_r = (uint8_t)((i >> 16) & 0xff),
               curr_g = (uint8_t)((i >> 8) & 0xff),
               curr_b = (uint8_t)(i & 0xff);
               strip.setPixelColor(j-1, r, g, b);
             //--------------------------------------- 
               strip.show();
               if(j==1)
               strip.setPixelColor(j-1, curr_r, curr_g, curr_b);
               delay(pause);
               strip.show();
               delay(pause);
           }
      }
//***********************************************************************

//***********************************************************************
void OncomingPixels(uint16_t pause, uint8_t R_fvd, uint8_t G_fvd, uint8_t B_fvd, uint8_t R_rev, uint8_t G_rev, uint8_t B_rev)
  {
         uint8_t curr_R_fvd=0, curr_G_fvd=0, curr_B_fvd=0;
         uint8_t curr_R_rev=0, curr_G_rev=0, curr_B_rev=0;
         uint16_t j,k=0;
         k=PixNum;
         long i;
         for(j=0; j<PixNum; j++, k--)
           {
              strip.setPixelColor(j-1, curr_R_fvd, curr_G_fvd, curr_B_fvd);
              strip.setPixelColor(k, curr_R_rev, curr_R_rev, curr_B_rev);
              //--------------------------------------- 
               i = strip.getPixelColor(j);
               curr_R_fvd = (uint8_t)((i >> 16) & 0xff),
               curr_G_fvd = (uint8_t)((i >> 8) & 0xff),
               curr_B_fvd = (uint8_t)(i & 0xff);
             //--------------------------------------- 
               i = strip.getPixelColor(k-1);
               curr_R_rev = (uint8_t)((i >> 16) & 0xff),
               curr_G_rev = (uint8_t)((i >> 8) & 0xff),
               curr_B_rev = (uint8_t)(i & 0xff);
               strip.setPixelColor(k-1, R_rev, G_rev, B_rev);
               strip.setPixelColor(j, R_fvd, G_fvd, B_fvd);
             //---------------------------------------             
              if(j==PixNum-1)strip.setPixelColor(j-1, curr_R_fvd, curr_G_fvd, curr_B_fvd);
              if(k==1)       strip.setPixelColor(k, curr_R_rev, curr_G_rev, curr_B_rev);
              strip.show();
              delay(pause);
           }
  }
//***********************************************************************

//***********************************************************************
void BlinkAllPix(uint16_t cycle, uint8_t StripOn, uint8_t StripOff, uint8_t R_on, uint8_t G_on, uint8_t B_on, uint8_t R_off, uint8_t G_off, uint8_t B_off)
  {
    uint16_t j, k;                                       //счетчики
    for(cycle; cycle>0; cycle--)                         //количество повторений
     {
       for(j=PixNum; j>0; j--)strip.setPixelColor(j-1, R_on, G_on, B_on);    //светим
          strip.show();                                 
          delay(StripOn); //задержка свечения
       for(j=PixNum; j>0; j--)strip.setPixelColor(j-1, R_off, G_off, B_off); //гасим
          strip.show();
          delay(StripOff); //задержка до включения
     }
          for(j=PixNum; j>0; j--)strip.setPixelColor(j-1, R_on, G_on, B_on); //выходим с включенными пикселями
          strip.show();
  }
//***********************************************************************

//***********************************************************************
void FvdShadowAllPixel(uint8_t pause, uint8_t StepOff, uint8_t r, uint8_t g, uint8_t b)
  {
         float coeff_R, coeff_G, coeff_B, m;
         uint16_t j, k;                          // счетчики
         float cr, cg, cb;                       // устанавливаемые цвета на ленте в цикле 
         m = max(r, g);                          // Самый яркий цвет (бОльшее значение из r, g, b)
         m = max(m, b);                    
         coeff_R = StepOff/m*r;                  // Значения шагов уменьшения каждого цвета в пикселе
         coeff_G = StepOff/m*g;
         coeff_B = StepOff/m*b;
         for(j=PixNum; j>0; j--)
          {
            strip.setPixelColor(j-1, r, g, b);
          }   
          strip.show();
          cr=r; cg=g; cb=b;
         for(k=(m/StepOff/PixNum)+2; k>0; k--)   //Внешний цикл
          {
              for(j=PixNum; j>0; j--)            //Цикл для пикселей в ленте
               {  //Замена каждого цвета на округленную сумму текущего цвета и числа прибавления
                  if(cr-coeff_R>0)cr=(cr-coeff_R); 
                  if(cg-coeff_G>0)cg=(cg-coeff_G);
                  if(cb-coeff_B>0)cb=(cb-coeff_B);
                  strip.setPixelColor(j-1, cr, cg, cb);
                  strip.show();
               }
                 delay(pause);                   //Плавность
                 if(k==2)
                 {
                  cr=0; cg=0; cb=0;
                 }
          }        
  }

//***********************************************************************

//***********************************************************************
void RevRiseAllPixel(uint8_t pause, uint8_t StepOn, uint8_t r, uint8_t g, uint8_t b)
  {
         float coeff_R, coeff_G, coeff_B, m;    // Значения шагов увеличения каждого цвета в пикселе 
         uint16_t j, k;                         // счетчики
         
         float cr, cg, cb;                      // устанавливаемые цвета на ленте в цикле 
         m = max(r, g);                         // Самый яркий цвет (бОльшее значение из r, g, b)
         m = max(m, b);                    
         coeff_R = StepOn/m*r;
         coeff_G = StepOn/m*g;
         coeff_B = StepOn/m*b;
         for(k=(m/StepOn/PixNum)+1; k>0; k--)   //Внешний цикл
          {
              for(j=PixNum; j>0; j--)           //Цикл для пикселей в ленте
               {  //Замена каждого цвета на округленную сумму текущего цвета и числа прибавления
                  if(r!=0 and ceil(coeff_R+cr)<r)cr=ceil(cr+coeff_R); 
                  if(g!=0 and ceil(coeff_G+cg)<g)cg=ceil(cg+coeff_G);
                  if(b!=0 and ceil(coeff_B+cb)<b)cb=ceil(cb+coeff_B);
                  strip.setPixelColor(j-1, cr, cg, cb);
                  strip.show();
              }
              delay(pause);                     //Плавность
          }        
  }
//***********************************************************************

//***********************************************************************
void RevFillPixels(uint16_t pause, byte r, byte g, byte b)
{
  uint16_t j;
  for(j=PixNum; j>0; j--)
     {
       strip.setPixelColor(j-1, r, g, b);
       strip.show();
       delay(pause);
     }
       delay(pause);  
}
//***********************************************************************

//***********************************************************************
void FvdFillPixels(uint16_t pause, byte r, byte g, byte b)
{
  uint16_t j;
  for(j=0; j<PixNum; j++)
     {
       strip.setPixelColor(j, r, g, b);
       strip.show();
       delay(pause);
     }
       delay(pause);  
}
//***********************************************************************

//***********************************************************************
void FvdRunMixPixel(uint8_t pause, byte fst, byte scd, byte th) 
         {
           uint16_t i, j, k, n;
           i=fst; k=0; n=0;          
           for(j=PixNum; j>0; j--)
            {
              strip.setPixelColor(j-1, i, k, n);
              if(i==fst)
                {
                  i=0; k=scd; n=0;
                } 
              else if(k==scd)
                {
                  i=0; k=0; n=th;
                }
              else if(n==th)
                {
                 i=fst; k=0; n=0;
                }
            strip.show();
            delay(pause);
            }
            delay(pause);
         }
//***********************************************************************

//***********************************************************************
void RevRunMixPixel(uint8_t pause, byte fst, byte scd, byte th) 
         {
           uint16_t i, j, k, n;
           i=fst; k=0; n=0;          
           for(j=0; j<PixNum; j++)
            {
              strip.setPixelColor(j, i, k, n);
              if(i==fst)
                {
                  i=0; k=scd; n=0;
                } 
              else if(k==scd)
                {
                  i=0; k=0; n=th;
                }
              else if(n==th)
                {
                 i=fst; k=0; n=0;
                }
            strip.show();
            delay(pause);
            }
            delay(pause);
         }
//***********************************************************************

//***********************************************************************
void FvdTurnOffAllPix(uint8_t pause, uint32_t StepOff)
       {
         uint8_t r, g, b;
         uint16_t j;
         uint8_t gradat;
         long i;
         for(j=PixNum; j>0; j--)
           {
               long i = strip.getPixelColor(j-1); 
               r = (uint8_t)((i >> 16) & 0xff),
               g = (uint8_t)((i >> 8) & 0xff),
               b = (uint8_t)(i & 0xff);
               gradat = 255/StepOff+1;
            for(gradat; gradat>0; gradat--)
              {
                  if(r>=StepOff)
                   r=r-StepOff;
                  else r-=r;
                  if(g>=StepOff)
                   g=g-StepOff;
                  else g-=g;
                  if(b>=StepOff)
                   b=b-StepOff;
                  else b-=b;                  
               strip.setPixelColor(j-1, r, g, b);
               strip.show();
              }
            delay(pause);
           }
       }            
//***********************************************************************

//***********************************************************************
void RevTurnOffAllPix(uint8_t pause, uint32_t StepOff)
       {
         uint8_t r, g, b;
         uint16_t j;
         uint8_t gradat;
         long i;
         for(j=0; j<PixNum; j++)
           {
               long i = strip.getPixelColor(j); 
               r = (uint8_t)((i >> 16) & 0xff),
               g = (uint8_t)((i >> 8) & 0xff),
               b = (uint8_t)(i & 0xff);
               gradat = 255/StepOff+1;
            for(gradat; gradat>0; gradat--)
              {
                  if(r>=StepOff)
                   r=r-StepOff;
                  else r-=r;
                  if(g>=StepOff)
                   g=g-StepOff;
                  else g-=g;
                  if(b>=StepOff)
                   b=b-StepOff;
                  else b-=b;                  
               strip.setPixelColor(j, r, g, b);
               strip.show();
              }
               delay(pause);
           }
       }   
//***********************************************************************

//***********************************************************************


 

Focus
Offline
Зарегистрирован: 05.04.2015

Что то мне в ней не понравилось. Толи весит много и не остаётся места для фантазии :) Толи конфликтует с RemoteXY, толи ещё чего - не помню.

Logik
Offline
Зарегистрирован: 05.08.2014

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

arduinec
Offline
Зарегистрирован: 01.09.2015

Logik пишет:

Удаленное уаравление тяжело совмещать с ws281х, особенно на длинных лентах.

Для вывода на ленту с 500 диодами требуется 15 мс. С кнопками при этом управление получается, а вот сигналы с пультов могут быть пропущены.

Logik
Offline
Зарегистрирован: 05.08.2014

Именно так. Даже для 30 диодов на ленте уже проблема. У ИК длителность бита порядка 1мсек. Я делаю так - как можна чаще мониторю состояние приемника, и если обнаружу активность - забиваю на ленту и принимаю ИК.  Работает, но есть забавное побочное - при нажатии на чужом пульте, например ТВ, лента замирает на мгновение, прислушмвается не к ей ли это :)

Serzh
Offline
Зарегистрирован: 31.12.2016

если я на один выход ардуино повешу все 8 лент это плохо , он сгорит?

Focus
Offline
Зарегистрирован: 05.04.2015

нет, но эффекты все надо будет переделывать, совсем переделывать )

Serzh
Offline
Зарегистрирован: 31.12.2016

я имел ввиду код в ардуино записать который привел выше с этой библиотекой Adafruit_NeoPixel 

значит ничего страшного с pin 6 неслучится?

Andrei24
Offline
Зарегистрирован: 03.08.2017

Мне понравился ваш скетч приведенный для примера!Подскажите как его закольцевать чтобы он повторялся бесконечно(я в программировнии не силен только учусь)

petronic
Offline
Зарегистрирован: 15.04.2019

Добрый день, а моно на основе Вашего проекта сделать просто гирлянду одну нв 100-300 светодиодов типа гирлянды ws2812 в наличии имею 4 гирлянды по 50 штук светодиодов в гирлянде на гибких проводах тип гирлянды приведён ниже

Светодиодный WS 2812B чип модуль 50 шт./лот предварительно спаяны WS2812B радиатор 5 В 5050 RGB WS2811 IC встроенный IC и 12 см подключения провода адресный

попробовал запустить от пи№5 на ардуино уно- пошла работа и изменил некоторые значения

 

#define NUM_LEDS    25 поставил 100
#define NUM_STRIPS  8  поставил 1


#define BRIGHTNESS         150  // Стартовое значение яркости поставил 255

извиняюсь за такое самовольство, но просто решил попробовать и надеюсь на Вашу помощь...

 

 

nupaT
Offline
Зарегистрирован: 09.05.2019

Привет форумчане.

Не буду выкидывать весь код, но вопрос по эффектам такой:

Переключение происходит так

switch(var){    // var меняется по нажатию кнопки

case 1: LED1(); break;

...

}

сам эффект такой

void LED1() // последовательное заполнение цветом всей ленты и затем выключение в обратном порядке
{
  for(int i = 0; i < LED_NUM; i++)  // NUM_LED кол-во пикселей в ленте
  {
    pixel.setPixelColor(i, 250, 0, 0);

    pixel.show();
  }
 
  for(int i = LED_NUM; i < 0; i--)
  {
    pixel.setPixelColor(i, 0, 0, 0);

    pixel.show();
  }

}

так вот переключение эффекта на следующий работает только по окончании предыдущего т.е. пока функция LED1() не дойдет до конца (все диоды выкл) var не увеличивается.

Тут же в теме прочитал что за одно выполнение цикла эффекта должен рисоваться один кадр. Вроде так и происходит.

Дайте совет в какую сторону курить?