#include <FastLED.h>

int joystickX = 0;
int joystickY = 0;

int previousJoystickX = 0;
int previousJoystickY = 0;

#define charging_pin 2


#define NUM_LEDS 12 // Количество светодиодов на ленте
#define DATA_PIN 13 // Пин, к которому подсоединены светодиоды
#define DATA_PIN_Back 12 // Пин, к которому подсоединены светодиоды
#define SERIAL_BAUD_RATE 9600 // Скорость обмена последовательными портами
#define LED_BRIGHTNESS 255

#define FADE_TIME 1000 // Time to fade from MAX_BRIGHTNESS to HALF_BRIGHTNESS in milliseconds
#define MAX_BRIGHTNESS 255
#define HALF_BRIGHTNESS 120

#define SEGMENT_LENGTH 3 // Длина сегмента, который будет повышать яркость
#define RAINBOW_SPEED 50 // Скорость движения радуги в миллисекундах
#define SEGMENT_SPEED 80 // Скорость движения сегмента в миллисекундах
#define MIN_RESPAWN_DELAY 5000 // Минимальная задержка перед появлением сегмента (в миллисекундах)
#define MAX_RESPAWN_DELAY 10000 // Максимальная задержка перед появлением сегмента (в миллисекундах)

#define delay_back_startingup 50
#define delay_lava_back 100 // Update every 100 milliseconds
#define delay_moving_back 50
#define delay_brake_back 50
#define delay_clear_back 50

bool RAINBOW_start_flag_front = true;
bool RAINBOW_start_flag_back = true;

int CHSV_back_color = 0;   //red
int CHSV_back_saturation = 255;

static uint8_t startIndex = 0;
  static int segmentStart = -SEGMENT_LENGTH; // Начальное значение -SEGMENT_LENGTH чтобы сегмент появился сразу
  static unsigned long lastSegmentTime = 0;
  static unsigned long nextRespawnTime = 0;

CRGB leds[NUM_LEDS];

uint8_t currentBrightness[NUM_LEDS]; // Array to store the current brightness for each LED
unsigned long lastBrightnessChange[NUM_LEDS]; // Array to store the last time the brightness was changed for each LED

// Переменные для управления эффектами
uint8_t currentMode = 0; // Текущий режим эффекта
uint8_t effectIndex = 0; // Индекс эффекта для плавного перехода цветов
int effectIndex_for_startingup = 0;



void initializeRandomSeed() {
    randomSeed(analogRead(0)); // Initialize the random number generator with a noise source
}

bool randomBrightnessChange() {
    return random(100) < 5; // 5% chance to return true
}


#define DATA_PIN_FRONT 12 // Пин, к которому подсоединены светодиоды

#define FADE_TIME_FRONT 1000 // Time to fade from MAX_BRIGHTNESS to HALF_BRIGHTNESS in milliseconds

#define SEGMENT_LENGTH_FRONT 3 // Длина сегмента, который будет повышать яркость
#define RAINBOW_SPEED_FRONT 50 // Скорость движения радуги в миллисекундах
#define SEGMENT_SPEED_FRONT 80 // Скорость движения сегмента в миллисекундах
#define MIN_RESPAWN_DELAY_FRONT 5000 // Минимальная задержка перед появлением сегмента (в миллисекундах)
#define MAX_RESPAWN_DELAY_FRONT 10000 // Максимальная задержка перед появлением сегмента (в миллисекундах)

#define delay_startingup_FRONT 50
#define delay_lava_FRONT 100 // Update every 100 milliseconds
#define delay_moving_FRONT 50
#define delay_brake_FRONT 50
#define delay_clear_front 50

#define delay_RAINBOW_start_flag_back 50
#define delay_RAINBOW_start_flag_front 50

int CHSV_color_FRONT = 200;   //red
int CHSV_saturation_FRONT = 255; 

