режимы свечения WS2812b

Djudav · 12 Ноя 2021

Доброго дня!
Прошу подсказать как сделать еще один режим свечения на адресной ленте, нажимая кнопку. То есть я объединил два скетча разных, использующих общую библиотеку, но в первой части более сложная схема (Оекан) смены свечения светодиодов, а в остальных простые "радуги" и т.д. Отдельно "Ocean" и схемы "радуг" работают вполне сносно. И даже вроде бы получилось в один скетч все объединить, но вот сделать так, что бы после режима "океан" менялся на следующий режим- встал в ступор... Спасибо, если подскажите как правильно и где организовать это.
Сам код:

C++:

#define FASTLED_ALLOW_INTERRUPTS 0
#include <FastLED.h>
FASTLED_USING_NAMESPACE

#define DATA_PIN            4
#define NUM_LEDS            220
#define MAX_POWER_MILLIAMPS 500
#define LED_TYPE            WS2812B
#define COLOR_ORDER         GRB

byte bright = 180; // яркость светодиодов
byte rate = 0;       // скорость эффектов
byte w = 1;          // переключение режимов
byte baza = 0;     // изменение оттенка


boolean button3WasUp = true;
//////////////////////////////////////////////////////////////////////////

CRGB leds[NUM_LEDS];

void setup() {
  delay( 1000); // 1 second delay for boot recovery, and a moment of silence
  FastLED.addLeds<LED_TYPE,DATA_PIN,COLOR_ORDER>(leds, NUM_LEDS)
        .setCorrection( TypicalLEDStrip );
  FastLED.setMaxPowerInVoltsAndMilliamps( 5, MAX_POWER_MILLIAMPS);
}

void knopka () {

  boolean button3IsUp = digitalRead(12);


  // если кнопка 3 была нажата, переходим в новый режим
  if (button3WasUp && !button3IsUp) {
    delay(10);
    button3IsUp = digitalRead(12);
    if (!button3IsUp) { w++; if (w > 7) { w = 1; }
    }
  }
  button3WasUp = button3IsUp; // запоминаем состояние кнопки 3
}

void loop()
{
  EVERY_N_MILLISECONDS( 20) {
    pacifica_loop();
    FastLED.show();
  }
}

//////////////////////////////////////////////////////////////////////////
//
// The code for this animation is more complicated than other examples, and
// while it is "ready to run", and documented in general, it is probably not
// the best starting point for learning.  Nevertheless, it does illustrate some
// useful techniques.
//
//////////////////////////////////////////////////////////////////////////
//
// In this animation, there are four "layers" of waves of light. 
//
// Each layer moves independently, and each is scaled separately.

CRGBPalette16 pacifica_palette_1 =
    { 0x000507, 0x000409, 0x00030B, 0x00030D, 0x000210, 0x000212, 0x000114, 0x000117,
      0x000019, 0x00001C, 0x000026, 0x000031, 0x00003B, 0x000046, 0x14554B, 0x28AA50 };
CRGBPalette16 pacifica_palette_2 =
    { 0x000507, 0x000409, 0x00030B, 0x00030D, 0x000210, 0x000212, 0x000114, 0x000117,
      0x000019, 0x00001C, 0x000026, 0x000031, 0x00003B, 0x000046, 0x0C5F52, 0x19BE5F };
CRGBPalette16 pacifica_palette_3 =
    { 0x000208, 0x00030E, 0x000514, 0x00061A, 0x000820, 0x000927, 0x000B2D, 0x000C33,
      0x000E39, 0x001040, 0x001450, 0x001860, 0x001C70, 0x002080, 0x1040BF, 0x2060FF };

    
void pacifica_loop()
{

  // Increment the four "color index start" counters, one for each wave layer.
  // Each is incremented at a different speed, and the speeds vary over time.
  static uint16_t sCIStart1, sCIStart2, sCIStart3, sCIStart4;
  static uint32_t sLastms = 0;
  uint32_t ms = GET_MILLIS();
  uint32_t deltams = ms - sLastms;
  sLastms = ms;
  uint16_t speedfactor1 = beatsin16(3, 179, 269);
  uint16_t speedfactor2 = beatsin16(4, 179, 269);
  uint32_t deltams1 = (deltams * speedfactor1) / 256;
  uint32_t deltams2 = (deltams * speedfactor2) / 256;
  uint32_t deltams21 = (deltams1 + deltams2) / 2;
  sCIStart1 += (deltams1 * beatsin88(1011,10,13));
  sCIStart2 -= (deltams21 * beatsin88(777,8,11));
  sCIStart3 -= (deltams1 * beatsin88(501,5,7));
  sCIStart4 -= (deltams2 * beatsin88(257,4,6));

  // Clear out the LED array to a dim background blue-green
  fill_solid( leds, NUM_LEDS, CRGB( 2, 6, 10));

  // Render each of four layers, with different scales and speeds, that vary over time
  pacifica_one_layer( pacifica_palette_1, sCIStart1, beatsin16( 3, 11 * 256, 14 * 256), beatsin8( 10, 70, 130), 0-beat16( 301) );
  pacifica_one_layer( pacifica_palette_2, sCIStart2, beatsin16( 4,  6 * 256,  9 * 256), beatsin8( 17, 40,  80), beat16( 401) );
  pacifica_one_layer( pacifica_palette_3, sCIStart3, 6 * 256, beatsin8( 9, 10,38), 0-beat16(503));
  pacifica_one_layer( pacifica_palette_3, sCIStart4, 5 * 256, beatsin8( 8, 10,28), beat16(601));

  // Add brighter 'whitecaps' where the waves lines up more
  pacifica_add_whitecaps();

  // Deepen the blues and greens a bit
  pacifica_deepen_colors();
}

// Add one layer of waves into the led array
void pacifica_one_layer( CRGBPalette16& p, uint16_t cistart, uint16_t wavescale, uint8_t bri, uint16_t ioff)
{
  uint16_t ci = cistart;
  uint16_t waveangle = ioff;
  uint16_t wavescale_half = (wavescale / 2) + 20;
  for( uint16_t i = 0; i < NUM_LEDS; i++) {
    waveangle += 250;
    uint16_t s16 = sin16( waveangle ) + 32768;
    uint16_t cs = scale16( s16 , wavescale_half ) + wavescale_half;
    ci += cs;
    uint16_t sindex16 = sin16( ci) + 32768;
    uint8_t sindex8 = scale16( sindex16, 240);
    CRGB c = ColorFromPalette( p, sindex8, bri, LINEARBLEND);
    leds[i] += c;
  }
}

// Add extra 'white' to areas where the four layers of light have lined up brightly
void pacifica_add_whitecaps()
{
  uint8_t basethreshold = beatsin8( 9, 55, 65);
  uint8_t wave = beat8( 7 );
 
  for( uint16_t i = 0; i < NUM_LEDS; i++) {
    uint8_t threshold = scale8( sin8( wave), 20) + basethreshold;
    wave += 7;
    uint8_t l = leds[i].getAverageLight();
    if( l > threshold) {
      uint8_t overage = l - threshold;
      uint8_t overage2 = qadd8( overage, overage);
      leds[i] += CRGB( overage, overage2, qadd8( overage2, overage2));
    }
  }
}