static uint8_t startIndex_FRONT = 0;
static int segmentStart_FRONT = -SEGMENT_LENGTH_FRONT; // Начальное значение -SEGMENT_LENGTH чтобы сегмент появился сразу
static unsigned long lastSegmentTime_FRONT = 0;
static unsigned long nextRespawnTime_FRONT = 0;


CRGB leds_FRONT[NUM_LEDS];

uint8_t currentBrightness_FRONT[NUM_LEDS]; // Array to store the current brightness for each LED
unsigned long lastBrightnessChange_FRONT[NUM_LEDS]; // Array to store the last time the brightness was changed for each LED

// Переменные для управления эффектами
uint8_t currentMode_FRONT = 0; // Текущий режим эффекта
uint8_t effectIndex_FRONT = 0; // Индекс эффекта для плавного перехода цветов
int effectIndex_for_startingup_FRONT = 0;


void initializeRandomSeed_FRONT() {
    randomSeed(analogRead(0)); // Initialize the random number generator with a noise source
}

bool randomBrightnessChange_FRONT() {
    return random(100) < 5; // 5% chance to return true
}




// Функция для чтения номера режима из монитора порта
void readModeFromSerial() {
  static String inputString = ""; // Буфер для хранения входных данных
  static boolean stringComplete = false; // Флаг для обозначения завершения строки

  while (Serial.available()) {
    // Получаем очередной символ из порта
    char inChar = (char)Serial.read();
    // Если символ новой строки, то строка закончилась
    if (inChar == '\n') {
      stringComplete = true;
    } else {
      // Иначе добавляем символ к строке
      inputString += inChar;
    }
  }

  // Если строка закончилась, то пытаемся преобразовать ее в число
  if (stringComplete) {
    int newMode = inputString.toInt(); // Преобразование строки в число
    if (newMode >= 0 && newMode <= 10) { // Проверка диапазона нового режима
      currentMode = newMode;
      effectIndex = 0; // Сброс индекса эффекта
      effectIndex_for_startingup = 0;

      currentMode_FRONT = newMode;
      effectIndex_FRONT = 0; // Сброс индекса эффекта
      effectIndex_for_startingup_FRONT = 0;
      FastLED.setBrightness(LED_BRIGHTNESS);
      RAINBOW_start_flag_front = true;
      RAINBOW_start_flag_back = true;

      Serial.println(currentMode);
    }
    // Очищаем строку и сбрасываем флаг
    inputString = "";
    stringComplete = false;
  }
}

// Функция для обновления эффектов
void updateEffects() {
  switch (currentMode) {
    case 0: // Все выключено
      clear_back();
      
      break;
    case 1: 
      EVERY_N_MILLISECONDS(delay_back_startingup) {
        back_startingup();
    }       
      break;
    case 2: 
      EVERY_N_MILLISECONDS(delay_lava_back) {
        lava_back();
    }
      break;
    case 3: 
      EVERY_N_MILLISECONDS(delay_moving_back) {
        moving_back();
    }
      break;
    case 4: // Светодиоды заливаются из центра к краям со 100% яркостью
      EVERY_N_MILLISECONDS(delay_brake_back) { // Обновление каждые 50 миллисекунд
        brake_back();
      }
      break;
      case 10: 
      
        charging();
    
      break;
    default:
      break;
  }
}


void updateEffects_FRONT() {
  switch (currentMode_FRONT) {
    case 0: // Все выключено
      clear_front();
      
      break;
    case 1: 
      EVERY_N_MILLISECONDS(delay_startingup_FRONT) {
        startingup_FRONT ();
    }       
      break;
    case 2: 
      EVERY_N_MILLISECONDS(delay_lava_FRONT) {
        lava_FRONT ();
    }
      break;
    case 3: 
      EVERY_N_MILLISECONDS(delay_moving_FRONT) {
        moving_FRONT ();
    }
      break;
    case 4: // Светодиоды заливаются из центра к краям со 100% яркостью
      EVERY_N_MILLISECONDS(delay_brake_FRONT) { // Обновление каждые 50 миллисекунд
        brake_FRONT();
      }
      break;
      case 10: 
      
        charging_FRONT();
    
      break;
    default:
      break;
  }
}