// Deepen the blues and greens
void pacifica_deepen_colors()
{
  for( uint16_t i = 0; i < NUM_LEDS; i++) {
    leds[i].blue = scale8( leds[i].blue,  145);
    leds[i].green= scale8( leds[i].green, 200);
    leds[i] |= CRGB( 2, 5, 7);
  }
  ///////////////////////////////////////////////////////////////////////
 
  // режимы свечения ленты
  // первый режим (радуга)
  while (w == 2) {
    knopka(); // узнаем состояние кнопок
    for (int i = 0; i < NUM_LEDS; i++) {
      leds[i] = CHSV(baza+ i * 5, 255, 255);
    }
    baza++;
    FastLED.setBrightness(bright);
    FastLED.show();
    delay(50 - rate);
  }

  // второй режим (палитра)
  while (w == 3) {
    knopka(); // узнаем состояние кнопок
    static uint8_t starthue = 0;
    fill_rainbow( leds + 5, NUM_LEDS - 5, --starthue, rate);
    uint8_t secs = (millis() / 1000) % (rate * 2);
    if (secs < rate) { FastLED.setTemperature( Tungsten100W ); leds[0] = Tungsten100W; }
    else { FastLED.setTemperature( OvercastSky ); leds[0] = OvercastSky; }
    FastLED.setBrightness(bright);
    FastLED.show();
  }

  // третий режим (конфетти)
  while (w == 4) {
    knopka(); // узнаем состояние кнопок
    fadeToBlackBy(leds, NUM_LEDS, (rate + 1) * 2);
    int pos = random16(NUM_LEDS);
    leds[pos] += CHSV(baza++ + random8(64), 200, 255);
    FastLED.setBrightness(bright);
    FastLED.show();
  }

  // четвертый режим (бегущий огонек)
  while (w == 5) {
    knopka(); // узнаем состояние кнопок
    fadeToBlackBy(leds, NUM_LEDS, (rate + 1) * 2);
    int pos = beatsin16(13, 0, NUM_LEDS - 1);
    leds[pos] += CHSV(baza++, 255, 192);
    FastLED.setBrightness(bright);
    FastLED.show();
  }

  // пятый режим (циклон)
  while (w == 6) {
    for (int i = 0; i < NUM_LEDS; i++) {
      leds[i].nscale8(250);
      }
    for (int i = 0; i < NUM_LEDS; i++) {
      knopka(); // узнаем состояние кнопок
      leds[i] = CHSV(baza++, 255, 255);
      FastLED.setBrightness(bright);
      FastLED.show();
      delay(rate);
    }
  }

  // шестой режим (фокус)
  while (w == 7) {
    knopka(); // узнаем состояние кнопок
    fadeToBlackBy(leds, NUM_LEDS, (rate + 1) * 2);
    for (int i = 0; i < 8; i++) {
      leds[beatsin16(i + 7, 0, NUM_LEDS - 1)] |= CHSV(baza+=16, 200, 255);
    }
    FastLED.setBrightness(bright);
    FastLED.show();
    delay(10);
  }

  // седьмой режим (радуга с мерцанием)
  while (w == 8) {
    knopka(); // узнаем состояние кнопок
    fill_rainbow( leds, NUM_LEDS, baza++, 7);
    if (random8() < 80) { leds[ random16(NUM_LEDS) ] += CRGB::White; }
    FastLED.setBrightness(bright);
    FastLED.show();
    delay(50 - rate);
  }
}

Lumenjer · 12 Ноя 2021

@Djudav, я так понимаю, что циклы while (w == 2) это уже ваше?
Скиньте два рабочие по отдельности скетча

Djudav · 12 Ноя 2021

@Lumenjer,нет циклы были в скетче с "радугами", в "океане" нет циклов. В этом то и стоит задача- сделать "океан" еще одним режимом, который будет поочередно кнопкой меняться.

C++:

//Скетч "Океан"

//
//  "Pacifica"
//  Gentle, blue-green ocean waves.
//  December 2019, Mark Kriegsman and Mary Corey March.
//  For Dan.
//

#define FASTLED_ALLOW_INTERRUPTS 0
#include <FastLED.h>
FASTLED_USING_NAMESPACE

#define DATA_PIN            13
#define NUM_LEDS            60
#define MAX_POWER_MILLIAMPS 500
#define LED_TYPE            WS2812B
#define COLOR_ORDER         GRB

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

CRGB leds[NUM_LEDS];

void setup() {
  delay( 3000); // 3 second delay for boot recovery, and a moment of silence
  FastLED.addLeds<LED_TYPE,DATA_PIN,COLOR_ORDER>(leds, NUM_LEDS)
        .setCorrection( TypicalLEDStrip );
  FastLED.setMaxPowerInVoltsAndMilliamps( 5, MAX_POWER_MILLIAMPS);
}

void loop()
{
  EVERY_N_MILLISECONDS( 20) {
    pacifica_loop();
    FastLED.show();
  }
}

//////////////////////////////////////////////////////////////////////////
//
// The code for this animation is more complicated than other examples, and
// while it is "ready to run", and documented in general, it is probably not
// the best starting point for learning.  Nevertheless, it does illustrate some
// useful techniques.
//
//////////////////////////////////////////////////////////////////////////
//
// In this animation, there are four "layers" of waves of light. 
//
// Each layer moves independently, and each is scaled separately.
//
// All four wave layers are added together on top of each other, and then
// another filter is applied that adds "whitecaps" of brightness where the
// waves line up with each other more.  Finally, another pass is taken
// over the led array to 'deepen' (dim) the blues and greens.
//
// The speed and scale and motion each layer varies slowly within independent
// hand-chosen ranges, which is why the code has a lot of low-speed 'beatsin8' functions
// with a lot of oddly specific numeric ranges.
//
// These three custom blue-green color palettes were inspired by the colors found in
// the waters off the southern coast of California, https://goo.gl/maps/QQgd97jjHesHZVxQ7
//
CRGBPalette16 pacifica_palette_1 =
    { 0x000507, 0x000409, 0x00030B, 0x00030D, 0x000210, 0x000212, 0x000114, 0x000117,
      0x000019, 0x00001C, 0x000026, 0x000031, 0x00003B, 0x000046, 0x14554B, 0x28AA50 };