void setup() {
  FastLED.addLeds<WS2812, DATA_PIN, GRB>(leds, NUM_LEDS);
  //FastLED.addLeds<WS2812, DATA_PIN_Back, GRB>(leds_Back, NUM_LEDS);
  FastLED.setBrightness(LED_BRIGHTNESS);
  initializeRandomSeed(); // Initialize the random number generator

  FastLED.addLeds<WS2812, DATA_PIN_FRONT, GRB>(leds_FRONT, NUM_LEDS);
  initializeRandomSeed_FRONT(); // Initialize the random number generator
  
  pinMode(charging_pin, INPUT);
  Serial.begin(SERIAL_BAUD_RATE);
  Serial.println("ok");
}

void loop() {
 
  






  readModeFromSerial();
  updateEffects();
  updateEffects_FRONT();
  FastLED.show();
}

void back_startingup() {
switch (effectIndex_for_startingup) {
            case 0: // Первый эффект
                leds[effectIndex] = CHSV(CHSV_back_color, 0, MAX_BRIGHTNESS);
                leds[effectIndex - 1] = CHSV(CHSV_back_color, 0, 0);
                leds[NUM_LEDS - 1 - effectIndex] = CHSV(CHSV_back_color, 0, MAX_BRIGHTNESS);
                leds[NUM_LEDS - 1 - effectIndex + 1] = CHSV(CHSV_back_color, 0, 0);
                 //blur1d(leds, NUM_LEDS, 50);  
                if (effectIndex >= NUM_LEDS / 2-1) {
                    effectIndex_for_startingup++;
                    effectIndex = 0;
                }
                break;
            case 1: // Второй эффект
                
                leds[NUM_LEDS / 2 + effectIndex-1] = CHSV(CHSV_back_color, 0, HALF_BRIGHTNESS);
                leds[NUM_LEDS / 2 - effectIndex-0] = CHSV(CHSV_back_color, 0, HALF_BRIGHTNESS);
                leds[NUM_LEDS / 2 + effectIndex+0] = CHSV(CHSV_back_color, 0, MAX_BRIGHTNESS);
                leds[NUM_LEDS / 2 - effectIndex-1] = CHSV(CHSV_back_color, 0, MAX_BRIGHTNESS);
                
                if (effectIndex >= NUM_LEDS / 2+1) {
                    effectIndex_for_startingup++;
                    effectIndex = 0;
                }
                break;
            case 2: // Третий эффект
                leds[NUM_LEDS / 2-1 + effectIndex] = CHSV(CHSV_back_color, 0, MAX_BRIGHTNESS);
                leds[NUM_LEDS / 2-1+1 - effectIndex] = CHSV(CHSV_back_color, 0, MAX_BRIGHTNESS);
                if (effectIndex >= NUM_LEDS / 2) {
                    effectIndex_for_startingup++;
                    effectIndex = 0;
                }
                break;
            case 3: // Четвертый эффект
            
                fill_solid(leds, NUM_LEDS, CHSV(CHSV_back_color, map(effectIndex,0,18,0,CHSV_back_saturation), MAX_BRIGHTNESS - MAX_BRIGHTNESS/2+10 - effectIndex));
                if (effectIndex >= 18) {
                    effectIndex_for_startingup = 0;
                    effectIndex = -1;
                    currentMode =2; //здесь сразу переключение на след мод
                }
                break;
                
        }
        
        effectIndex++;
    }