CRGBPalette16 pacifica_palette_2 =
    { 0x000507, 0x000409, 0x00030B, 0x00030D, 0x000210, 0x000212, 0x000114, 0x000117,
      0x000019, 0x00001C, 0x000026, 0x000031, 0x00003B, 0x000046, 0x0C5F52, 0x19BE5F };
CRGBPalette16 pacifica_palette_3 =
    { 0x000208, 0x00030E, 0x000514, 0x00061A, 0x000820, 0x000927, 0x000B2D, 0x000C33,
      0x000E39, 0x001040, 0x001450, 0x001860, 0x001C70, 0x002080, 0x1040BF, 0x2060FF };


void pacifica_loop()
{
  // Increment the four "color index start" counters, one for each wave layer.
  // Each is incremented at a different speed, and the speeds vary over time.
  static uint16_t sCIStart1, sCIStart2, sCIStart3, sCIStart4;
  static uint32_t sLastms = 0;
  uint32_t ms = GET_MILLIS();
  uint32_t deltams = ms - sLastms;
  sLastms = ms;
  uint16_t speedfactor1 = beatsin16(3, 179, 269);
  uint16_t speedfactor2 = beatsin16(4, 179, 269);
  uint32_t deltams1 = (deltams * speedfactor1) / 256;
  uint32_t deltams2 = (deltams * speedfactor2) / 256;
  uint32_t deltams21 = (deltams1 + deltams2) / 2;
  sCIStart1 += (deltams1 * beatsin88(1011,10,13));
  sCIStart2 -= (deltams21 * beatsin88(777,8,11));
  sCIStart3 -= (deltams1 * beatsin88(501,5,7));
  sCIStart4 -= (deltams2 * beatsin88(257,4,6));

  // Clear out the LED array to a dim background blue-green
  fill_solid( leds, NUM_LEDS, CRGB( 2, 6, 10));

  // Render each of four layers, with different scales and speeds, that vary over time
  pacifica_one_layer( pacifica_palette_1, sCIStart1, beatsin16( 3, 11 * 256, 14 * 256), beatsin8( 10, 70, 130), 0-beat16( 301) );
  pacifica_one_layer( pacifica_palette_2, sCIStart2, beatsin16( 4,  6 * 256,  9 * 256), beatsin8( 17, 40,  80), beat16( 401) );
  pacifica_one_layer( pacifica_palette_3, sCIStart3, 6 * 256, beatsin8( 9, 10,38), 0-beat16(503));
  pacifica_one_layer( pacifica_palette_3, sCIStart4, 5 * 256, beatsin8( 8, 10,28), beat16(601));

  // Add brighter 'whitecaps' where the waves lines up more
  pacifica_add_whitecaps();

  // Deepen the blues and greens a bit
  pacifica_deepen_colors();
}

// Add one layer of waves into the led array
void pacifica_one_layer( CRGBPalette16& p, uint16_t cistart, uint16_t wavescale, uint8_t bri, uint16_t ioff)
{
  uint16_t ci = cistart;
  uint16_t waveangle = ioff;
  uint16_t wavescale_half = (wavescale / 2) + 20;
  for( uint16_t i = 0; i < NUM_LEDS; i++) {
    waveangle += 250;
    uint16_t s16 = sin16( waveangle ) + 32768;
    uint16_t cs = scale16( s16 , wavescale_half ) + wavescale_half;
    ci += cs;
    uint16_t sindex16 = sin16( ci) + 32768;
    uint8_t sindex8 = scale16( sindex16, 240);
    CRGB c = ColorFromPalette( p, sindex8, bri, LINEARBLEND);
    leds[i] += c;
  }
}

// Add extra 'white' to areas where the four layers of light have lined up brightly
void pacifica_add_whitecaps()
{
  uint8_t basethreshold = beatsin8( 9, 55, 65);
  uint8_t wave = beat8( 7 );
 
  for( uint16_t i = 0; i < NUM_LEDS; i++) {
    uint8_t threshold = scale8( sin8( wave), 20) + basethreshold;
    wave += 7;
    uint8_t l = leds[i].getAverageLight();
    if( l > threshold) {
      uint8_t overage = l - threshold;
      uint8_t overage2 = qadd8( overage, overage);
      leds[i] += CRGB( overage, overage2, qadd8( overage2, overage2));
    }
  }
}