void moving_back() {
  if (effectIndex < NUM_LEDS/2) {
          int position = NUM_LEDS / 2 + effectIndex;
          if (position < NUM_LEDS) {
            leds[position] = CHSV(CHSV_back_color, CHSV_back_saturation, HALF_BRIGHTNESS); // Зажигаем текущий светодиод
          }
          position = NUM_LEDS / 2-1 - effectIndex;
          if (position >= 0) {
            leds[position] = CHSV(CHSV_back_color, CHSV_back_saturation, HALF_BRIGHTNESS); // Зажигаем текущий светодиод
          }
          
          effectIndex++; // Переходим к следующему светодиоду
        }
        if (effectIndex >= NUM_LEDS/2) {
          effectIndex = 0; // Сброс индекса эффекта после заполнения всех светодиодов
        }
}



void brake_back() {
  if (effectIndex < NUM_LEDS/2) {
          int position = NUM_LEDS / 2 + effectIndex;
          if (position < NUM_LEDS) {
            leds[position] = CHSV(CHSV_back_color, CHSV_back_saturation, MAX_BRIGHTNESS); // Зажигаем текущий светодиод
          }
          position = NUM_LEDS / 2-1 - effectIndex;
          if (position >= 0) {
            leds[position] = CHSV(CHSV_back_color, CHSV_back_saturation, MAX_BRIGHTNESS); // Зажигаем текущий светодиод
          }
          
          effectIndex++; // Переходим к следующему светодиоду
        }
        if (effectIndex >= NUM_LEDS/2) {
          effectIndex = 0; // Сброс индекса эффекта после заполнения всех светодиодов
        }
        
}

void lava_back() {
    float progress = (sin(millis() / 2000.0 * PI) + 1.0) / 2.0; // Range: 0 to 1

    for (int i = 0; i < NUM_LEDS; ++i) {
        float distance1 = abs(i - NUM_LEDS / 4);
        float distance2 = abs(i - NUM_LEDS / 2);
        float distance3 = abs(i - 3 * NUM_LEDS / 4);
        float minDistance = min(distance1, min(distance2, distance3));
        uint8_t currentHue = progress * (1.0 - minDistance / (NUM_LEDS / 4)) * 32 + CHSV_back_color; // Transition from red to orange

        unsigned long timeSinceChange = millis() - lastBrightnessChange[i];
        if (timeSinceChange < FADE_TIME) {
            currentBrightness[i] = MAX_BRIGHTNESS - ((MAX_BRIGHTNESS - HALF_BRIGHTNESS) * timeSinceChange) / FADE_TIME;
        } else {
            currentBrightness[i] = randomBrightnessChange() ? MAX_BRIGHTNESS : HALF_BRIGHTNESS;
        }

        leds[i] = CHSV(currentHue, 255, currentBrightness[i]); // Full saturation and brightness
        if (currentBrightness[i] == MAX_BRIGHTNESS) {
            lastBrightnessChange[i] = millis();
        }
    }
}