// Deepen the blues and greens
void pacifica_deepen_colors()
{
  for( uint16_t i = 0; i < NUM_LEDS; i++) {
    leds[i].blue = scale8( leds[i].blue,  145);
    leds[i].green= scale8( leds[i].green, 200);
    leds[i] |= CRGB( 2, 5, 7);
  }
}

Djudav · 12 Ноя 2021

@Lumenjer, изначальный код работы с режимами "радуга" и переключением кнопкой (там еще не нужные мне были доп. кнопки увеличения яркости):

C++:

#include <FastLED.h> // подключаем библиотеку

#define NUM_LEDS 100
#define PIN 4

byte bright = 50; // яркость светодиодов
byte rate = 0;       // скорость эффектов
byte w = 1;          // переключение режимов
byte baza = 0;     // изменение оттенка

boolean button1WasUp = true;   // переменные для считывания нажатия на кнопки
boolean button2WasUp = true;
boolean button3WasUp = true;

CRGB leds[NUM_LEDS];

void setup() {
  pinMode(8, INPUT_PULLUP);   // подключаем тактовые кнопки
  pinMode(10, INPUT_PULLUP);
  pinMode(12, INPUT_PULLUP);

  FastLED.addLeds <WS2812, PIN, GRB>(leds, NUM_LEDS).setCorrection(TypicalLEDStrip);
  FastLED.setBrightness(bright);
}

void knopka () {
  boolean button1IsUp = digitalRead(8);   // узнаем текущее состояние кнопок
  boolean button2IsUp = digitalRead(10);
  boolean button3IsUp = digitalRead(12);

  // если кнопка 1 была нажата, добавляем яркость (не больше 250)
  if (button1WasUp && !button1IsUp) {
    delay(10);
    button1IsUp = digitalRead(8);
    if (!button1IsUp) { bright = bright + 50; if (bright > 250) { bright = 50; }
    }
  }
  button1WasUp = button1IsUp; // запоминаем состояние кнопки 1

  // если кнопка 2 была нажата, увеличиваем задержку (не больше 50)
  if (button2WasUp && !button2IsUp) {
    delay(10);
    button2IsUp = digitalRead(10);
    if (!button2IsUp) { rate = rate + 10; if (rate > 50) { rate = 0; }
    }
  }
  button2WasUp = button2IsUp; // запоминаем состояние кнопки 2

  // если кнопка 3 была нажата, переходим в новый режим
  if (button3WasUp && !button3IsUp) {
    delay(10);
    button3IsUp = digitalRead(12);
    if (!button3IsUp) { w++; if (w > 7) { w = 1; }
    }
  }
  button3WasUp = button3IsUp; // запоминаем состояние кнопки 3
}

void loop() {
  // первый режим (радуга)
  while (w == 1) {
    knopka(); // узнаем состояние кнопок
    for (int i = 0; i < NUM_LEDS; i++) {
      leds[i] = CHSV(baza+ i * 5, 255, 255);
    }
    baza++;
    FastLED.setBrightness(bright);
    FastLED.show();
    delay(50 - rate);
  }

  // второй режим (палитра)
  while (w == 2) {
    knopka(); // узнаем состояние кнопок
    static uint8_t starthue = 0;
    fill_rainbow( leds + 5, NUM_LEDS - 5, --starthue, rate);
    uint8_t secs = (millis() / 1000) % (rate * 2);
    if (secs < rate) { FastLED.setTemperature( Tungsten100W ); leds[0] = Tungsten100W; }
    else { FastLED.setTemperature( OvercastSky ); leds[0] = OvercastSky; }
    FastLED.setBrightness(bright);
    FastLED.show();
  }

  // третий режим (конфетти)
  while (w == 3) {
    knopka(); // узнаем состояние кнопок
    fadeToBlackBy(leds, NUM_LEDS, (rate + 1) * 2);
    int pos = random16(NUM_LEDS);
    leds[pos] += CHSV(baza++ + random8(64), 200, 255);
    FastLED.setBrightness(bright);
    FastLED.show();
  }

  // четвертый режим (бегущий огонек)
  while (w == 4) {
    knopka(); // узнаем состояние кнопок
    fadeToBlackBy(leds, NUM_LEDS, (rate + 1) * 2);
    int pos = beatsin16(13, 0, NUM_LEDS - 1);
    leds[pos] += CHSV(baza++, 255, 192);
    FastLED.setBrightness(bright);
    FastLED.show();
  }

  // пятый режим (циклон)
  while (w == 5) {
    for (int i = 0; i < NUM_LEDS; i++) {
      leds[i].nscale8(250);
      }
    for (int i = 0; i < NUM_LEDS; i++) {
      knopka(); // узнаем состояние кнопок
      leds[i] = CHSV(baza++, 255, 255);
      FastLED.setBrightness(bright);
      FastLED.show();
      delay(rate);
    }
  }

  // шестой режим (фокус)
  while (w == 6) {
    knopka(); // узнаем состояние кнопок
    fadeToBlackBy(leds, NUM_LEDS, (rate + 1) * 2);
    for (int i = 0; i < 8; i++) {
      leds[beatsin16(i + 7, 0, NUM_LEDS - 1)] |= CHSV(baza+=16, 200, 255);
    }
    FastLED.setBrightness(bright);
    FastLED.show();
    delay(10);
  }

  // седьмой режим (радуга с мерцанием)
  while (w == 7) {
    knopka(); // узнаем состояние кнопок
    fill_rainbow( leds, NUM_LEDS, baza++, 7);
    if (random8() < 80) { leds[ random16(NUM_LEDS) ] += CRGB::White; }
    FastLED.setBrightness(bright);
    FastLED.show();
    delay(50 - rate);
  }
}

Lumenjer · 12 Ноя 2021

@Djudav, если по быстрому, то попробуйте так

C++:

#define FASTLED_ALLOW_INTERRUPTS 0
#include <FastLED.h>
FASTLED_USING_NAMESPACE

#define DATA_PIN            4
#define NUM_LEDS            220
#define MAX_POWER_MILLIAMPS 500
#define LED_TYPE            WS2812B
#define COLOR_ORDER         GRB

byte bright = 180; // яркость светодиодов
byte rate = 0;       // скорость эффектов
byte w = 1;          // переключение режимов
byte baza = 0;     // изменение оттенка


boolean button3WasUp = true;
//////////////////////////////////////////////////////////////////////////

CRGB leds[NUM_LEDS];

void setup() {
  delay( 1000); // 1 second delay for boot recovery, and a moment of silence
  FastLED.addLeds<LED_TYPE,DATA_PIN,COLOR_ORDER>(leds, NUM_LEDS)
        .setCorrection( TypicalLEDStrip );
  FastLED.setMaxPowerInVoltsAndMilliamps( 5, MAX_POWER_MILLIAMPS);
}

void knopka () {

  boolean button3IsUp = digitalRead(12);


  // если кнопка 3 была нажата, переходим в новый режим
  if (button3WasUp && !button3IsUp) {
    delay(10);
    button3IsUp = digitalRead(12);
    if (!button3IsUp) { w++; if (w > 7) { w = 1; }
    }
  }
  button3WasUp = button3IsUp; // запоминаем состояние кнопки 3
}

void loop()
{
    knopka();
    if(w == 1){
      EVERY_N_MILLISECONDS( 20) {
          pacifica_loop();
          FastLED.show();
      }
    }
    else {
        rainbow();
    }
}

//////////////////////////////////////////////////////////////////////////
//
// The code for this animation is more complicated than other examples, and
// while it is "ready to run", and documented in general, it is probably not
// the best starting point for learning.  Nevertheless, it does illustrate some
// useful techniques.
//
//////////////////////////////////////////////////////////////////////////
//
// In this animation, there are four "layers" of waves of light.
//
// Each layer moves independently, and each is scaled separately.

CRGBPalette16 pacifica_palette_1 =
    { 0x000507, 0x000409, 0x00030B, 0x00030D, 0x000210, 0x000212, 0x000114, 0x000117,
      0x000019, 0x00001C, 0x000026, 0x000031, 0x00003B, 0x000046, 0x14554B, 0x28AA50 };
CRGBPalette16 pacifica_palette_2 =
    { 0x000507, 0x000409, 0x00030B, 0x00030D, 0x000210, 0x000212, 0x000114, 0x000117,
      0x000019, 0x00001C, 0x000026, 0x000031, 0x00003B, 0x000046, 0x0C5F52, 0x19BE5F };
CRGBPalette16 pacifica_palette_3 =
    { 0x000208, 0x00030E, 0x000514, 0x00061A, 0x000820, 0x000927, 0x000B2D, 0x000C33,
      0x000E39, 0x001040, 0x001450, 0x001860, 0x001C70, 0x002080, 0x1040BF, 0x2060FF };

    