void charging() {
    

  EVERY_N_MILLISECONDS(RAINBOW_SPEED) {
    
    // Заполняем радугой светодиоды
    fill_rainbow(leds, NUM_LEDS, startIndex, 7);
    startIndex++; // Увеличиваем индекс начала радуги
FastLED.setBrightness(HALF_BRIGHTNESS);
    // Устанавливаем яркость светодиодов в сегменте
for (int i = 0; i < NUM_LEDS; i++) {
  if (i >= segmentStart && i < segmentStart + SEGMENT_LENGTH) {
    // Рассчитываем яркость для текущего светодиода
    int distanceToCenter = abs(i - (segmentStart + SEGMENT_LENGTH / 2));
    int brightness = max(0, MAX_BRIGHTNESS - distanceToCenter * HALF_BRIGHTNESS / (SEGMENT_LENGTH / 2));
    leds[i].maximizeBrightness(brightness);
  } else {
    // Устанавливаем яркость для светодиодов, которые не входят в сегмент
    leds[i].maximizeBrightness(HALF_BRIGHTNESS);
  }
}
  }

  EVERY_N_MILLISECONDS(SEGMENT_SPEED) {
    // Проверяем, достиг ли сегмент конца ленты
    if (segmentStart - SEGMENT_LENGTH >= NUM_LEDS && millis() >= nextRespawnTime) {
      // Сбрасываем сегмент и устанавливаем время следующего появления
      segmentStart = -SEGMENT_LENGTH;
      nextRespawnTime = millis() + random(MIN_RESPAWN_DELAY, MAX_RESPAWN_DELAY);
    } else {
      // Перемещаем сегмент влево
      segmentStart++;
    }

    
  }
  if (RAINBOW_start_flag_back) {

    for (int i = 0; i < NUM_LEDS / 2-1-effectIndex; i++) {
      leds[i] = CHSV(CHSV_back_color, CHSV_back_saturation, 0);
      leds[NUM_LEDS - i - 1] = CHSV(CHSV_back_color, CHSV_back_saturation, 0);
    }
    EVERY_N_MILLISECONDS(delay_RAINBOW_start_flag_back) {
  effectIndex++;
  
  if (effectIndex>= NUM_LEDS / 2+1) {
    effectIndex = 0;
    RAINBOW_start_flag_back = false;
 } 
}

} 

}





void startingup_FRONT () {
switch (effectIndex_for_startingup_FRONT) {
            case 0: // Первый эффект
                leds_FRONT[effectIndex_FRONT] = CHSV(CHSV_color_FRONT, 0, MAX_BRIGHTNESS);
                leds_FRONT[effectIndex_FRONT - 1] = CHSV(CHSV_color_FRONT, 0, 0);
                leds_FRONT[NUM_LEDS - 1 - effectIndex_FRONT] = CHSV(CHSV_color_FRONT, 0, MAX_BRIGHTNESS);
                leds_FRONT[NUM_LEDS - 1 - effectIndex_FRONT + 1] = CHSV(CHSV_color_FRONT, 0, 0);
                 //blur1d(leds, NUM_LEDS, 50);  
                if (effectIndex_FRONT >= NUM_LEDS / 2-1) {
                    effectIndex_for_startingup_FRONT++;
                    effectIndex_FRONT = 0;
                }
                break;
            case 1: // Второй эффект
                leds_FRONT[NUM_LEDS / 2 + effectIndex_FRONT-1] = CHSV(CHSV_color_FRONT, 0, HALF_BRIGHTNESS);
                leds_FRONT[NUM_LEDS / 2 - effectIndex_FRONT-0] = CHSV(CHSV_color_FRONT, 0, HALF_BRIGHTNESS);
                leds_FRONT[NUM_LEDS / 2 + effectIndex_FRONT+0] = CHSV(CHSV_color_FRONT, 0, MAX_BRIGHTNESS);
                leds_FRONT[NUM_LEDS / 2 - effectIndex_FRONT-1] = CHSV(CHSV_color_FRONT, 0, MAX_BRIGHTNESS);
                
                if (effectIndex_FRONT >= NUM_LEDS / 2+1) {
                    effectIndex_for_startingup_FRONT++;
                    effectIndex_FRONT = 0;
                }
                break;
            case 2: // Третий эффект
                leds_FRONT[NUM_LEDS / 2-1 + effectIndex_FRONT] = CHSV(CHSV_color_FRONT, 0, MAX_BRIGHTNESS);
                leds_FRONT[NUM_LEDS / 2-1+1 - effectIndex_FRONT] = CHSV(CHSV_color_FRONT, 0, MAX_BRIGHTNESS);
                if (effectIndex_FRONT >= NUM_LEDS / 2) {
                    effectIndex_for_startingup_FRONT++;
                    effectIndex_FRONT = 0;
                }
                break;
            case 3: // Четвертый эффект
            
                fill_solid(leds_FRONT, NUM_LEDS, CHSV(CHSV_color_FRONT, map(effectIndex_FRONT,0,18,0,CHSV_saturation_FRONT), MAX_BRIGHTNESS - MAX_BRIGHTNESS/2+10 - effectIndex_FRONT));
                if (effectIndex_FRONT >= 18) {
                    effectIndex_for_startingup_FRONT = 0;
                    effectIndex_FRONT = -1;
                    currentMode_FRONT =2; //здесь сразу переключение на след мод
                }
                break;
        }
        
        effectIndex_FRONT++;
    }