void pacifica_loop()
{

  // Increment the four "color index start" counters, one for each wave layer.
  // Each is incremented at a different speed, and the speeds vary over time.
  static uint16_t sCIStart1, sCIStart2, sCIStart3, sCIStart4;
  static uint32_t sLastms = 0;
  uint32_t ms = GET_MILLIS();
  uint32_t deltams = ms - sLastms;
  sLastms = ms;
  uint16_t speedfactor1 = beatsin16(3, 179, 269);
  uint16_t speedfactor2 = beatsin16(4, 179, 269);
  uint32_t deltams1 = (deltams * speedfactor1) / 256;
  uint32_t deltams2 = (deltams * speedfactor2) / 256;
  uint32_t deltams21 = (deltams1 + deltams2) / 2;
  sCIStart1 += (deltams1 * beatsin88(1011,10,13));
  sCIStart2 -= (deltams21 * beatsin88(777,8,11));
  sCIStart3 -= (deltams1 * beatsin88(501,5,7));
  sCIStart4 -= (deltams2 * beatsin88(257,4,6));

  // Clear out the LED array to a dim background blue-green
  fill_solid( leds, NUM_LEDS, CRGB( 2, 6, 10));

  // Render each of four layers, with different scales and speeds, that vary over time
  pacifica_one_layer( pacifica_palette_1, sCIStart1, beatsin16( 3, 11 * 256, 14 * 256), beatsin8( 10, 70, 130), 0-beat16( 301) );
  pacifica_one_layer( pacifica_palette_2, sCIStart2, beatsin16( 4,  6 * 256,  9 * 256), beatsin8( 17, 40,  80), beat16( 401) );
  pacifica_one_layer( pacifica_palette_3, sCIStart3, 6 * 256, beatsin8( 9, 10,38), 0-beat16(503));
  pacifica_one_layer( pacifica_palette_3, sCIStart4, 5 * 256, beatsin8( 8, 10,28), beat16(601));

  // Add brighter 'whitecaps' where the waves lines up more
  pacifica_add_whitecaps();

  // Deepen the blues and greens a bit
  pacifica_deepen_colors();
}

// Add one layer of waves into the led array
void pacifica_one_layer( CRGBPalette16& p, uint16_t cistart, uint16_t wavescale, uint8_t bri, uint16_t ioff)
{
  uint16_t ci = cistart;
  uint16_t waveangle = ioff;
  uint16_t wavescale_half = (wavescale / 2) + 20;
  for( uint16_t i = 0; i < NUM_LEDS; i++) {
    waveangle += 250;
    uint16_t s16 = sin16( waveangle ) + 32768;
    uint16_t cs = scale16( s16 , wavescale_half ) + wavescale_half;
    ci += cs;
    uint16_t sindex16 = sin16( ci) + 32768;
    uint8_t sindex8 = scale16( sindex16, 240);
    CRGB c = ColorFromPalette( p, sindex8, bri, LINEARBLEND);
    leds[i] += c;
  }
}

// Add extra 'white' to areas where the four layers of light have lined up brightly
void pacifica_add_whitecaps()
{
  uint8_t basethreshold = beatsin8( 9, 55, 65);
  uint8_t wave = beat8( 7 );
 
  for( uint16_t i = 0; i < NUM_LEDS; i++) {
    uint8_t threshold = scale8( sin8( wave), 20) + basethreshold;
    wave += 7;
    uint8_t l = leds[i].getAverageLight();
    if( l > threshold) {
      uint8_t overage = l - threshold;
      uint8_t overage2 = qadd8( overage, overage);
      leds[i] += CRGB( overage, overage2, qadd8( overage2, overage2));
    }
  }
}

// Deepen the blues and greens
void pacifica_deepen_colors()
{
  for( uint16_t i = 0; i < NUM_LEDS; i++) {
    leds[i].blue = scale8( leds[i].blue,  145);
    leds[i].green= scale8( leds[i].green, 200);
    leds[i] |= CRGB( 2, 5, 7);
  }
}