void moving_FRONT() {
  if (effectIndex_FRONT < NUM_LEDS/2) {
          int position = NUM_LEDS / 2 + effectIndex_FRONT;
          if (position < NUM_LEDS) {
            leds_FRONT[position] = CHSV(CHSV_color_FRONT, CHSV_saturation_FRONT, HALF_BRIGHTNESS); // Зажигаем текущий светодиод
          }
          position = NUM_LEDS / 2-1 - effectIndex_FRONT;
          if (position >= 0) {
            leds_FRONT[position] = CHSV(CHSV_color_FRONT, CHSV_saturation_FRONT, HALF_BRIGHTNESS); // Зажигаем текущий светодиод
          }
          
          effectIndex_FRONT++; // Переходим к следующему светодиоду
        }
        if (effectIndex_FRONT >= NUM_LEDS/2) {
          effectIndex_FRONT = 0; // Сброс индекса эффекта после заполнения всех светодиодов
        }
}


void brake_FRONT() {
  if (effectIndex_FRONT < NUM_LEDS/2) {
          int position = NUM_LEDS / 2 + effectIndex_FRONT;
          if (position < NUM_LEDS) {
            leds_FRONT[position] = CHSV(CHSV_color_FRONT, CHSV_saturation_FRONT, MAX_BRIGHTNESS); // Зажигаем текущий светодиод
          }
          position = NUM_LEDS / 2-1 - effectIndex_FRONT;
          if (position >= 0) {
            leds_FRONT[position] = CHSV(CHSV_color_FRONT, CHSV_saturation_FRONT, MAX_BRIGHTNESS); // Зажигаем текущий светодиод
          }
          
          effectIndex_FRONT++; // Переходим к следующему светодиоду
        }
        if (effectIndex_FRONT >= NUM_LEDS/2) {
          effectIndex_FRONT = 0; // Сброс индекса эффекта после заполнения всех светодиодов
        }
        
}

void lava_FRONT() {
    float progress = (sin(millis() / 2000.0 * PI) + 1.0) / 2.0; // Range: 0 to 1

    for (int i = 0; i < NUM_LEDS; ++i) {
        float distance1 = abs(i - NUM_LEDS / 4);
        float distance2 = abs(i - NUM_LEDS / 2);
        float distance3 = abs(i - 3 * NUM_LEDS / 4);
        float minDistance = min(distance1, min(distance2, distance3));
        uint8_t hue = progress * (1.0 - minDistance / (NUM_LEDS / 4)) * 32 + CHSV_color_FRONT; // Transition from red to orange

        unsigned long timeSinceChange = millis() - lastBrightnessChange_FRONT[i];
        if (timeSinceChange < FADE_TIME_FRONT) {
            currentBrightness_FRONT[i] = MAX_BRIGHTNESS - ((MAX_BRIGHTNESS - HALF_BRIGHTNESS) * timeSinceChange) / FADE_TIME_FRONT;
        } else {
            currentBrightness_FRONT[i] = randomBrightnessChange_FRONT() ? MAX_BRIGHTNESS : HALF_BRIGHTNESS;
        }

        leds_FRONT[i] = CHSV(hue, 255, currentBrightness_FRONT[i]); // Full saturation and brightness
        if (currentBrightness_FRONT[i] == MAX_BRIGHTNESS) {
            lastBrightnessChange_FRONT[i] = millis();
        }
    }

    
}