///////////////////////////////////////////////////////////////////////
// режимы свечения ленты
void rainbow(){
  // первый режим (радуга)
  while (w == 2) {
    knopka(); // узнаем состояние кнопок
    for (int i = 0; i < NUM_LEDS; i++) {
      leds[i] = CHSV(baza+ i * 5, 255, 255);
    }
    baza++;
    FastLED.setBrightness(bright);
    FastLED.show();
    delay(50 - rate);
  }

  // второй режим (палитра)
  while (w == 3) {
    knopka(); // узнаем состояние кнопок
    static uint8_t starthue = 0;
    fill_rainbow( leds + 5, NUM_LEDS - 5, --starthue, rate);
    uint8_t secs = (millis() / 1000) % (rate * 2);
    if (secs < rate) { FastLED.setTemperature( Tungsten100W ); leds[0] = Tungsten100W; }
    else { FastLED.setTemperature( OvercastSky ); leds[0] = OvercastSky; }
    FastLED.setBrightness(bright);
    FastLED.show();
  }

  // третий режим (конфетти)
  while (w == 4) {
    knopka(); // узнаем состояние кнопок
    fadeToBlackBy(leds, NUM_LEDS, (rate + 1) * 2);
    int pos = random16(NUM_LEDS);
    leds[pos] += CHSV(baza++ + random8(64), 200, 255);
    FastLED.setBrightness(bright);
    FastLED.show();
  }

  // четвертый режим (бегущий огонек)
  while (w == 5) {
    knopka(); // узнаем состояние кнопок
    fadeToBlackBy(leds, NUM_LEDS, (rate + 1) * 2);
    int pos = beatsin16(13, 0, NUM_LEDS - 1);
    leds[pos] += CHSV(baza++, 255, 192);
    FastLED.setBrightness(bright);
    FastLED.show();
  }

  // пятый режим (циклон)
  while (w == 6) {
    for (int i = 0; i < NUM_LEDS; i++) {
      leds[i].nscale8(250);
      }
    for (int i = 0; i < NUM_LEDS; i++) {
      knopka(); // узнаем состояние кнопок
      leds[i] = CHSV(baza++, 255, 255);
      FastLED.setBrightness(bright);
      FastLED.show();
      delay(rate);
    }
  }

  // шестой режим (фокус)
  while (w == 7) {
    knopka(); // узнаем состояние кнопок
    fadeToBlackBy(leds, NUM_LEDS, (rate + 1) * 2);
    for (int i = 0; i < 8; i++) {
      leds[beatsin16(i + 7, 0, NUM_LEDS - 1)] |= CHSV(baza+=16, 200, 255);
    }
    FastLED.setBrightness(bright);
    FastLED.show();
    delay(10);
  }

  // седьмой режим (радуга с мерцанием)
  while (w == 8) {
    knopka(); // узнаем состояние кнопок
    fill_rainbow( leds, NUM_LEDS, baza++, 7);
    if (random8() < 80) { leds[ random16(NUM_LEDS) ] += CRGB::White; }
    FastLED.setBrightness(bright);
    FastLED.show();
    delay(50 - rate);
  }
}

Сотнег · 12 Ноя 2021

@Djudav, если в скетче ничего нет, кроме эффектов,
почему не взять готовую прошивку со сборником эффектов?

Djudav · 12 Ноя 2021

@Сотнег,мне понравился эффект Океана этот, плюс хотел доработать, путем объединения с тем скетчем, где кнопкой менять можно режимы

@Lumenjer,благодарю! все заработало, как и хотел. Сейчас внимательно посмотрю как вы сделали )

Djudav · 12 Ноя 2021

@Lumenjer, прошу прощения еще раз. Заметил, что корректно работает скетч и вся сборка только, если питание от ноутбука идет через юсб. На прямую от БП идет смена режимов через каждые примерно 3 секунды. С чем может быть связано такое?

Lumenjer · 12 Ноя 2021

@Djudav, замыкать планируете к чему? К GND или 3.3v?
Если к GND, то в setup() допишите строку pinMode(12, INPUT_PULLUP); и можете замыкать хоть на массу блока питания.

Djudav · 12 Ноя 2021

@Lumenjer, думал о подобном, но не реализовал. Теперь все отлично. Еще раз спасибо

Поиск

Поиск

режимы свечения WS2812b

Djudav

✩✩✩✩✩✩✩

Lumenjer

★★★✩✩✩✩

Djudav

✩✩✩✩✩✩✩

Djudav

✩✩✩✩✩✩✩

Lumenjer

★★★✩✩✩✩

Сотнег

★★★★★★★

Djudav

✩✩✩✩✩✩✩

Djudav

✩✩✩✩✩✩✩

Lumenjer

★★★✩✩✩✩

Djudav

✩✩✩✩✩✩✩