void charging_FRONT () {
    

  EVERY_N_MILLISECONDS(RAINBOW_SPEED_FRONT) {
    
    // Заполняем радугой светодиоды
    fill_rainbow(leds_FRONT, NUM_LEDS, startIndex_FRONT, 7);
    startIndex_FRONT++; // Увеличиваем индекс начала радуги
FastLED.setBrightness(HALF_BRIGHTNESS);
    // Устанавливаем яркость светодиодов в сегменте
for (int i = 0; i < NUM_LEDS; i++) {
  if (i >= segmentStart_FRONT && i < segmentStart_FRONT + SEGMENT_LENGTH_FRONT) {
    // Рассчитываем яркость для текущего светодиода
    int distanceToCenter = abs(i - (segmentStart_FRONT + SEGMENT_LENGTH_FRONT / 2));
    int brightness = max(0, MAX_BRIGHTNESS - distanceToCenter * HALF_BRIGHTNESS / (SEGMENT_LENGTH_FRONT / 2));
    leds_FRONT[i].maximizeBrightness(brightness);
  } else {
    // Устанавливаем яркость для светодиодов, которые не входят в сегмент
    leds_FRONT[i].maximizeBrightness(HALF_BRIGHTNESS);
  }
}
  }

  EVERY_N_MILLISECONDS(SEGMENT_SPEED_FRONT) {
    // Проверяем, достиг ли сегмент конца ленты
    if (segmentStart_FRONT - SEGMENT_LENGTH_FRONT >= NUM_LEDS && millis() >= nextRespawnTime_FRONT) {
      // Сбрасываем сегмент и устанавливаем время следующего появления
      segmentStart_FRONT = -SEGMENT_LENGTH_FRONT;
      nextRespawnTime_FRONT = millis() + random(MIN_RESPAWN_DELAY_FRONT, MAX_RESPAWN_DELAY_FRONT);
    } else {
      // Перемещаем сегмент влево
      segmentStart_FRONT++;
    }

    
  }

  if (RAINBOW_start_flag_front) {

    for (int i = 0; i < NUM_LEDS / 2-1-effectIndex_FRONT; i++) {
      leds_FRONT[i] = CHSV(CHSV_color_FRONT, CHSV_saturation_FRONT, 0);
      leds_FRONT[NUM_LEDS - i - 1] = CHSV(CHSV_color_FRONT, CHSV_saturation_FRONT, 0);
    }
    EVERY_N_MILLISECONDS(delay_RAINBOW_start_flag_front) {
  effectIndex_FRONT++;
  
  if (effectIndex_FRONT>= NUM_LEDS / 2+1) {
    effectIndex_FRONT = 0;
    RAINBOW_start_flag_front = false;
 } 
}

} 

  

}


void clear_back() {
  EVERY_N_MILLISECONDS(delay_clear_back) {
    leds[NUM_LEDS / 2 + effectIndex] = CHSV(CHSV_back_color, CHSV_back_saturation, 0);
                leds[NUM_LEDS / 2-1 - effectIndex] = CHSV(CHSV_back_color, CHSV_back_saturation, 0);
                effectIndex ++;
                if (effectIndex >= NUM_LEDS / 2) {
                    effectIndex_for_startingup = 0;
                    effectIndex = 0;
                }
                
    }
}

void clear_front() {
  EVERY_N_MILLISECONDS(delay_clear_front) {
    leds_FRONT[NUM_LEDS / 2 + effectIndex_FRONT] = CHSV(CHSV_color_FRONT, CHSV_saturation_FRONT, 0);
                leds_FRONT[NUM_LEDS / 2-1 - effectIndex_FRONT] = CHSV(CHSV_color_FRONT, CHSV_saturation_FRONT, 0);
                effectIndex_FRONT ++;
                if (effectIndex_FRONT >= NUM_LEDS / 2) {
                    effectIndex_for_startingup_FRONT = 0;
                    effectIndex_FRONT = 0;
                }
                
                
        
} 
}