Arduino.ru

Ещё раз извеняюсь код работает но правильно показуют только первые два индикатора.

Хотелка чтоб и давление и температура и влажность была

кодом поделился  dj_tocha

извиняюсь за панику не видел кода в 303 посте :)

как в ущерб символа "С" показывать отрицательную температуру ? что б на улице часы прикрутить можно было ? код из 303 поста 

при использовании датчика BME280 есть возможность использования часов на Улице , как потушить символ"С" и заставить показывать отрицательную температуру (если на улице минусовая температура)?

понимаю что здесь надо задать символ

058 0b00100000,//Digit "-"11  

но как сдвинуть показания температуры на один символ вправо?

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

две страницы  монолога , класс :(

спс 

за это время давно могли бы разобраться в коде, чтобы сдвинуть цифры. А вопрос про вывод минуса меня просто умиляет :)

Расчитывал на помощь получил ничего:( обидно

а что, вот такое самому в голову не пришло?

if ( температура < 0) {

// показать минус

}

Ты чо, это ж Откровения Святого Кернигана, он их не читал еще. 

Дед Семён я не для стеба на форум пришёл, а за помощью

помощь - это обучение программированию страждущих в трёх постах?  Или выдача готового кода на блюдечке?  

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

Понятно

а сообщение #364 понятно?

Да в строчке написано условие что если temp меньше 0 то выводим знак минуса ,как прописать координаты светодиодов которые зажигать для этого условия?

И что, скажете вы сами не могли до этого додуматься ПОЛТОРА МЕСЯЦА?

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

dgeka - если вы отмотаете ветку назад. вы увидите, что я довольно охотно помогаю с этими часами тем, кто спрашивает. Но при одном условии - если люди пытаются что-то сделать САМИ.

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

выввод температуры - процедура TempToArray() , строка 190 кода сообщения #303. Какой знак куда выводится - там почти в каждой строчке есть комментарии

СПС буду дальше глумиться над кодом

Здравствуйте. Прошу помощи. Помогите пожалуйста отредактировать код, чтобы он выводил на часы данные по температуре и влажности с датчика DHT22.

Вот код который использую:

/*
Подключение к Arduino nano:
Часы DS3231:    SCL -> A5
                SDA -> A4
Датчик освещения    -> A3                
Кнопки: Смена часов -> D2 
        Смена минут -> D3
        Смена цвета -> D4
Лента WS2811(WS2812)-> D13
*/
//---------------------------------------------------------------------------------------------------
#include <DS3232RTC.h>
#include <Time.h>
#include <Wire.h>
#include <FastLED.h>

#define LEDS_IN_SEGMENT 1     // Задаём сколько у нас светодиодов в сегменте
#define DOTS_NUM 2            // Задаём сколько у нас разделительных точек
#define COLOR_CHANGE 2        // Смена цвета ( 0 - никогда, 1 - раз в минуту, 2 - каждые десять минут, 3 - каждый час, 4 - каждые десять часов)
#define NUM_COLORS 16         // Количество цветов
#define COLOR_ORDER BGR       // По умолчанию цвет стоит зелёный при выключенных режимах
#define DATA_PIN 13           // Пин ленты 
#define BRI_PIN A3            // PIN фоторезистора
#define auto_bright 1         // автоматическая подстройка яркости от уровня внешнего освещения (1 - включить, 0 - выключить)
#define max_bright 250        // максимальная яркость (0 - 255)
#define min_bright 70         // минимальная яркость (0 - 255)
#define bright_constant 1000  // константа усиления от внешнего света (0 - 1023), чем МЕНЬШЕ константа, тем "резче" будет прибавляться яркость
#define coef 0.7              // коэффициент фильтра (0.0 - 1.0), чем больше - тем медленнее меняется яркость
int new_bright, new_bright_f;
unsigned long bright_timer, off_timer;
//---------------------------------------------------------------------------------------------------
#define NUM_LEDS (LEDS_IN_SEGMENT * 28 + DOTS_NUM) // Вычислемые константы, НЕ РЕДАКТИРОВАТЬ!
//---------------------------------------------------------------------------------------------------
CRGB leds[NUM_LEDS]; //Задаём значение светодиодов
uint8_t  digits[] = {
  0b00111111,     // Digit 0
  0b00100001,     // Digit 1
  0b01110110,     // Digit 2
  0b01110011,     // Digit 3
  0b01101001,     // Digit 4
  0b01011011,     // Digit 5
  0b01011111,     // Digit 6
  0b00110001,     // Digit 7
  0b01111111,     // Digit 8
  0b01111011,     // Digit 9
  0b01111000,     // Digit * градус  10
  0b00011110,     // Digit C         11
  0b01111100,     // Digit P         12
  0b01111000,     // Digit % знак % из двух частей 13
  0b01000111,     // Digit % знак % из двух частей 14
};
//---------------------------------------------------------------------------------------------------
bool Dot = true;
bool TempShow = true;
int last_digit = 0;
//---------------------------------------------------------------------------------------------------
long ledColor = CRGB::Aqua; // Используемый цвет
long ColorTable[NUM_COLORS] = {
  CRGB::Amethyst,
  CRGB::Aqua,
  CRGB::Blue,
  CRGB::Chartreuse,
  CRGB::DarkGreen,
  CRGB::DarkMagenta,
  CRGB::DarkOrange,
  CRGB::DeepPink,
  CRGB::Fuchsia,
  CRGB::Gold,
  CRGB::GreenYellow,
  CRGB::LightCoral,
  CRGB::Tomato,
  CRGB::Red,
  CRGB::Orchid,
  CRGB::DarkOrchid
};
//---------------------------------------------------------------------------------------------------
void setup() {
  Serial.begin(9600);
  Wire.begin();
  LEDS.addLeds<WS2812, DATA_PIN, COLOR_ORDER>(leds, NUM_LEDS);
//---------------------------------------------------------------------------------------------------
  //LEDS.setBrightness(75); // Задаём яркость
  pinMode(4, INPUT_PULLUP); // Кнопка смены цветов
  pinMode(3, INPUT_PULLUP); // Кнопка смены минут
  pinMode(2, INPUT_PULLUP); // Кнопка смены часов
}
//---------------------------------------------------------------------------------------------------
void BrightDots (boolean Dot_On) {
  for (uint8_t i = 0; i < DOTS_NUM; i++) {
  leds[(LEDS_IN_SEGMENT * 14)+ i] = (Dot_On) ? ledColor : 0;
  }
}
//---------------------------------------------------------------------------------------------------
void BrightDigit (uint8_t digit, uint8_t cursor)
{
  for (uint8_t mask = 0b01000000; mask > 0; mask = mask >> 1)
  {
    for (uint8_t i = 0; i < LEDS_IN_SEGMENT; i++)
    {
      leds[cursor] = (digit & mask) ? ledColor : 0;
      cursor ++;
    }
  }
}
//---------------------------------------------------------------------------------------------------
//Массив управления яркостью 
void BrightnessCheck() {
  if (auto_bright) {                         // если включена адаптивная яркость
    if (millis() - bright_timer > 100) {     // каждые 100 мс
      bright_timer = millis();               // сброить таймер
      new_bright = map(analogRead(BRI_PIN), 0, bright_constant, min_bright, max_bright);   // считать показания с фоторезистора, перевести диапазон
      new_bright = constrain(new_bright, min_bright, max_bright);
      new_bright_f = new_bright_f * coef + new_bright * (1 - coef);
      LEDS.setBrightness(new_bright_f);      // установить новую яркость
    }
  }
};
//---------------------------------------------------------------------------------------------------
//  Получаем время в одном номере, если часы будет только одна цифра то будет отображаться 155  вместо 0155
int GetTime()
{
  tmElements_t Now;
  RTC.read(Now);
  int hour = Now.Hour;
  int minute = Now.Minute;
  int second = Now.Second;
  if (second % 2 == 0)
  {
    Dot = false;
  }
  else {
    Dot = true;
  };
  return (hour * 100 + minute);
};
//---------------------------------------------------------------------------------------------------
// Преобразуем время в массив для отображание
void TimeToArray() {
  int Now = GetTime(); // Получаем время
  BrightDots(Dot);
  for (int i = 1; i <= 4; i++) {
    int digit = Now % 10; // Получаем последнюю цифру в времени
    int cursor = NUM_LEDS - i * LEDS_IN_SEGMENT * 7;
    if (i > 2) {
      cursor -= DOTS_NUM;
    }
    BrightDigit(digits[digit], cursor);
    if ( i == COLOR_CHANGE) {
      if (digit != last_digit)
      {
        ledColor =  ColorTable[random(NUM_COLORS)];    // цикличное изменение цветов
      }
      last_digit = digit;
    }
    Now /= 10;
  };
};
//---------------------------------------------------------------------------------------------------
// Функция вывода температуры
/*/
 //Пример для DHT11
 void TempToArray() {
  tmElements_t tm;
  RTC.read(tm);
  if (tm.Second != 17) {
    TempShow = false;
    return;  }
  TempShow = true;
  int t = dht.readTemperature();
  int celsius = t * 100; 
  BrightDots(0);  //разделительные мигающие точки выключены
  BrightDigit(digits[11], (NUM_LEDS - LEDS_IN_SEGMENT * 7));    // начало знака Цельсия (С) 4й блок
  BrightDigit(digits[10], (NUM_LEDS - LEDS_IN_SEGMENT * 14));   // начало знака Градус (*) 3й блок
  int digit = celsius % 10;
  BrightDigit(digits[digit], (NUM_LEDS - LEDS_IN_SEGMENT * 21 - DOTS_NUM));  // 2й блок вывода второго символа
  celsius /= 10;
  digit = celsius % 10;
  BrightDigit(digits[digit], (NUM_LEDS - LEDS_IN_SEGMENT * 28 - DOTS_NUM));  // 1й блок вывода первого символа
};
 */
void TempToArray(){
  tmElements_t tm;
  RTC.read(tm);
  if (tm.Second != 30) {
    TempShow = false;
    return;
  }
  TempShow = true;
  int t = RTC.temperature();
  int celsius = (t / 4.0);
  BrightDots(0);  //разделительные мигающие точки выключены
  BrightDigit(digits[11], (NUM_LEDS - LEDS_IN_SEGMENT * 7));    // начало знака Цельсия (С) 4й блок
  BrightDigit(digits[10], (NUM_LEDS - LEDS_IN_SEGMENT * 14));   // начало знака Градус (*) 3й блок
  int digit = celsius % 10;
  BrightDigit(digits[digit], (NUM_LEDS - LEDS_IN_SEGMENT * 21 - DOTS_NUM));  // 2й блок вывода второго символа
  celsius /= 10;
  digit = celsius % 10;
  BrightDigit(digits[digit], (NUM_LEDS - LEDS_IN_SEGMENT * 28 - DOTS_NUM));  // 1й блок вывода первого символа
};
//---------------------------------------------------------------------------------------------------
//смена цвета кнопкой DST пин D4
void DSTcheck() {
  int buttonDST = digitalRead(4);
  if (buttonDST == LOW) {
    ledColor =  ColorTable[random(NUM_COLORS)];
  };
  delay(200);
};
//---------------------------------------------------------------------------------------------------
// Массив управляет кнопками с часами и минутами
void TimeAdjust() {
  int buttonH = digitalRead(2);
  int buttonM = digitalRead(3);
  if (buttonH == LOW || buttonM == LOW) {
    delay(200);
    tmElements_t Now;
    RTC.read(Now);
    int hour = Now.Hour;
    int minutes = Now.Minute;
    int second = Now.Second;
    if (buttonH == LOW) {
      if (Now.Hour == 23) {
        Now.Hour = 0;
      }
      else {
        Now.Hour += 1;
      };
    }
    else
    {
      if (Now.Minute == 59) {
        Now.Minute = 0;
      }
      else {
        Now.Minute += 1;
      };
    };
    RTC.write(Now);
  }
}
//---------------------------------------------------------------------------------------------------
//Меняем эффекты
void fadeall() {
  for (int i = 0; i < NUM_LEDS; i++) {
    leds[i].nscale8(250);
  }
}
//---------------------------------------------------------------------------------------------------
// массив отвечает за цикличное изменение цветов
void cylon () {
  static uint8_t hue = 0;
  Serial.print("x");
  // Сдвигаем один светодиод в любом направлении
  for (int i = 0; i < NUM_LEDS; i++) {
    // Устанавливаем 1 светодиод на цвет красный
    leds[i] = CHSV(hue++, 255, 255);
    // Показываем светодиоды
    FastLED.show();
    fadeall();
    // Ждём немного и повторяем цикл
    delay(10);
  }
  Serial.print("x");
//---------------------------------------------------------------------------------------------------
  // Сдвигаем один светодиод в любом направлении
  for (int i = (NUM_LEDS) - 1; i >= 0; i--) {
    // Устанавливаем 1 светодиод на цвет красный
    leds[i] = CHSV(hue++, 255, 255);
    // Показываем светодиоды
    FastLED.show();
    fadeall();
    // Ждём немного и повторяем цикл
    delay(10);
  }
}
//---------------------------------------------------------------------------------------------------
void loop() { 
  BrightnessCheck(); // Проверяем датчик
  DSTcheck(); // Проверяем режимы
  TimeAdjust(); // Проверяем время если сменилось на 1 цифру
  TimeToArray(); // Проверяем часы если сменилось на 1 цифру
  TempToArray();  // температура
  FastLED.show(); // Задаём массив светодиодов
  if (TempShow == true) delay (3000); // время отображения температуры (3000 = 3 сек)
}

Буду благодарен за исправление кода.

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

В ветке достаточно примеров работы на самых разных датчиках - DHT BME BMP - посмотрите внимательно и адаптируйте эти примеры под свой датчик.

ShevaLoL а в чем собственно проблема у вас в коде закоментирован пример для DHT11 поменяйте на 22 появится температура. добавьте чтение и вывод влажности будет влажность.

Ок, спасибо за ответ.

Ок, щас буду пробовать ковырять код.

Запустил часы на esp8266, но появились некоторые косяки. При переключении на показал температуры/давления/влажности светодиоды через один меняют свой оттенок. Это может произойти как во всех 3 вариантах либо вообще не появиться. Также при запуске анимации смены цвета несколько светодиодов 1го сегмента начинают мерцать. Есть ли такое на ардуино или это "фишки" esp?

#define FASTLED_ESP8266_RAW_PIN_ORDER

#include <ESP8266WiFi.h>
#include <WiFiUdp.h>
#include <Adafruit_BME280.h>
#include <FastLED.h>

#define LEDS_IN_SEGMENT 2                          // Задаём сколько у нас светодиодов в сегменте.
#define DOTS_NUM 2                                 // Задаём количество разделительных точек
#define COLOR_CHANGE 1                             // ( 0 - НИКОГДА, 1 - каждую минуту, 2 - каждые 10 минут, 3 - каждый час, 4 - каждые 10 часов)
#define NUM_COLORS 16                              // цветовая гамма
#define COLOR_ORDER BGR                            // По умолчанию цвет стоит зелёный при выключенных режимах
#define DATA_PIN D6                                // подключение ленты
#define BRI_PIN A0                                 // фоторезистор
#define auto_bright 0                              // автоматическая подстройка яркости от уровня внешнего освещения (1 - включить, 0 - выключить)
#define max_bright 227                             // максимальная яркость (0 - 255)
#define min_bright 0                               // минимальная яркость (0 - 255)
#define bright_constant 1010                       // константа усиления от внешнего света (0 - 1023), чем МЕНЬШЕ константа, тем "резче" будет прибавляться яркость
#define coef 0.7                                   // коэффициент фильтра (0.0 - 1.0), чем больше - тем медленнее меняется яркость
#define AP_SSID "Mi 5"                             // Логин к вашему WiFi(кавычки оставить)
#define AP_PASS "22222222"                         // Пароль у вашему WiFi
#define TIMEZONE 6                                 // Часовой пояс
#define NUM_LEDS (LEDS_IN_SEGMENT * 28 + DOTS_NUM) //количество светодиодов в ленте

int new_bright, new_bright_f;
unsigned long bright_timer, off_timer;

Adafruit_BME280 bme; // BME280 давление, влажность, температура   I2C

unsigned int localPort = 2390; // local port to listen for UDP packets
unsigned int err_count = 0;

unsigned long ntp_time = 0;
unsigned long Next_ms = 3600000;
unsigned long cur_ms = 0;
unsigned long t_cur = 0;
unsigned long ms1 = 0;
unsigned long ms2 = 10000000UL;

long t_correct = 0;

uint16_t my_s = 0;
uint16_t my_m = 0;
uint16_t my_h = 0;

bool NtpNoConn = false;

IPAddress timeServerIP;
const char *ntpServerName = "0.ru.pool.ntp.org";

const int NTP_PACKET_SIZE = 48;
byte packetBuffer[NTP_PACKET_SIZE];
WiFiUDP udp;

CRGB leds[NUM_LEDS]; //Задаём значение светодиодов, какой символ из чего состоит
uint8_t digits[] = {
    0b00111111, // Digit 0
    0b00100001, // Digit 1
    0b01110110, // Digit 2
    0b01110011, // Digit 3
    0b01101001, // Digit 4
    0b01011011, // Digit 5
    0b01011111, // Digit 6
    0b00110001, // Digit 7
    0b01111111, // Digit 8
    0b01111011, // Digit 9
    0b01111000, // Digit * градус  10
    0b00011110, // Digit C         11
    0b01111100, // Digit P         12
    0b01111000, // Digit % знак % из двух частей 13
    0b01000111, // Digit % знак % из двух частей 14
    0b11000000, // Digit - 15
};

bool Dot = true;
bool TempShow = true;
bool PressureShow = true;
bool HumidityShow = true;
int last_digit = 0;

long ledColor = CRGB::MediumSpringGreen; // Используемый цвет
long ColorTable[NUM_COLORS] = {
    CRGB::Amethyst,
    CRGB::Aqua,
    CRGB::Blue,
    CRGB::Chartreuse,
    CRGB::DarkGreen,
    CRGB::DarkMagenta,
    CRGB::DarkOrange,
    CRGB::DeepPink,
    CRGB::Fuchsia,
    CRGB::Gold,
    CRGB::GreenYellow,
    CRGB::LightCoral,
    CRGB::Tomato,
    //CRGB::Salmon,
    CRGB::Red,
    CRGB::Orchid,
    CRGB::DarkOrchid};

/**
 * Соединение с WiFi
 */
bool ConnectWiFi(const char *ssid, const char *pass)
{
  // Три попытки соединения по WiFi
  for (int i = 0; i < 3; i++)
  {
    Serial.print("\nConnecting to: ");
    Serial.println(ssid);
    WiFi.begin(ssid, pass);
    delay(1000);
    // Максиммум 12 раз проверка соединения
    for (int j = 0; j < 12; j++)
    {
      if (WiFi.status() == WL_CONNECTED)
      {
        Serial.print("\nWiFi connect true: ");
        Serial.print(WiFi.localIP());
        Serial.print("/");
        Serial.print(WiFi.subnetMask());
        Serial.print("/");
        Serial.println(WiFi.gatewayIP());
        return true;
      }
      delay(1000);
      Serial.print(WiFi.status());
    }
  }
  Serial.println("\nConnect WiFi failed ...");
  return false;
}

unsigned long sendNTPpacket(IPAddress &address)
{
  Serial.println("sending NTP packet...");
  // Очистка буфера в 0
  memset(packetBuffer, 0, NTP_PACKET_SIZE);
  // Формируем строку зыпроса NTP сервера
  packetBuffer[0] = 0b11100011; // LI, Version, Mode
  packetBuffer[1] = 0;          // Stratum, or type of clock
  packetBuffer[2] = 6;          // Polling Interval
  packetBuffer[3] = 0xEC;       // Peer Clock Precision
  // 8 bytes of zero for Root Delay & Root Dispersion
  packetBuffer[12] = 49;
  packetBuffer[13] = 0x4E;
  packetBuffer[14] = 49;
  packetBuffer[15] = 52;
  // Посылаем запрос на NTP сервер (123 порт)
  udp.beginPacket(address, 123);
  udp.write(packetBuffer, NTP_PACKET_SIZE);
  udp.endPacket();
}

/**
 * Посылаем и парсим запрос к NTP серверу
 */
bool GetNTP(void)
{
  Serial.println("Starting UDP");
  udp.begin(localPort);
  Serial.print("Local port: ");
  Serial.println(udp.localPort());
  WiFi.hostByName(ntpServerName, timeServerIP);
  sendNTPpacket(timeServerIP);
  delay(1000);

  int cb = udp.parsePacket();
  if (!cb)
  {
    Serial.println("No packet yet");
    return false;
  }
  else
  {
    Serial.print("packet received, length=");
    Serial.println(cb);
    // Читаем пакет в буфер
    udp.read(packetBuffer, NTP_PACKET_SIZE);
    // 4 байта начиная с 40-го сождержат таймстамп времени - число секунд
    // от 01.01.1900
    unsigned long highWord = word(packetBuffer[40], packetBuffer[41]);
    unsigned long lowWord = word(packetBuffer[42], packetBuffer[43]);
    // Конвертируем два слова в переменную long
    unsigned long secsSince1900 = highWord << 16 | lowWord;
    // Конвертируем в UNIX-таймстамп (число секунд от 01.01.1970
    const unsigned long seventyYears = 2208988800UL;
    unsigned long epoch = secsSince1900 - seventyYears;
    // Делаем поправку на местную тайм-зону
    ntp_time = epoch + TIMEZONE * 3600;
    Serial.print("Unix time = ");
    Serial.println(ntp_time);
    udp.flush(); //empty UDP library rxBuffer
    udp.stop();  //stop client & close connection/socket
    //WiFi.mode(WIFI_OFF);
  }
  return true;
}

//новые координаты точек
void BrightDots(boolean Dot_On)
{
  for (uint8_t i = 0; i < DOTS_NUM; i++)
  {
    leds[(LEDS_IN_SEGMENT * 14) + i] = (Dot_On) ? ledColor : 0;
  }
  //leds[DOT2] = (Dot_On) ? ledColor : 0;
}

void BrightDigit(uint8_t digit, uint8_t cursor)
{
  for (uint8_t mask = 0b01000000; mask > 0; mask = mask >> 1)
  {
    for (uint8_t i = 0; i < LEDS_IN_SEGMENT; i++)
    {
      leds[cursor] = (digit & mask) ? ledColor : 0;
      cursor++;
    }
  }
};

//Массив управляет яркостью
// Новый метод изменения яркости
void BrightnessCheck()
{

  if (auto_bright)
  { // если включена адаптивная яркость
    if (millis() - bright_timer > 100)
    {                                                                                    // каждые 100 мс
      bright_timer = millis();                                                           // сбросить таймер
      new_bright = map(analogRead(BRI_PIN), 0, bright_constant, min_bright, max_bright); // считать показания с фоторезистора, перевести диапазон
      new_bright = constrain(new_bright, min_bright, max_bright);
      new_bright_f = new_bright_f * coef - new_bright * (1 - coef);
      LEDS.setBrightness(new_bright_f); // установить новую яркость
    }
  }
};

//  Получаем время в одном номере, если часы будет только одна цифра то будет отображаться 155  вместо 0155
int GetTime()
{

  my_h = (ntp_time / 3600) % 24;
  my_m = (ntp_time / 60) % 60;
  my_s = ntp_time % 60;

  if (my_s % 2 == 0)
  {
    Dot = false;
  }
  else
  {
    Dot = true;
  };
  return (my_h * 100 + my_m);
};

//Меняем эффекты
void fadeall()
{
  for (int i = 0; i < NUM_LEDS; i++)
  {
    leds[i].nscale8(250);
  }
}

// массив отвечает за цикличное изменение цветов
void cylon()
{
  static uint8_t hue = 0;
  //Serial.print("x");
  // Сдвигаем один светодиод в любом направлении
  for (int i = 0; i < NUM_LEDS; i++)
  {
    // Устанавливаем 1 светодиод на цвет красный
    leds[i] = CHSV(hue++, 255, 255);
    // Показываем светодиоды
    FastLED.show();
    fadeall();
    // Ждём немного и повторяем цикл
    delay(20);
  }
  //Serial.print("x");

  // Сдвигаем один светодиод в любом направлении
  for (int i = (NUM_LEDS)-1; i >= 0; i--)
  {
    // Устанавливаем 1 светодиод на цвет красный
    leds[i] = CHSV(hue++, 255, 255);
    // Показываем светодиоды
    FastLED.show();
    fadeall();
    // Ждём немного и повторяем цикл
    delay(20);
  }
}

// Преобразуем время в массив для отображание

void TimeToArray()
{
  int Now = GetTime(); // Получаем время
  BrightDots(Dot);

  for (int i = 1; i <= 4; i++)
  {
    int digit = Now % 10; // Получаем последнюю цифру в времени
    int cursor = NUM_LEDS - i * LEDS_IN_SEGMENT * 7;
    if (i > 2)
    {
      cursor -= 2;
    }
    if ((i != 4) || (digit != 0))
      BrightDigit(digits[digit], cursor);
    else
      BrightDigit(0, cursor);
    if (i == COLOR_CHANGE)
    {
      if (digit != last_digit)
      {
        cylon();                                   // цикличное изменение цветов
        ledColor = ColorTable[random(NUM_COLORS)]; // цикличное изменение цветов
      }
      last_digit = digit;
    }
    Now /= 10;
  };
};

// Функция вывода метеоданных
// Преобразуем Temp в массив для отображение
void TempToArray()
{
  if (my_s != 25)
  { //через какое время показывать температуруi
    TempShow = false;
    return;
  }
  TempShow = true;
  int celsius = bme.readTemperature(); //int t = bmp.readTemperature();
  BrightDots(0);                       //разделительные мигающие точки выключены

  if (celsius < 0)
  {
    BrightDigit(digits[15], (NUM_LEDS - LEDS_IN_SEGMENT * 28 - DOTS_NUM)); //1й блок
    BrightDigit(digits[10], (NUM_LEDS - LEDS_IN_SEGMENT * 7));             //4й блок
    int digit = celsius % 10;
    BrightDigit(digits[digit], (NUM_LEDS - LEDS_IN_SEGMENT * 14)); //3й блок
    celsius /= 10;
    digit = celsius % 10;
    BrightDigit(digits[digit], (NUM_LEDS - LEDS_IN_SEGMENT * 21 - DOTS_NUM)); //2й блок
  }
  else
  {
    BrightDigit(0, (NUM_LEDS - LEDS_IN_SEGMENT * 28 - DOTS_NUM)); //1й блок
    BrightDigit(digits[10], (NUM_LEDS - LEDS_IN_SEGMENT * 7));    //4й блок
    int digit = celsius % 10;
    BrightDigit(digits[digit], (NUM_LEDS - LEDS_IN_SEGMENT * 14)); //3й блок
    celsius /= 10;
    digit = celsius % 10;
    BrightDigit(digits[digit], (NUM_LEDS - LEDS_IN_SEGMENT * 21 - DOTS_NUM)); //2й блок
  }
};

// Измеряем давление
void PressureToArray()
{
  if (my_s != 30)
  { //через какое время показывать давление
    PressureShow = false;
    return;
  }
  PressureShow = true;
  int Pressure = bme.readPressure() / 133.322;                           //int p = bmp.readPressure() / 133.322;c
  BrightDots(0);                                                         //разделительные мигающие точки выключены
  BrightDigit(digits[12], (NUM_LEDS - LEDS_IN_SEGMENT * 28 - DOTS_NUM)); //0  начало знака Давления (Р) 1й блокh
  int digit = Pressure % 10;
  BrightDigit(digits[digit], (NUM_LEDS - LEDS_IN_SEGMENT * 7)); //65  4й блок вывода третьей цифры значения
  Pressure /= 10;
  digit = Pressure % 10;
  BrightDigit(digits[digit], (NUM_LEDS - LEDS_IN_SEGMENT * 14)); //44  3й блок вывода второй цифры значенияk
  Pressure /= 10;
  digit = Pressure % 10;
  BrightDigit(digits[digit], (NUM_LEDS - LEDS_IN_SEGMENT * 21 - DOTS_NUM)); //21  2й блок вывода первой цифры значения
};

//Вывод влажности
//Переделано на BME280  //Пример на DHT11
void HumidityToArray()
{
  if (my_s != 35)
  { //через какое время показывать влажность
    HumidityShow = false;
    return;
  }
  HumidityShow = true;
  int humidity = bme.readHumidity();                          //int h = dht.readHumidity();
  BrightDots(0);                                              //разделительные мигающие точки выключены
  BrightDigit(digits[14], (NUM_LEDS - LEDS_IN_SEGMENT * 7));  //65  конец знака процентов (%) 4й блок
  BrightDigit(digits[13], (NUM_LEDS - LEDS_IN_SEGMENT * 14)); //44  начало знака процентов (%) 3 блок
  int digit = humidity % 10;
  BrightDigit(digits[digit], (NUM_LEDS - LEDS_IN_SEGMENT * 21 - DOTS_NUM)); //21  2й блок вывода второго символаA
  humidity /= 10;
  digit = humidity % 10;
  BrightDigit(digits[digit], (NUM_LEDS - LEDS_IN_SEGMENT * 28 - DOTS_NUM)); //0  1й блок вывода первого символа
};

void setup()
{
  if (!ConnectWiFi(AP_SSID, AP_PASS))
  {
    Serial.println("Reset ESP8266 ...");
    ESP.reset();
  }
  Serial.begin(9600);
  LEDS.addLeds<WS2812B, DATA_PIN, COLOR_ORDER>(leds, NUM_LEDS).setCorrection(TypicalLEDStrip);
  LEDS.setBrightness(3); // Задаём яркость
  bme.begin();           //bmp.begin(); //датчик температуры
}

void loop()
{
  cur_ms = millis();
  t_cur = cur_ms / 1000;
  // Каждые 24 часа считываем время в интернете
  if (cur_ms < ms2 || (cur_ms - ms2) > Next_ms)
  {
    err_count++;
    // Делаем три  попытки синхронизации с интернетом
    NtpNoConn = false;
    if (GetNTP())
    {
      ms2 = cur_ms;
      err_count = 0;
      t_correct = ntp_time - t_cur;
      NtpNoConn = true;
      Next_ms = 86400000;
    }
    else
    {
      Next_ms = 60000;
    } //соединяемся через минуту
  }

  // Каждые  секунду выдаем время
  if (cur_ms < ms1 || (cur_ms - ms1) > 1000)
  {
    ms1 = cur_ms;
    ntp_time = t_cur + t_correct;

    /*     Serial.print("Time: ");
    Serial.print(my_h);
    Serial.print(":");
    Serial.print(my_m);
    Serial.print(":");
    Serial.println(my_s);
    Serial.print("Temperature = ");
    Serial.print(bme.readTemperature());
    Serial.println(" *C");
    Serial.print("Pressure = ");
    Serial.print(bme.readPressure() / 133.322);
    Serial.println(" mm.pt");
    Serial.print("Humidity = ");
    Serial.print(bme.readHumidity());
    Serial.println(" %");
    Serial.println(); */
  }
  // Если нет соединения с интернетом, перезагружаемся
  if (err_count > 10)
  {
    Serial.println("NTP connect false");
    Serial.println("Reset ESP8266 ...");
    ESP.reset();
  }

  BrightnessCheck(); // Проверяем датчик освещения
  TimeToArray();     // часы
  TempToArray();     // температура
  PressureToArray(); // давление
  HumidityToArray(); // если будет влажность
  FastLED.show();    // Задаём массив светодиодов
  if (TempShow == true)
    delay(5000); //время показа температуры
  if (PressureShow == true)
    delay(5000); //время показа давления
  if (HumidityShow == true)
    delay(5000); //время показа влажности
}

есть подозрение, что вай-фай и ФастЛед плохо уживаются вместе. Соберите этот же код на ЕСП, но с выключенным Вайфаем - и посмотрите, сохранятся ли глюки с цветом пикселей.

Если окажется, что я прав - можно попробовать на время запуска конструкции FastLed.show() выключать WiFi

Insert #define FASTLED_ALLOW_INTERRUPTS 0 before the #include <FastLED.h>

Поковырялся, разобрался, получилось)))) Показывает влажность и температуру с датчика DHT22.

Вот рабочий код:

/*
Подключение к Arduino nano:
Часы DS3231:    SCL -> A5
                SDA -> A4
Датчик освещения    -> A3                
Кнопки: Смена часов -> D2 
        Смена минут -> D3
        Смена цвета -> D4
Лента WS2811(WS2812)-> D13
*/
//---------------------------------------------------------------------------------------------------
#include <DS3232RTC.h>
#include <Time.h>
#include <Wire.h>
#include <FastLED.h>
#include <DHT.h>
#include <DHT_U.h>



#define LEDS_IN_SEGMENT 1     // Задаём сколько у нас светодиодов в сегменте
#define DOTS_NUM 2            // Задаём сколько у нас разделительных точек
#define COLOR_CHANGE 2        // Смена цвета ( 0 - никогда, 1 - раз в минуту, 2 - каждые десять минут, 3 - каждый час, 4 - каждые десять часов)
#define NUM_COLORS 16         // Количество цветов
#define COLOR_ORDER BGR       // По умолчанию цвет стоит зелёный при выключенных режимах
#define DATA_PIN 13           // Пин ленты 
#define BRI_PIN A3            // PIN фоторезистора
#define auto_bright 1         // автоматическая подстройка яркости от уровня внешнего освещения (1 - включить, 0 - выключить)
#define max_bright 250        // максимальная яркость (0 - 255)
#define min_bright 70         // минимальная яркость (0 - 255)
#define bright_constant 1000  // константа усиления от внешнего света (0 - 1023), чем МЕНЬШЕ константа, тем "резче" будет прибавляться яркость
#define coef 0.9              // коэффициент фильтра (0.0 - 1.0), чем больше - тем медленнее меняется яркость
int new_bright, new_bright_f;
unsigned long bright_timer, off_timer;
DHT dht(5, DHT22);
//---------------------------------------------------------------------------------------------------
#define NUM_LEDS (LEDS_IN_SEGMENT * 28 + DOTS_NUM) // Вычислемые константы, НЕ РЕДАКТИРОВАТЬ!
//---------------------------------------------------------------------------------------------------
CRGB leds[NUM_LEDS]; //Задаём значение светодиодов
uint8_t  digits[] = {
  0b00111111,     // Digit 0
  0b00100001,     // Digit 1
  0b01110110,     // Digit 2
  0b01110011,     // Digit 3
  0b01101001,     // Digit 4
  0b01011011,     // Digit 5
  0b01011111,     // Digit 6
  0b00110001,     // Digit 7
  0b01111111,     // Digit 8
  0b01111011,     // Digit 9
  0b01111000,     // Digit * градус  10
  0b00011110,     // Digit C         11
  0b01111100,     // Digit P         12
  0b01111000,     // Digit % знак % из двух частей 13
  0b01000111,     // Digit % знак % из двух частей 14
};
//---------------------------------------------------------------------------------------------------
bool Dot = true;
bool DST = false;
bool TempShow = true;
bool HumidityShow = true;
int last_digit = 0;
//---------------------------------------------------------------------------------------------------
long ledColor = CRGB::Aqua; // Используемый цвет
long ColorTable[NUM_COLORS] = {
  CRGB::Amethyst,
  CRGB::Aqua,
  CRGB::Blue,
  CRGB::Chartreuse,
  CRGB::DarkGreen,
  CRGB::DarkMagenta,
  CRGB::DarkOrange,
  CRGB::DeepPink,
  CRGB::Fuchsia,
  CRGB::Gold,
  CRGB::GreenYellow,
  CRGB::LightCoral,
  CRGB::Tomato,
  CRGB::Red,
  CRGB::Orchid,
  CRGB::DarkOrchid
};
//---------------------------------------------------------------------------------------------------
void setup() {
  Serial.begin(9600);
  Wire.begin();
  dht.begin(); //датчик влажности
  LEDS.addLeds<WS2812, DATA_PIN, COLOR_ORDER>(leds, NUM_LEDS);
//---------------------------------------------------------------------------------------------------
  //LEDS.setBrightness(75); // Задаём яркость
  pinMode(4, INPUT_PULLUP); // Кнопка смены цветов
  pinMode(3, INPUT_PULLUP); // Кнопка смены минут
  pinMode(2, INPUT_PULLUP); // Кнопка смены часов
}
//---------------------------------------------------------------------------------------------------
void BrightDots (boolean Dot_On) {
  for (uint8_t i = 0; i < DOTS_NUM; i++) {
  leds[(LEDS_IN_SEGMENT * 14)+ i] = (Dot_On) ? ledColor : 0;
  }
}
//---------------------------------------------------------------------------------------------------
void BrightDigit (uint8_t digit, uint8_t cursor)
{
  for (uint8_t mask = 0b01000000; mask > 0; mask = mask >> 1)
  {
    for (uint8_t i = 0; i < LEDS_IN_SEGMENT; i++)
    {
      leds[cursor] = (digit & mask) ? ledColor : 0;
      cursor ++;
    }
  }
}
//---------------------------------------------------------------------------------------------------
//Массив управления яркостью 
void BrightnessCheck() {
  if (auto_bright) {                         // если включена адаптивная яркость
    if (millis() - bright_timer > 100) {     // каждые 100 мс
      bright_timer = millis();               // сброить таймер
      new_bright = map(analogRead(BRI_PIN), 0, bright_constant, min_bright, max_bright);   // считать показания с фоторезистора, перевести диапазон
      new_bright = constrain(new_bright, min_bright, max_bright);
      new_bright_f = new_bright_f * coef + new_bright * (1 - coef);
      LEDS.setBrightness(new_bright_f);      // установить новую яркость
    }
  }
};
//---------------------------------------------------------------------------------------------------
//  Получаем время в одном номере, если часы будет только одна цифра то будет отображаться 155  вместо 0155
int GetTime()
{
  tmElements_t Now;
  RTC.read(Now);
  int hour = Now.Hour;
  int minute = Now.Minute;
  int second = Now.Second;
  if (second % 2 == 0)
  {
    Dot = false;
  }
  else {
    Dot = true;
  };
  return (hour * 100 + minute);
};
//---------------------------------------------------------------------------------------------------
// Преобразуем время в массив для отображание
void TimeToArray() {
  int Now = GetTime(); // Получаем время
  BrightDots(Dot);
  for (int i = 1; i <= 4; i++) {
    int digit = Now % 10; // Получаем последнюю цифру в времени
    int cursor = NUM_LEDS - i * LEDS_IN_SEGMENT * 7;
    if (i > 2) {
      cursor -= DOTS_NUM;
    }
    BrightDigit(digits[digit], cursor);
    if ( i == COLOR_CHANGE) {
      if (digit != last_digit)
      {
        ledColor =  ColorTable[random(NUM_COLORS)];    // цикличное изменение цветов
      }
      last_digit = digit;
    }
    Now /= 10;
  };
};
//---------------------------------------------------------------------------------------------------
// Функция вывода температуры
 //Пример для DHT22
void TempToArray() {
  tmElements_t tm;
 //bmp.begin();
  RTC.read(tm);
  if (tm.Second != 20) {//через какое время показывать температуру
    TempShow = false;
    return; }
  TempShow = true;
//  delay(3000);
  int t = dht.readTemperature();
  int celsius = t;
  BrightDots(0);  //разделительные мигающие точки выключены
  BrightDigit(digits[11], (NUM_LEDS - LEDS_IN_SEGMENT * 7));    //65  начало знака Цельсия (*) 4й блок
  BrightDigit(digits[10], (NUM_LEDS - LEDS_IN_SEGMENT * 14));   //44  начало знака Градус (С) 3 блок
  int digit = celsius % 10;
  BrightDigit(digits[digit], (NUM_LEDS - LEDS_IN_SEGMENT * 21 - 2));  //21  2й блок вывода второго символа
  celsius /= 10;
  digit = celsius % 10;
  BrightDigit(digits[digit], (NUM_LEDS - LEDS_IN_SEGMENT * 28 - 2));  //0  1й блок вывода первого символа
};
// \/\/\/\/\/\/ЗАКОМЕНТИРОВАТЬ ЕСЛИ НЕ ПОЛУЧИТСЯ\/\/\/\/
//============ЗАКОМЕНТИРОВАТЬ ЕСЛИ НЕ ПОЛУЧИТСЯ============
 //Вывод влажности
 //Пример на DHT22
 void HumidityToArray() {
  tmElements_t tm;
  RTC.read(tm);
  if (tm.Second != 35) {//через какое время показывать влажность
    HumidityShow = false;
    return; 
  }
  HumidityShow = true;
//  delay(3000);
  int h = dht.readHumidity();
  int humidity = h;
  BrightDots(0);  //разделительные мигающие точки выключены
  BrightDigit(digits[14], (NUM_LEDS - LEDS_IN_SEGMENT * 7));    //65  конец знака процентов (%) 4й блок
  BrightDigit(digits[13], (NUM_LEDS - LEDS_IN_SEGMENT * 14));   //44  начало знака процентов (%) 3 блок
  int digit = humidity % 10;
  BrightDigit(digits[digit], (NUM_LEDS - LEDS_IN_SEGMENT * 21 - 2));  //21  2й блок вывода второго символа
  humidity /= 10;
  digit = humidity % 10;
  BrightDigit(digits[digit], (NUM_LEDS - LEDS_IN_SEGMENT * 28 - 2));  //0  1й блок вывода первого символа
};
// ЗАКОМЕНТИРОВАТЬ ЕСЛИ НЕ ПОЛУЧИТСЯ
//^^^^^^^^^^^^^^^^^ЗАКОМЕНТИРОВАТЬ ЕСЛИ НЕ ПОЛУЧИТСЯ^^^^^^^^^^^^^^^^
//---------------------------------------------------------------------------------------------------
//смена цвета кнопкой DST пин D4
void DSTcheck() {
  int buttonDST = digitalRead(4);
  if (buttonDST == LOW) {
    ledColor =  ColorTable[random(NUM_COLORS)];
  };
  delay(200);
};
//---------------------------------------------------------------------------------------------------
// Массив управляет кнопками с часами и минутами
void TimeAdjust() {
  int buttonH = digitalRead(2);
  int buttonM = digitalRead(3);
  if (buttonH == LOW || buttonM == LOW) {
    delay(200);
    tmElements_t Now;
    RTC.read(Now);
    int hour = Now.Hour;
    int minutes = Now.Minute;
    int second = Now.Second;
    if (buttonH == LOW) {
      if (Now.Hour == 23) {
        Now.Hour = 0;
      }
      else {
        Now.Hour += 1;
      };
    }
    else
    {
      if (Now.Minute == 59) {
        Now.Minute = 0;
      }
      else {
        Now.Minute += 1;
      };
    };
    RTC.write(Now);
  }
}
//---------------------------------------------------------------------------------------------------
//Меняем эффекты
void fadeall() {
  for (int i = 0; i < NUM_LEDS; i++) {
    leds[i].nscale8(250);
  }
}
//---------------------------------------------------------------------------------------------------
// массив отвечает за цикличное изменение цветов
void cylon () {
  static uint8_t hue = 0;
  Serial.print("x");
  // Сдвигаем один светодиод в любом направлении
  for (int i = 0; i < NUM_LEDS; i++) {
    // Устанавливаем 1 светодиод на цвет красный
    leds[i] = CHSV(hue++, 255, 255);
    // Показываем светодиоды
    FastLED.show();
    fadeall();
    // Ждём немного и повторяем цикл
    delay(10);
  }
  Serial.print("x");
//---------------------------------------------------------------------------------------------------
  // Сдвигаем один светодиод в любом направлении
  for (int i = (NUM_LEDS) - 1; i >= 0; i--) {
    // Устанавливаем 1 светодиод на цвет красный
    leds[i] = CHSV(hue++, 255, 255);
    // Показываем светодиоды
    FastLED.show();
    fadeall();
    // Ждём немного и повторяем цикл
    delay(10);
  }
}
//---------------------------------------------------------------------------------------------------
void loop() { 
  BrightnessCheck(); // Проверяем датчик
  DSTcheck(); // Проверяем режимы
  TimeAdjust(); // Проверяем время если сменилось на 1 цифру
  TimeToArray(); // Проверяем часы если сменилось на 1 цифру
  TempToArray();  // температура
  HumidityToArray(); //если будет влажность
  FastLED.show(); // Задаём массив светодиодов
  if (TempShow == true) delay (5000); // время отображения температуры (5000 = 5 сек)
  if (HumidityShow == true) delay (5000);//время показа влажности
}

Спасибо большое b707, dj-toxa за наводки. А OdinochkA за твои труды (взял твой код для переделки).

Убрал wifi, но косяки остались. Вернув значение delay в 10 в cylon мерцание стало практически незаметным(оно длиться в пределах движения "змейки" по первому сегменту, а дальше все нормально). Да и разные оттенки через рассеиватель, наверное, будет не заметны. Один раз разные оттенки проскочили в таком виде

#define FASTLED_ESP8266_RAW_PIN_ORDER
#define FASTLED_ALLOW_INTERRUPTS 0

#include <Adafruit_BME280.h>
#include <FastLED.h>

#define LEDS_IN_SEGMENT 2                          // Задаём сколько у нас светодиодов в сегменте.
#define DOTS_NUM 2                                 // Задаём количество разделительных точек
#define COLOR_CHANGE 1                             // ( 0 - НИКОГДА, 1 - каждую минуту, 2 - каждые 10 минут, 3 - каждый час, 4 - каждые 10 часов)
#define NUM_COLORS 16                              // цветовая гамма
#define COLOR_ORDER BGR                            // По умолчанию цвет стоит зелёный при выключенных режимах
#define DATA_PIN D6                                // подключение ленты
#define NUM_LEDS (LEDS_IN_SEGMENT * 28 + DOTS_NUM) //количество светодиодов в ленте

int new_bright, new_bright_f;
unsigned long bright_timer, off_timer;

Adafruit_BME280 bme; // BME280 давление, влажность, температура   I2C

unsigned long cur_ms = 0;
unsigned long t_cur = 0;
unsigned long ms1 = 0;

uint16_t my_s = 0;
uint16_t my_m = 0;
uint16_t my_h = 0;

CRGB leds[NUM_LEDS]; //Задаём значение светодиодов, какой символ из чего состоит
uint8_t digits[] = {
    0b00111111, // Digit 0
    0b00100001, // Digit 1
    0b01110110, // Digit 2
    0b01110011, // Digit 3
    0b01101001, // Digit 4
    0b01011011, // Digit 5
    0b01011111, // Digit 6
    0b00110001, // Digit 7
    0b01111111, // Digit 8
    0b01111011, // Digit 9
    0b01111000, // Digit * градус  10
    0b00011110, // Digit C         11
    0b01111100, // Digit P         12
    0b01111000, // Digit % знак % из двух частей 13
    0b01000111, // Digit % знак % из двух частей 14
    0b11000000, // Digit - 15
};

bool Dot = true;
bool TempShow = true;
bool PressureShow = true;
bool HumidityShow = true;
int last_digit = 0;

long ledColor = CRGB::MediumSpringGreen; // Используемый цвет
long ColorTable[NUM_COLORS] = {
    CRGB::Amethyst,
    CRGB::Aqua,
    CRGB::Blue,
    CRGB::Chartreuse,
    CRGB::DarkGreen,
    CRGB::DarkMagenta,
    CRGB::DarkOrange,
    CRGB::DeepPink,
    CRGB::Fuchsia,
    CRGB::Gold,
    CRGB::GreenYellow,
    CRGB::LightCoral,
    CRGB::Tomato,
    //CRGB::Salmon,
    CRGB::Red,
    CRGB::Orchid,
    CRGB::DarkOrchid};

//новые координаты точек
void BrightDots(boolean Dot_On)
{
  for (uint8_t i = 0; i < DOTS_NUM; i++)
  {
    leds[(LEDS_IN_SEGMENT * 14) + i] = (Dot_On) ? ledColor : 0;
  }
  //leds[DOT2] = (Dot_On) ? ledColor : 0;
}

void BrightDigit(uint8_t digit, uint8_t cursor)
{
  for (uint8_t mask = 0b01000000; mask > 0; mask = mask >> 1)
  {
    for (uint8_t i = 0; i < LEDS_IN_SEGMENT; i++)
    {
      leds[cursor] = (digit & mask) ? ledColor : 0;
      cursor++;
    }
  }
};

//  Получаем время в одном номере, если часы будет только одна цифра то будет отображаться 155  вместо 0155
int GetTime()
{

  if (my_s % 2 == 0)
  {
    Dot = false;
  }
  else
  {
    Dot = true;
  };
  return (my_h * 100 + my_m);
};

//Меняем эффекты
void fadeall()
{
  for (int i = 0; i < NUM_LEDS; i++)
  {
    leds[i].nscale8(250);
  }
}

// массив отвечает за цикличное изменение цветов
void cylon()
{
  static uint8_t hue = 0;
  //Serial.print("x");
  // Сдвигаем один светодиод в любом направлении
  for (int i = 0; i < NUM_LEDS; i++)
  {
    // Устанавливаем 1 светодиод на цвет красный
    leds[i] = CHSV(hue++, 255, 255);
    // Показываем светодиоды
    
    fadeall();
    FastLED.show();
    // Ждём немного и повторяем цикл
    delay(10);
  }
  //Serial.print("x");

  // Сдвигаем один светодиод в любом направлении
  for (int i = (NUM_LEDS)-1; i >= 0; i--)
  {
    // Устанавливаем 1 светодиод на цвет красный
    leds[i] = CHSV(hue++, 255, 255);
    // Показываем светодиоды
    
    fadeall();
    FastLED.show();
    // Ждём немного и повторяем цикл
    delay(10);
  }
}

// Преобразуем время в массив для отображание

void TimeToArray()
{
  int Now = GetTime(); // Получаем время
  BrightDots(Dot);

  for (int i = 1; i <= 4; i++)
  {
    int digit = Now % 10; // Получаем последнюю цифру в времени
    int cursor = NUM_LEDS - i * LEDS_IN_SEGMENT * 7;
    if (i > 2)
    {
      cursor -= 2;
    }
    if ((i != 4) || (digit != 0))
      BrightDigit(digits[digit], cursor);
    else
      BrightDigit(0, cursor);
    if (i == COLOR_CHANGE)
    {
      if (digit != last_digit)
      {
        cylon();                                   // цикличное изменение цветов
        ledColor = ColorTable[random(NUM_COLORS)]; // цикличное изменение цветов
      }
      last_digit = digit;
    }
    Now /= 10;
  };
};

// Функция вывода метеоданных
// Преобразуем Temp в массив для отображение
void TempToArray()
{
  if (my_s != 25)
  { //через какое время показывать температуруi
    TempShow = false;
    return;
  }
  TempShow = true;
  int celsius = bme.readTemperature(); //int t = bmp.readTemperature();
  BrightDots(0);                       //разделительные мигающие точки выключены

  if (celsius < 0)
  {
    BrightDigit(digits[15], (NUM_LEDS - LEDS_IN_SEGMENT * 28 - DOTS_NUM)); //1й блок
    BrightDigit(digits[10], (NUM_LEDS - LEDS_IN_SEGMENT * 7));             //4й блок
    int digit = celsius % 10;
    BrightDigit(digits[digit], (NUM_LEDS - LEDS_IN_SEGMENT * 14)); //3й блок
    celsius /= 10;
    digit = celsius % 10;
    BrightDigit(digits[digit], (NUM_LEDS - LEDS_IN_SEGMENT * 21 - DOTS_NUM)); //2й блок
  }
  else
  {
    BrightDigit(0, (NUM_LEDS - LEDS_IN_SEGMENT * 28 - DOTS_NUM)); //1й блок
    BrightDigit(digits[10], (NUM_LEDS - LEDS_IN_SEGMENT * 7));    //4й блок
    int digit = celsius % 10;
    BrightDigit(digits[digit], (NUM_LEDS - LEDS_IN_SEGMENT * 14)); //3й блок
    celsius /= 10;
    digit = celsius % 10;
    BrightDigit(digits[digit], (NUM_LEDS - LEDS_IN_SEGMENT * 21 - DOTS_NUM)); //2й блок
  }
};

// Измеряем давление
void PressureToArray()
{
  if (my_s != 30)
  { //через какое время показывать давление
    PressureShow = false;
    return;
  }
  PressureShow = true;
  int Pressure = bme.readPressure() / 133.322;                           //int p = bmp.readPressure() / 133.322;c
  BrightDots(0);                                                         //разделительные мигающие точки выключены
  BrightDigit(digits[12], (NUM_LEDS - LEDS_IN_SEGMENT * 28 - DOTS_NUM)); //0  начало знака Давления (Р) 1й блокh
  int digit = Pressure % 10;
  BrightDigit(digits[digit], (NUM_LEDS - LEDS_IN_SEGMENT * 7)); //65  4й блок вывода третьей цифры значения
  Pressure /= 10;
  digit = Pressure % 10;
  BrightDigit(digits[digit], (NUM_LEDS - LEDS_IN_SEGMENT * 14)); //44  3й блок вывода второй цифры значенияk
  Pressure /= 10;
  digit = Pressure % 10;
  BrightDigit(digits[digit], (NUM_LEDS - LEDS_IN_SEGMENT * 21 - DOTS_NUM)); //21  2й блок вывода первой цифры значения
};

//Вывод влажности
//Переделано на BME280  //Пример на DHT11
void HumidityToArray()
{
  if (my_s != 35)
  { //через какое время показывать влажность
    HumidityShow = false;
    return;
  }
  HumidityShow = true;
  int humidity = bme.readHumidity();                          //int h = dht.readHumidity();
  BrightDots(0);                                              //разделительные мигающие точки выключены
  BrightDigit(digits[14], (NUM_LEDS - LEDS_IN_SEGMENT * 7));  //65  конец знака процентов (%) 4й блок
  BrightDigit(digits[13], (NUM_LEDS - LEDS_IN_SEGMENT * 14)); //44  начало знака процентов (%) 3 блок
  int digit = humidity % 10;
  BrightDigit(digits[digit], (NUM_LEDS - LEDS_IN_SEGMENT * 21 - DOTS_NUM)); //21  2й блок вывода второго символаA
  humidity /= 10;
  digit = humidity % 10;
  BrightDigit(digits[digit], (NUM_LEDS - LEDS_IN_SEGMENT * 28 - DOTS_NUM)); //0  1й блок вывода первого символа
};

void setup()
{

  Serial.begin(9600);
  LEDS.addLeds<WS2812B, DATA_PIN, COLOR_ORDER>(leds, NUM_LEDS).setCorrection(TypicalLEDStrip);
  LEDS.setBrightness(5); // Задаём яркость
  bme.begin();           //bmp.begin(); //датчик температуры
}

void loop()
{
  cur_ms = millis();
  t_cur = cur_ms / 1000;

  // Каждые  секунду выдаем время
  if (cur_ms < ms1 || (cur_ms - ms1) > 1000)
  {
    ms1 = cur_ms;

    my_s++;
    if (my_s > 59)
    {
      my_s = 0;
      my_m++;
    }
    if (my_m > 59)
    {
      my_m = 0;
    }

    Serial.print("Time: ");
    Serial.print(my_h);
    Serial.print(":");
    Serial.print(my_m);
    Serial.print(":");
    Serial.println(my_s);
    Serial.print("Temperature = ");
    Serial.print(bme.readTemperature());
    Serial.println(" *C");
    Serial.print("Pressure = ");
    Serial.print(bme.readPressure() / 133.322);
    Serial.println(" mm.pt");
    Serial.print("Humidity = ");
    Serial.print(bme.readHumidity());
    Serial.println(" %");
    Serial.println();
  }

  TimeToArray();     // часы
  TempToArray();     // температура
  PressureToArray(); // давление
  HumidityToArray(); // если будет влажность
  FastLED.show();    // Задаём массив светодиодов
  if (TempShow == true)
    delay(5000); //время показа температуры
  if (PressureShow == true)
    delay(5000); //время показа давления
  if (HumidityShow == true)
    delay(5000); //время показа влажности
}

Всем доброго времени. Уведомления одолели, заглянул а тут такое)))))))) b707 надеюсь вы принимаете на свой счет все благодарности которые почему то пишут мне. Большое вам спасибо за помощь в этом проекте. Который так не плохо начал развиваться. Уже делают с ESP и WiFi. Может стоит к концу года собрать все это вместе и сделать мега проект в котором будет собрано это все ну и во избежание конфликтов часть закомментированно. Кто что захочет, тот то и включит.  Вот комерсам -то будет радости.(((((( 

В общем 01:20 на часах. Сижу ломаю голову над своими домашними часами. Надоел один глюк который никак не уходит. При слишком ярком освещении, индикация тоже становится яркой и...... часы зависают. Первый блок как то меняется в зависимости от того что там появляется время, Р или температура. А вот оставшиеся 3 блока зависли на последних значениях которые показывали. Одно время помогала перезагрузка. Теперь и она слабо помогает. При повторном включении загорается первый блок индикации и работает. В остальных блоках чернота. Спустя минут 5-10 остальные блоки оживают, до очередной засветки. Есть идея (которую уже озвучивали здесь), что все таки всей ленте не хватает питания, хотя блок на 5В 5А. Завтра попробую ко второму концу припаять питание. При чем на работе таких глюков ниразу не было. А может сказывается разница количества светодиодов 86 и 114. Может дуня не тянет. БП стоят одинаковые.

По BME280. Температуру он показывает слегка не корректно. Стоят часы и метеорологический психометр 1986 г.в. (в те времена ещё делали качественные вещи). На часах +25, на психометре +22,3. Разница 2.5 градуса. Завтра Сделаю тест на влажность, сравню с ВМЕ.

P.S. Продолжение. В ночном режиме часы светятся довольно ярко и как бы для спальни не подходят. Начал ковырять снова. Модуль фоторезистора с 3 пинами работает только в цифре и поэтому сигнал только вкл/выкл. Заменил на сенсорный модуль для arduino 4pin DIY Kit там есть контакт А0, теперь значения реально меняются в зависимости от освещения: тусклее, ярче или вообще минимум. Но, проблема яркости на минимуме осталась. Ярко. Посмотрел код ShevaLoL , у него в коде строка 121 идет 

new_bright_f = new_bright_f * coef + new_bright * (1 - coef);

в моём же случае 

new_bright_f = new_bright_f * coef - new_bright * (1 - coef);

С чем чёрт не шутит, поставил его строку себе. И о чудо, яркость упала в минимум, еле видно. НО... значения инвертировались. Минимум при ярком освещении, в темноте можно освещать двор. Не подходит. Игрался со значениями

#define max_bright 227        // максимальная яркость (0 - 255)
#define min_bright 0          // минимальная яркость (0 - 255)

менял их местами, менял полярность фотоэлемента (а вдруг))))). Подскажите, что ещё можно изменить, чтобы фоторезистор отрабатывал правильно и диоды ночью горели в минимуме?

если нужно полностью инвертировать. то это очень просто - последнюю строчку настройки яркости запишите как

LEDS.setBrightness(255-new_bright_f); 

Но не понятно, почему вам потребовалась инверсия.... Похоже, что-то тут не так.

LEDS.setBrightness(255-new_bright_f); 

Не получается ((( Инверсия. В темноте ярко, на свету тускло, но опять не в минимум. Ничего не понимаю. А всё началось с того что яркость в темноте довольно высокая и решил разобраться почему при минимальном значении яркости min=0 светит как будто на 100

#include <Adafruit_BME280.h>
#include <DS3232RTC.h>
#include <Time.h>
#include <FastLED.h>

#define LEDS_IN_SEGMENT 4     // Задаём сколько у нас светодиодов в сегменте.
#define DOTS_NUM 2            // Задаём количество разделительных точек
#define COLOR_CHANGE 3        // ( 0 - НИКОГДА, 1 - каждую минуту, 2 - каждые 10 минут, 3 - каждый час, 4 - каждые 10 часов)
#define NUM_COLORS 16         // цветовая гамма
#define COLOR_ORDER BGR       // По умолчанию цвет стоит зелёный при выключенных режимах
#define DATA_PIN 13           // подключение ленты
#define BRI_PIN A0            // фоторезистор 
#define auto_bright 1         // автоматическая подстройка яркости от уровня внешнего освещения (1 - включить, 0 - выключить)
#define max_bright 230        // максимальная яркость (0 - 255)
#define min_bright 0          // минимальная яркость (0 - 255)
#define bright_constant 1010  // константа усиления от внешнего света (0 - 1023), чем МЕНЬШЕ константа, тем "резче" будет прибавляться яркость
#define coef 0.7             // коэффициент фильтра (0.0 - 1.0), чем больше - тем медленнее меняется яркость
int new_bright, new_bright_f;
unsigned long bright_timer, off_timer;

Adafruit_BME280 bme;            // BME280 давление, влажность, температура   I2C

//BMP280 PINS                   //датчик подключается паралельно часам по I2C
//SCL -> SCL or A5
//SDA -> SDA or A4

// Вычислемые константы, НЕ РЕДАКТИРОВАТЬ!
#define NUM_LEDS (LEDS_IN_SEGMENT * 28 + DOTS_NUM)  //114 количество светодиодов в ленте
//#define NUM_LEDS (LEDS_IN_SEGMENT * 28 + 2)  //114 количество светодиодов в ленте
//#define DOT1  (LEDS_IN_SEGMENT * 14)   // координаты мигающих точек
//#define DOT2  (LEDS_IN_SEGMENT * 14  + 1)   // координаты мигающих точек

CRGB leds[NUM_LEDS]; //Задаём значение светодиодов, какой символ из чего состоит
uint8_t  digits[] = {
  0b00111111,     // Digit 0
  0b00100001,     // Digit 1
  0b01110110,     // Digit 2
  0b01110011,     // Digit 3
  0b01101001,     // Digit 4
  0b01011011,     // Digit 5
  0b01011111,     // Digit 6
  0b00110001,     // Digit 7
  0b01111111,     // Digit 8
  0b01111011,     // Digit 9
  0b01111000,     // Digit * градус  10
  0b00011110,     // Digit C         11
  0b01111100,     // Digit P         12
  0b01111000,     // Digit % знак % из двух частей 13
  0b01000111,     // Digit % знак % из двух частей 14
};

bool Dot = true;
bool DST = false; 
bool TempShow = true;
bool PressureShow = true;
bool HumidityShow = true;
int last_digit = 0;

long ledColor = CRGB::Salmon; // Используемый цвет
//long ledColor = CRGB::MediumVioletRed;
long ColorTable[NUM_COLORS] = {
  CRGB::Amethyst,
  CRGB::Aqua,
  CRGB::Blue,
  CRGB::Chartreuse,
  CRGB::DarkGreen,
  CRGB::DarkMagenta,
  CRGB::DarkOrange,
  CRGB::DeepPink,
  CRGB::Fuchsia,
  CRGB::Gold,
  CRGB::GreenYellow,
  CRGB::LightCoral,
  CRGB::Tomato,
  //CRGB::Salmon,
  CRGB::Red,
  CRGB::Orchid,
  CRGB::DarkOrchid
};

void setup() {
  Serial.begin(9600);
  //Wire.begin();//Для BMP
  LEDS.addLeds<WS2812, DATA_PIN, COLOR_ORDER>(leds, NUM_LEDS);

  bme.begin(); //bmp.begin(); //датчик температуры
   
  //LEDS.setBrightness(75); // Задаём яркость
  pinMode(4, INPUT_PULLUP); // Кнопка смены цветов
  pinMode(3, INPUT_PULLUP); // Кнопка регулировки минут
  pinMode(2, INPUT_PULLUP); // Кнопка регулировки часов
}
//новые координаты точек
void BrightDots (boolean Dot_On) {
  for (uint8_t i = 0; i < DOTS_NUM; i++) {
  leds[(LEDS_IN_SEGMENT * 14)+ i] = (Dot_On) ? ledColor : 0;
  }
  //leds[DOT2] = (Dot_On) ? ledColor : 0;
}

void BrightDigit (uint8_t digit, uint8_t cursor)
{
  for (uint8_t mask = 0b01000000; mask > 0; mask = mask >> 1)
  {
    for (uint8_t i = 0; i < LEDS_IN_SEGMENT; i++)
    {
      leds[cursor] = (digit & mask) ? ledColor : 0;
      cursor ++;
    }
  }
}

//Массив управляет яркостью
// Новый метод изменения яркости
void BrightnessCheck() {
  if (auto_bright) {                         // если включена адаптивная яркость
    if (millis() - bright_timer > 100) {     // каждые 100 мс
      int brightness = 0;    // уставливаем начально значение яркости      YJDJT0

      bright_timer = millis();               // сброить таймер
      new_bright = map(analogRead(BRI_PIN), 0, bright_constant, min_bright, max_bright);   // считать показания с фоторезистора, перевести диапазон
      new_bright = constrain(new_bright, min_bright, max_bright);
      new_bright_f = new_bright_f * coef + new_bright * (1 - coef);     // new_bright_f = new_bright_f * coef - new_bright * (1 - coef);   //  300*0.9-300*(1-0.9)
      LEDS.setBrightness(new_bright_f);      // установить новую яркость
      //LEDS.setBrightness(255-new_bright_f);   // установить новую яркость
    }
  }
};

//  Получаем время в одном номере, если часы будет только одна цифра то будет отображаться 155  вместо 0155
int GetTime()
{
  tmElements_t Now;
  RTC.read(Now);
  //time_t Now = RTC.Now();// Получаем данные текущегO времени и его хранение
  int hour = Now.Hour;
  int minute = Now.Minute;
  int second = Now.Second;

  if (second % 2 == 0)
  {
    Dot = false;
  }
  else {
    Dot = true;
  };
  return (hour * 100 + minute);
};

// Преобразуем время в массив для отображание

void TimeToArray() {
  int Now = GetTime();                                // Получаем время
  BrightDots(Dot);

  for (int i = 1; i <= 4; i++) {
    int digit = Now % 10;                             // Получаем последнюю цифру в времениd
    int cursor = NUM_LEDS - i * LEDS_IN_SEGMENT * 7;
    if (i > 2) {
     cursor -= DOTS_NUM;
      //cursor -= 2;
    }
    BrightDigit(digits[digit], cursor);
    if ( i == COLOR_CHANGE) {
      if (digit != last_digit)
      {
//        cylon ();                                    // цикличное изменение цветов
        ledColor =  ColorTable[random(NUM_COLORS)];    // цикличное изменение цветов
      }
      last_digit = digit;
    }
    Now /= 10;
  };
};

// Функция вывода метеоданных
// Преобразуем Temp в массив для отображение
void TempToArray() {
  tmElements_t tm;
  RTC.read(tm);
  if (tm.Second != 25) {     //через какое время показывать температуруi
    TempShow = false;
    return;
  }
  TempShow = true;
  int t = bme.readTemperature();  //int t = bmp.readTemperature();
  int celsius = t;
  BrightDots(0);  //разделительные мигающие точки выключены
  BrightDigit(digits[11], (NUM_LEDS - LEDS_IN_SEGMENT * 7));    //65  начало знака Цельсия (*) 4й блокn
  BrightDigit(digits[10], (NUM_LEDS - LEDS_IN_SEGMENT * 14));   //44  начало знака Градус (С) 3 блок
  int digit = celsius % 10;
  BrightDigit(digits[digit], (NUM_LEDS - LEDS_IN_SEGMENT * 21 - DOTS_NUM));  //21  2й блок вывода второго символа
  celsius /= 10;
  digit = celsius % 10;
  BrightDigit(digits[digit], (NUM_LEDS - LEDS_IN_SEGMENT * 28 - DOTS_NUM));  //0  1й блок вывода первого символаo
};

// Измеряем давление
 void PressureToArray() {
  tmElements_t tm;
  RTC.read(tm);
  if (tm.Second != 30) {//через какое время показывать давление
    PressureShow = false;
    return;
  }
  PressureShow = true;
  int p = bme.readPressure() / 133.322;  //int p = bmp.readPressure() / 133.322;c
  int Pressure = p;
  BrightDots(0); //разделительные мигающие точки выключены
  BrightDigit(digits[12], (NUM_LEDS - LEDS_IN_SEGMENT * 28 - DOTS_NUM));  //0  начало знака Давления (Р) 1й блокh
//  Pressure /= 10;
  int digit = Pressure % 10;
  BrightDigit(digits[digit], (NUM_LEDS - LEDS_IN_SEGMENT * 7 ));  //65  4й блок вывода третьей цифры значения
  Pressure /= 10;
  digit = Pressure % 10;
  BrightDigit(digits[digit], (NUM_LEDS - LEDS_IN_SEGMENT * 14));  //44  3й блок вывода второй цифры значенияk
  Pressure /= 10;
  digit = Pressure % 10;
  BrightDigit(digits[digit], (NUM_LEDS - LEDS_IN_SEGMENT * 21 - DOTS_NUM ));  //21  2й блок вывода первой цифры значения
};

 //Вывод влажности
 //Переделано на BME280  //Пример на DHT11
 void HumidityToArray() {
  tmElements_t tm;
  RTC.read(tm);
  if (tm.Second != 35) {           //через какое время показывать влажность
    HumidityShow = false;
    return;  
  }
  HumidityShow = true;
  int h = bme.readHumidity();  //int h = dht.readHumidity();
  int humidity = h;
  BrightDots(0);  //разделительные мигающие точки выключены
  BrightDigit(digits[14], (NUM_LEDS - LEDS_IN_SEGMENT * 7));    //65  конец знака процентов (%) 4й блок
  BrightDigit(digits[13], (NUM_LEDS - LEDS_IN_SEGMENT * 14));   //44  начало знака процентов (%) 3 блок
  int digit = humidity % 10;
  BrightDigit(digits[digit], (NUM_LEDS - LEDS_IN_SEGMENT * 21 - DOTS_NUM));  //21  2й блок вывода второго символаA
  humidity /= 10;
  digit = humidity % 10;
  BrightDigit(digits[digit], (NUM_LEDS - LEDS_IN_SEGMENT * 28 - DOTS_NUM));  //0  1й блок вывода первого символа
};

//смена цвета ленты кнопкой DST Pin 4
void DSTcheck() {
  int buttonDST = digitalRead(4);
  if (buttonDST == LOW) {
    ledColor =  ColorTable[random(NUM_COLORS)];
  };
  delay(100);//время реакции на нажатие
};

// Массив управляет кнопками с часами и минутами
void TimeAdjust() {
  int buttonH = digitalRead(2);
  int buttonM = digitalRead(3);
  if (buttonH == LOW || buttonM == LOW) {
    delay(100);//время реакции на нажатие
    tmElements_t Now;
    RTC.read(Now);
    int hour = Now.Hour;
    int minutes = Now.Minute;
    int second = Now.Second;
    if (buttonH == LOW) {
      if (Now.Hour == 23) {
        Now.Hour = 0;
      }
      else {
        Now.Hour += 1;
      };
    }
    else
    {
      if (Now.Minute == 59) {
        Now.Minute = 0;
      }
      else {
        Now.Minute += 1;
      };
    };
    RTC.write(Now);
  }
}

//Меняем эффекты
void fadeall() {
  for (int i = 0; i < NUM_LEDS; i++) {
    leds[i].nscale8(250);
  }
}

// массив отвечает за цикличное изменение цветов
void cylon () {
  static uint8_t hue = 0;
  Serial.print("x");
  // Сдвигаем один светодиод в любом направлении
  for (int i = 0; i < NUM_LEDS; i++) {
  // Устанавливаем 1 светодиод на цвет красный
    leds[i] = CHSV(hue++, 255, 255);
  // Показываем светодиоды
    FastLED.show();
    fadeall();
  // Ждём немного и повторяем цикл
    delay(10);
  }
  //Serial.print("x");

  // Сдвигаем один светодиод в любом направлении
  for (int i = (NUM_LEDS) - 1; i >= 0; i--) {
  // Устанавливаем 1 светодиод на цвет красный
    leds[i] = CHSV(hue++, 255, 255);
  // Показываем светодиоды
    FastLED.show();
    fadeall();
  // Ждём немного и повторяем цикл
    delay(10);
  }
}

void loop()
{ 
  BrightnessCheck(); // Проверяем датчик освещения
  DSTcheck();        // Проверяем цветовые режимы
  TimeAdjust();      // Проверяем время если сменилось на 1 цифру
  TimeToArray();     // Проверяем часы если сменилось на 1 цифру
  TempToArray();     // температура
  PressureToArray(); // давление
  HumidityToArray(); // влажность
  FastLED.show();    // Задаём массив светодиодов
  if (TempShow == true) delay (5000);    //время показа температуры
  if (PressureShow == true) delay (5000);//время показа давления
  if (HumidityShow == true) delay (5000);//время показа влажности

/*/ 
 
 int brightness = analogRead(BRI_PIN);
  // Получение тестовых значений
  // Выодим на монитор полученное значение
  Serial.print("brightness = "); // Название значения для наглядного представления
  Serial.println(brightness);    // Выводим значение и используем вызов println, те переноса строки
  delay(1000);
  */

  
 /*/ 
  //вывод информации в сом порт
  // Раскоментировать если нужно посмотреть в сом порте,  подтормаживает вся система если это открыто 
    Serial.print("Tемпература = ");
    Serial.print(bme.readTemperature());  //Serial.print(bmp.readTemperature());
    Serial.println("*C");
    
    Serial.print ("Давление = ");
    Serial.print (bme.readPressure() / 133.322);  //Serial.print (bmp.readPressure() / 133.322); // Полученное значение в Па делим на 133,322 и получаем мм.рт.ст.
    Serial.println (" mm"); // и соответственно меняем "Pa" на "mm"

    Serial.print ("Влажность = ");
    Serial.print (bme.readHumidity() ); // Serial.print (dht.readHumidity() ); // 
    Serial.println ("%\t"); // 
    Serial.println();
    delay(8000);

    Serial.println (" *Arduino.ru.* "); // 
 */ 
}

Вот если делать как я написал выше в уравнении поставить + то подсветка гаснет идеально до минимума который выставлен, но инверсия. А если добавить ваше предложение, то либо инверсия в неполный минимум со знаком +, либо нормально в неполный минимум со знаком -

OdinochkA - в программировании чудеса редки. ищите ошибки. Если Ваш сенсор осыещенности выдает БОЛЬШИЕ значения при более ярком свете, а не наоборот - инверсии тут взяться просто неоткуда.

Надо провести "отладку" кода и найти, где возникает ошибка. Я бы на Вашем месте действовал так - сначала подключил бы датчик освещения к отдельной ардуине, загрузил простенький код, который выводит значения освещения в Сериал - и посмотрел, какие цифры выдает датчик в темноте, в сумерках и на ярком свету.

Потом подставил бы полученные цифры в формулу из скетча, вручную посчитал значения настроек яркости для разных случаев - и подставил бы, к примеру, цифру яркости часов для сумерек в строчку

LEDS.setBrightness(new_bright_f);

чтобы убедится. что яркость свечения часов такая как надо. Потом так же с цифрой для ркого света и тд

Вроде правильно при засвете мало при затемнении большее значение , аж интересно :)

Фотодатчик модулем ?

Да. На али брал с 4мя пинами

У мну такойже работает адекватно скетч из 303 поста.

/**/
//------- кнопки ---------------------------
typedef void (*pDo)();
class Cl_Btn {
  protected:
    byte pin;
    bool state;
    unsigned long past;
    void set(bool s) {
      state = s;
      past = millis();
      if (s) Do();
    }
  public:
    Cl_Btn(byte p): pin(p) {}
    pDo Do = [] {};
    void init() {
      pinMode(pin, INPUT_PULLUP);
      set(false);
    }
    void run() {
      if (millis() - past >= 100)
        switch (state) {
          case false:
            if (!digitalRead(pin))set(true);
            break;
          case true:
            if (digitalRead(pin))set(false);
            if (millis() - past >= 300)set(false);
            break;
        }
    }
};
Cl_Btn BtnS(/*пин*/2);//кнопка селект
Cl_Btn BtnU(/*пин*/3);//кнопка UP
//---------часы--------------------
class cl_clock {
  protected:
    unsigned long past;
  public:
    cl_clock() {}
    byte h, m, s;// часы минуты секунды
    void init() {
      h = 0; m = 0; s = 0;
      past = millis();
    }
    void run() {
      if (millis() - past >= 1000) {
        past = millis();
        s++; if (s >= 60) {
          s = 0;
          m++; if (m >= 60) {
            m = 0;
            h++; if (h >= 24) h = 0;
          }
        }
      }
    }
};
cl_clock clock;
//---------Экран-----------------------------
template <typename T> inline Print & operator << (Print &s, T n) {
  s.print(n);
  return s;
}
class cl_display: public Print {
  protected:
    char buffer[5];
    byte pos;
    virtual size_t write(uint8_t c) {
      if (c == '\n') {
        setPos(1);
        return 1;
      }
      if (c < 32) return 0;
      buffer[pos] = c;
      pos++;
      return 1;
    }
  public:
    cl_display() {}
    void setPos(byte p) {
      if (p == 0) p = 1;
      else if (p > 5) p = 5;
      pos = p;
    }
    void clear() {
      setPos(1);
      for (int i = 0; i < 5; i++)buffer[i] = ' ';
    }
    void show() {
      Serial << '\n' << buffer[1]  << buffer[2] << buffer[0] << buffer[3] << buffer[4];
    }
    void setDot(char c) {
      if (c != ':') c = ' ';
      buffer[0] = c;
    }
    void printD(byte num) {
      if (num < 10) print('0');
      print(num);
    }
};
cl_display  display;

const byte page0 = 0;  // отображение часы минуты
const byte page1 = 10; // отображение часы минуты секунды
const byte page2 = 20; // установка часов
const byte page3 = 30; // установка минут
const byte page4 = 40; // установка секунд
byte page;
unsigned long past;
void goPage(byte p) {
  page = p;
  past = millis();
  display.clear();
  switch (page) {
    case  page0://показ часы:минуты
      { display.printD(clock.h);
        display.printD(clock.m);
        display.setDot(clock.s % 2 * ':');
      }
      BtnS.Do = [] {goPage(page1);};
      BtnU.Do = [] {};
      break;
    case  page1://показминуты:секунды
      display.printD(clock.m);
      display.printD(clock.s);
      BtnS.Do = [] {goPage(page2);};
      BtnU.Do = [] {};
      break;
    case  page2:// установка часов
      display << "h ";
      if (page == page2)display.printD(clock.h);
      else display << " ";
      BtnS.Do = [] {goPage(page3);};
      BtnU.Do = [] {
        clock.h++;
        if (clock.h >= 24)clock.h = 0;
        goPage(page2);
      };
      break;
    case  page3:// установка минут
      display << "m ";
      if (page == page3)display.printD(clock.m);
      else display << " ";
      BtnS.Do = [] {goPage(page4);};
      BtnU.Do = [] {
        clock.m++;
        if (clock.m >= 60)clock.h = 0;
        goPage(page3);
      };
      break;
    case  page4:// установка секунд
      display << "s ";
      if (page == page4)display.printD(clock.s);
      else display << " ";
      BtnS.Do = [] {goPage(page0);};
      BtnU.Do = [] {
        clock.s++;
        if (clock.s >= 60)clock.s = 0;
        goPage(page4);
      };
      break;
  }
  display.show();
}
void menu_init() {
  Serial.begin(9600);
  goPage(page0);
}
void menu_run() {
  if (page == page0 && millis() - past > 500)goPage(page0);
  if (page == page1 && millis() - past > 500)goPage(page1);
}
//--------------------------------
void setup() {
  BtnS.init();
  BtnU.init();
  clock.init();
  menu_init();
}
void loop() {
  BtnS.run();
  BtnU.run();
  clock.run();
  menu_run();
}

Всё. Вроде работает.. Поставил так:

#define max_bright 255        // максимальная яркость (0 - 255)
#define min_bright 5         // минимальная яркость (0 - 255)
#define bright_constant 510  // константа усиления от внешнего света (0 - 1023), чем МЕНЬШЕ константа, тем "резче" будет прибавляться яркость

И судя по опытам весь затык был в константе. При увеличении выше этого значения, по крайней мере у меня, начинались скачки светимости при достижении крайних точек. ПОследний код

/*/Проект собран на основе желания сделать себе как у всех, но чуточку лучше. Основная работа по коду шла на 
форуме <a href="http://arduino.ru." rel="nofollow">http://arduino.ru.</a> Конкретно началось с поста №58. Много людей помогали и вносили свою лепту
во всё это действо b707, bwn, GennOk.
Данный проект подходит под определение метео станция. Вывод данных о температуре, давлении и влажности. Так же основное
предназначение это показ часов. Очень много коментариев и росписей по кокретным блокам.
Проект универсальный, под разное количество LED-светодиодов, за это отдельное спасибо b707. Да и вообще большая часть кода
была переписана этим человеком. От того, что было изначально возможно осталась только идея))) Универсальность количества
диодов, переписана координатность символов, переназначение кнопок, отключение смены цветов либо смена по времени.
ВОЗМОЖНО в будущем появится вывод даты
////////////////////////////////////////////////////////////////////////////OdinochkA)))
*/

#include <Adafruit_BME280.h>
#include <DS3232RTC.h>
#include <Time.h>
#include <FastLED.h>

#define LEDS_IN_SEGMENT 4     // Задаём сколько у нас светодиодов в сегменте.
#define DOTS_NUM 2            // Задаём количество разделительных точек
#define COLOR_CHANGE 3        // ( 0 - НИКОГДА, 1 - каждую минуту, 2 - каждые 10 минут, 3 - каждый час, 4 - каждые 10 часов)
#define NUM_COLORS 16         // цветовая гамма
#define COLOR_ORDER BGR       // По умолчанию цвет стоит зелёный при выключенных режимах
#define DATA_PIN 13           // подключение ленты
#define BRI_PIN A0            // фоторезистор 
#define auto_bright 1         // автоматическая подстройка яркости от уровня внешнего освещения (1 - включить, 0 - выключить)
#define max_bright 255        // максимальная яркость (0 - 255)
#define min_bright 5         // минимальная яркость (0 - 255)
#define bright_constant 510  // константа усиления от внешнего света (0 - 1023), чем МЕНЬШЕ константа, тем "резче" будет прибавляться яркость
#define coef 0.8             // коэффициент фильтра (0.0 - 1.0), чем больше - тем медленнее меняется яркость
int new_bright, new_bright_f;
unsigned long bright_timer, off_timer;

Adafruit_BME280 bme;            // BME280 давление, влажность, температура   I2C

//BMP280 PINS                   //датчик подключается паралельно часам по I2C
//SCL -> SCL or A5
//SDA -> SDA or A4

// Вычислемые константы, НЕ РЕДАКТИРОВАТЬ!
#define NUM_LEDS (LEDS_IN_SEGMENT * 28 + DOTS_NUM)  //114 количество светодиодов в ленте
//#define NUM_LEDS (LEDS_IN_SEGMENT * 28 + 2)  //114 количество светодиодов в ленте
//#define DOT1  (LEDS_IN_SEGMENT * 14)   // координаты мигающих точек
//#define DOT2  (LEDS_IN_SEGMENT * 14  + 1)   // координаты мигающих точек

CRGB leds[NUM_LEDS]; //Задаём значение светодиодов, какой символ из чего состоит
uint8_t  digits[] = {
  0b00111111,     // Digit 0
  0b00100001,     // Digit 1
  0b01110110,     // Digit 2
  0b01110011,     // Digit 3
  0b01101001,     // Digit 4
  0b01011011,     // Digit 5
  0b01011111,     // Digit 6
  0b00110001,     // Digit 7
  0b01111111,     // Digit 8
  0b01111011,     // Digit 9
  0b01111000,     // Digit * градус  10
  0b00011110,     // Digit C         11
  0b01111100,     // Digit P         12
  0b01111000,     // Digit % знак % из двух частей 13
  0b01000111,     // Digit % знак % из двух частей 14
};

bool Dot = true;
bool DST = false; 
bool TempShow = true;
bool PressureShow = true;
bool HumidityShow = true;
int last_digit = 0;

long ledColor = CRGB::Salmon; // Используемый цвет
//long ledColor = CRGB::MediumVioletRed;
long ColorTable[NUM_COLORS] = {
  CRGB::Amethyst,
  CRGB::Aqua,
  CRGB::Blue,
  CRGB::Chartreuse,
  CRGB::DarkGreen,
  CRGB::DarkMagenta,
  CRGB::DarkOrange,
  CRGB::DeepPink,
  CRGB::Fuchsia,
  CRGB::Gold,
  CRGB::GreenYellow,
  CRGB::LightCoral,
  CRGB::Tomato,
  //CRGB::Salmon,
  CRGB::Red,
  CRGB::Orchid,
  CRGB::DarkOrchid
};

void setup() {
  Serial.begin(9600);
  //Wire.begin();//Для BMP
  LEDS.addLeds<WS2812, DATA_PIN, COLOR_ORDER>(leds, NUM_LEDS);

  bme.begin(); //bmp.begin(); //датчик температуры
   
  //LEDS.setBrightness(75); // Задаём яркость
  pinMode(4, INPUT_PULLUP); // Кнопка смены цветов
  pinMode(3, INPUT_PULLUP); // Кнопка регулировки минут
  pinMode(2, INPUT_PULLUP); // Кнопка регулировки часов
}
//новые координаты точек
void BrightDots (boolean Dot_On) {
  for (uint8_t i = 0; i < DOTS_NUM; i++) {
  leds[(LEDS_IN_SEGMENT * 14)+ i] = (Dot_On) ? ledColor : 0;
  }
  //leds[DOT2] = (Dot_On) ? ledColor : 0;
}

void BrightDigit (uint8_t digit, uint8_t cursor)
{
  for (uint8_t mask = 0b01000000; mask > 0; mask = mask >> 1)
  {
    for (uint8_t i = 0; i < LEDS_IN_SEGMENT; i++)
    {
      leds[cursor] = (digit & mask) ? ledColor : 0;
      cursor ++;
    }
  }
}

//Массив управляет яркостью
// Новый метод изменения яркости
void BrightnessCheck() {
  if (auto_bright) {                         // если включена адаптивная яркость
    if (millis() - bright_timer > 100) {     // каждые 100 мс
      bright_timer = millis();               // сброить таймер
      new_bright = map(analogRead(BRI_PIN), 0, bright_constant, min_bright, max_bright);   // считать показания с фоторезистора, перевести диапазон
      new_bright = constrain(new_bright, min_bright, max_bright);
      new_bright_f = new_bright_f * coef - new_bright * (1 - coef);     // new_bright_f = new_bright_f * coef - new_bright * (1 - coef);   //  300*0.9-300*(1-0.9)
     LEDS.setBrightness(new_bright_f);      // установить новую яркость
      //LEDS.setBrightness(255-new_bright_f);   // установить новую яркость
    }
  }
};

//  Получаем время в одном номере, если часы будет только одна цифра то будет отображаться 155  вместо 0155
int GetTime()
{
  tmElements_t Now;
  RTC.read(Now);
  //time_t Now = RTC.Now();// Получаем данные текущегO времени и его хранение
  int hour = Now.Hour;
  int minute = Now.Minute;
  int second = Now.Second;

  if (second % 2 == 0)
  {
    Dot = false;
  }
  else {
    Dot = true;
  };
  return (hour * 100 + minute);
};

// Преобразуем время в массив для отображание

void TimeToArray() {
  int Now = GetTime();                                // Получаем время
  BrightDots(Dot);

  for (int i = 1; i <= 4; i++) {
    int digit = Now % 10;                             // Получаем последнюю цифру в времениd
    int cursor = NUM_LEDS - i * LEDS_IN_SEGMENT * 7;
    if (i > 2) {
     cursor -= DOTS_NUM;
      //cursor -= 2;
    }
    BrightDigit(digits[digit], cursor);
    if ( i == COLOR_CHANGE) {
      if (digit != last_digit)
      {
//        cylon ();                                    // цикличное изменение цветов
        ledColor =  ColorTable[random(NUM_COLORS)];    // цикличное изменение цветов
      }
      last_digit = digit;
    }
    Now /= 10;
  };
};

// Функция вывода метеоданных
// Преобразуем Temp в массив для отображение
void TempToArray() {
  tmElements_t tm;
  RTC.read(tm);
  if (tm.Second != 25) {     //через какое время показывать температуруi
    TempShow = false;
    return;
  }
  TempShow = true;
  int t = bme.readTemperature();  //int t = bmp.readTemperature();
  int celsius = t;
  BrightDots(0);  //разделительные мигающие точки выключены
  BrightDigit(digits[11], (NUM_LEDS - LEDS_IN_SEGMENT * 7));    //65  начало знака Цельсия (*) 4й блокn
  BrightDigit(digits[10], (NUM_LEDS - LEDS_IN_SEGMENT * 14));   //44  начало знака Градус (С) 3 блок
  int digit = celsius % 10;
  BrightDigit(digits[digit], (NUM_LEDS - LEDS_IN_SEGMENT * 21 - DOTS_NUM));  //21  2й блок вывода второго символа
  celsius /= 10;
  digit = celsius % 10;
  BrightDigit(digits[digit], (NUM_LEDS - LEDS_IN_SEGMENT * 28 - DOTS_NUM));  //0  1й блок вывода первого символаo
};

// Измеряем давление
 void PressureToArray() {
  tmElements_t tm;
  RTC.read(tm);
  if (tm.Second != 30) {//через какое время показывать давление
    PressureShow = false;
    return;
  }
  PressureShow = true;
  int p = bme.readPressure() / 133.322;  //int p = bmp.readPressure() / 133.322;c
  int Pressure = p;
  BrightDots(0); //разделительные мигающие точки выключены
  BrightDigit(digits[12], (NUM_LEDS - LEDS_IN_SEGMENT * 28 - DOTS_NUM));  //0  начало знака Давления (Р) 1й блокh
//  Pressure /= 10;
  int digit = Pressure % 10;
  BrightDigit(digits[digit], (NUM_LEDS - LEDS_IN_SEGMENT * 7 ));  //65  4й блок вывода третьей цифры значения
  Pressure /= 10;
  digit = Pressure % 10;
  BrightDigit(digits[digit], (NUM_LEDS - LEDS_IN_SEGMENT * 14));  //44  3й блок вывода второй цифры значенияk
  Pressure /= 10;
  digit = Pressure % 10;
  BrightDigit(digits[digit], (NUM_LEDS - LEDS_IN_SEGMENT * 21 - DOTS_NUM ));  //21  2й блок вывода первой цифры значения
};

 //Вывод влажности
 //Переделано на BME280  //Пример на DHT11
 void HumidityToArray() {
  tmElements_t tm;
  RTC.read(tm);
  if (tm.Second != 35) {           //через какое время показывать влажность
    HumidityShow = false;
    return;  
  }
  HumidityShow = true;
  int h = bme.readHumidity();  //int h = dht.readHumidity();
  int humidity = h;
  BrightDots(0);  //разделительные мигающие точки выключены
  BrightDigit(digits[14], (NUM_LEDS - LEDS_IN_SEGMENT * 7));    //65  конец знака процентов (%) 4й блок
  BrightDigit(digits[13], (NUM_LEDS - LEDS_IN_SEGMENT * 14));   //44  начало знака процентов (%) 3 блок
  int digit = humidity % 10;
  BrightDigit(digits[digit], (NUM_LEDS - LEDS_IN_SEGMENT * 21 - DOTS_NUM));  //21  2й блок вывода второго символаA
  humidity /= 10;
  digit = humidity % 10;
  BrightDigit(digits[digit], (NUM_LEDS - LEDS_IN_SEGMENT * 28 - DOTS_NUM));  //0  1й блок вывода первого символа
};

//смена цвета ленты кнопкой DST Pin 4
void DSTcheck() {
  int buttonDST = digitalRead(4);
  if (buttonDST == LOW) {
    ledColor =  ColorTable[random(NUM_COLORS)];
  };
  delay(100);//время реакции на нажатие
};

// Массив управляет кнопками с часами и минутами
void TimeAdjust() {
  int buttonH = digitalRead(2);
  int buttonM = digitalRead(3);
  if (buttonH == LOW || buttonM == LOW) {
    delay(100);//время реакции на нажатие
    tmElements_t Now;
    RTC.read(Now);
    int hour = Now.Hour;
    int minutes = Now.Minute;
    int second = Now.Second;
    if (buttonH == LOW) {
      if (Now.Hour == 23) {
        Now.Hour = 0;
      }
      else {
        Now.Hour += 1;
      };
    }
    else
    {
      if (Now.Minute == 59) {
        Now.Minute = 0;
      }
      else {
        Now.Minute += 1;
      };
    };
    RTC.write(Now);
  }
}

//Меняем эффекты
void fadeall() {
  for (int i = 0; i < NUM_LEDS; i++) {
    leds[i].nscale8(250);
  }
}

// массив отвечает за цикличное изменение цветов
void cylon () {
  static uint8_t hue = 0;
  Serial.print("x");
  // Сдвигаем один светодиод в любом направлении
  for (int i = 0; i < NUM_LEDS; i++) {
  // Устанавливаем 1 светодиод на цвет красный
    leds[i] = CHSV(hue++, 255, 255);
  // Показываем светодиоды
    FastLED.show();
    fadeall();
  // Ждём немного и повторяем цикл
    delay(10);
  }
  //Serial.print("x");

  // Сдвигаем один светодиод в любом направлении
  for (int i = (NUM_LEDS) - 1; i >= 0; i--) {
  // Устанавливаем 1 светодиод на цвет красный
    leds[i] = CHSV(hue++, 255, 255);
  // Показываем светодиоды
    FastLED.show();
    fadeall();
  // Ждём немного и повторяем цикл
    delay(10);
  }
}

void loop()
{ 
  BrightnessCheck(); // Проверяем датчик освещения
  DSTcheck();        // Проверяем цветовые режимы
  TimeAdjust();      // Проверяем время если сменилось на 1 цифру
  TimeToArray();     // Проверяем часы если сменилось на 1 цифру
  TempToArray();     // температура
  PressureToArray(); // давление
  HumidityToArray(); // влажность
  FastLED.show();    // Задаём массив светодиодов
  if (TempShow == true) delay (5000);    //время показа температуры
  if (PressureShow == true) delay (5000);//время показа давления
  if (HumidityShow == true) delay (5000);//время показа влажности

/*/ 
 //вывод на монитор данных по освещённости
 int brightness = analogRead(BRI_PIN);
  // Получение тестовых значений
  // Выодим на монитор полученное значение
  Serial.print("brightness = "); // Название значения для наглядного представления
  Serial.println(brightness);    // Выводим значение и используем вызов println, те переноса строки
  delay(1000);
  */
  
 /*/ 
  //вывод информации в монитор порта
  // Раскоментировать если нужно посмотреть в сом порте,  подтормаживает вся система если это открыто 
    Serial.print("Tемпература = ");
    Serial.print(bme.readTemperature());  //Serial.print(bmp.readTemperature());
    Serial.println("*C");
    
    Serial.print ("Давление = ");
    Serial.print (bme.readPressure() / 133.322);  //Serial.print (bmp.readPressure() / 133.322); // Полученное значение в Па делим на 133,322 и получаем мм.рт.ст.
    Serial.println (" mm"); // и соответственно меняем "Pa" на "mm"

    Serial.print ("Влажность = ");
    Serial.print (bme.readHumidity() ); // Serial.print (dht.readHumidity() ); // 
    Serial.println ("%\t"); // 
    Serial.println();
    delay(8000);

    Serial.println (" *Arduino.ru.* "); // 
 */ 
}

Боюсь, этот код тоже неправильный и проблему вы не решили, только замаскировали.
Код в процедуре автоподстройки яркости - рассчитан на прямую зависимость цифр с датчика от освещения - чем больше света, тем больше цифра. А судя по вашим тестам, на вашем датчике зависимость обратная.
В процедуре map мин и макс надо поменять местами, да и значение константы 510 к вашим данным не подходит совсем

глянь вот в этом скетче, одна из старых разновидностей нашего =) тут на аналоге яркость вроде считывается а не на цифре

/*------------------------
   Leds used here are WS2812B, 3 leds by segment
   total = (3*7)* 4numbers  + 2 dots = 86 leds
   Led controlled with FastLeds Lib on Pin 5
   Brightness sensor on A0
   RTC Modul on A4 A5
   I'm using 5V 2A Power supply
*/


#include <DS3232RTC.h>
#include <Time.h>
#include <Wire.h>
#include <FastLED.h>
//#include <IRremote.h>



#define NUM_LEDS 86  //3*7*4 +2  Number of LED controles (remember I have 3 leds / controler
#define LED_TYPE    WS2812
//#define COLOR_ORDER BRG // Define color order for your strip
#define BRIGHTNESS_DEFAULT  180
#define LED_PIN 5 // Data pin for led comunication



char    incoming_command = 'H';
int brightness = 0;
int  auto_brightness = 1;
//brightness
int photocellPin = 0; // the cell and 10K pulldown are connected to a0
int photocellReading; // the analog reading from the analog resis
int led_on = 1;
//LEDS COLORS


volatile boolean animate = true;
volatile long animation_change_timeout;
unsigned long previousMillis = 0;        // will store last time LED was updated


const long interval = 5000;           // interval for printing Temp and date



CRGB leds[NUM_LEDS]; // Define LEDs strip
// 10 digit :0...10, each digit is composed of 7 segments of 3 leds
byte digits[10][21] = {
  {
    0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
  }
  , // Digit 0

  {
    0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1
  }
  , // Digit 1

  {
    1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0
  }
  , // Digit 2

  {
    1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1
  }
  , // Digit 3

  {
    1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1
  }
  , // Digit 4

  {
    1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1
  }
  , // Digit 5

  {
    1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
  }
  , // Digit 6

  {
    0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1
  }
  , // Digit 7

  {
    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
  }
  , // Digit 8

  {
    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1
  }
}; // Digit 9 | 2D Array for numbers on 7 segment

// Digit 1 first number | 2D Array for numbers on 7 segment

bool Dot = true; //Dot state

bool DST = false; //DST state
int last_digit = 0;
//long ledColor = CRGB::DarkOrchid; // Color used (in hex)
long ledColor = CRGB::MediumVioletRed;
//Random colors i picked up
long ColorTable[16] = {
  CRGB::Amethyst,
  CRGB::Aqua,
  CRGB::Blue,
  CRGB::Chartreuse,
  CRGB::DarkGreen,
  CRGB::DarkMagenta,
  CRGB::DarkOrange,
  CRGB::DeepPink,
  CRGB::Fuchsia,
  CRGB::Gold,
  CRGB::GreenYellow,
  CRGB::LightCoral,
  CRGB::Tomato,
  CRGB::Salmon,
  CRGB::Red,
  CRGB::Orchid
};


void setup() {

  Serial.begin(9600);
  Wire.begin();
  FastLED.addLeds<WS2812B, LED_PIN, GRB>(leds, NUM_LEDS);
  // FastLED.addLeds<LED_TYPE, LED_PIN, COLOR_ORDER>(leds, NUM_LEDS).setCorrection( TypicalLEDStrip );
  FastLED.setBrightness(  BRIGHTNESS_DEFAULT );

}

// Check Light sensor and set brightness accordingly

void BrightnessCheck() {

  photocellReading = analogRead(photocellPin);

  const byte brightnessLow = 30; // Low brightness value

  const byte brightnessHigh = 100; // High brightness value
  //you can choose between auto or manual brightness
  if   (auto_brightness ) {
    if (photocellReading > 100) {

      FastLED.setBrightness( brightnessHigh );

    }

    else if (photocellReading < 100) {


      FastLED.setBrightness( brightnessLow);

    }
  }

};

// Get time in a single number
int GetTime() {
  tmElements_t Now;
  RTC.read(Now);
  //time_t Now = RTC.Now();// Getting the current Time and storing it into a DateTime object
  int hour = Now.Hour;
  int minutes = Now.Minute;
  int second = Now.Second;
  //use this to blink your dots every second
  if (second % 2 == 0) {
    Dot = false;
  }
  else {
    Dot = true;
  };
  //it is easy to manipulate 2150 rather than hours = 10 minutes = 50
  return (hour * 100 + minutes);
};

//function to print day and month
int DayMonth() {
  tmElements_t Now;
  RTC.read(Now);
  int day = Now.Day;
  int month = Now.Month;
  return (day * 100 + month);
}

// not used yet
void DSTcheck() {

  int buttonDST = digitalRead(2);

  Serial.print("DST is: ");
  Serial.println(DST);

  if (buttonDST == LOW) {

    if (DST) {

      DST = false;

      Serial.print("Switching DST to: ");
      Serial.println(DST);

    }

    else if (!DST) {

      DST = true;

      Serial.print("Switching DST to: ");
      Serial.println(DST);

    };

    delay(500);

  };

}

// Convert time to array needet for display
void TimeToArray() {

  int Now = GetTime(); // Get time

  int cursor = 86; //

  //Serial.print("Time is: ");
  //Serial.println(Now);

  if (Dot) {
    leds[42] = ledColor;
    leds[43] = ledColor;
  }

  else {

    leds[42] = 0x000000;
    leds[43] = 0x000000;

  };

  for (int i = 1; i <= 4; i++) {

    int digit = Now % 10; // get last digit in time

    if (i == 1) {

      cursor = 65;

      //Serial.print("Digit 4 is : ");
      //Serial.print(digit);
      //Serial.print(", the array is : ");

      for (int k = 0; k <= 20; k++) {

        //Serial.print(digits[digit][k]);

        if (digits[digit][k] == 1) {
          leds[cursor] = ledColor;
        }

        else if (digits[digit][k] == 0) {
          leds[cursor] = 0x000000;
        };

        cursor ++;

      }; // fin for

      //   Serial.println();
      if (digit != last_digit)
      {
        fadefonction();
        ledColor =  ColorTable[random(16)];
      }
      last_digit = digit;

    }// fin if

    else if (i == 2) {

      cursor = 44;

      //Serial.print("Digit 3 is : ");
      //Serial.print(digit);
      //Serial.print(", the array is : ");

      for (int k = 0; k <= 20; k++) {

        //Serial.print(digits[digit][k]);

        if (digits[digit][k] == 1) {
          leds[cursor] = ledColor;
        }

        else if (digits[digit][k] == 0) {
          leds[cursor] = 0x000000;
        };

        cursor ++;

      };

      // Serial.println();

    }

    else if (i == 3) {

      cursor = 21;

      //Serial.print("Digit 2 is : ");
      //Serial.print(digit);
      //Serial.print(", the array is : ");

      for (int k = 0; k <= 20; k++) {

        //Serial.print(digits[digit][k]);

        if (digits[digit][k] == 1) {
          leds[cursor] = ledColor;
        }

        else if (digits[digit][k] == 0) {
          leds[cursor] = 0x000000;
        };

        cursor ++;

      };

      //Serial.println();

    }

    else if (i == 4) {

      cursor = 0;

      //Serial.print("Digit 1 is : ");
      //Serial.print(digit);
      //Serial.print(", the array is : ");

      for (int k = 0; k <= 20; k++) {
        //Serial.print(digits[digit][k]);
        if (digits[digit][k] == 1) {
          leds[cursor] = ledColor;
        }
        else if (digits[digit][k] == 0) {
          leds[cursor] = 0x000000;
        };
        cursor ++;
      };
      //      Serial.println();

    };

    Now /= 10;

  };

};

// Convert date to array needet for display

void DateToArray() {
  FastLED.clear();
  unsigned long currentMillis = millis();
  while (millis() - currentMillis < interval) {
    FastLED.show();
    int Now = DayMonth(); // Get time

    int cursor = 86; //116

    //Serial.print("Time is: ");
    //Serial.println(Now);


    for (int i = 1; i <= 4; i++) {

      int digit = Now % 10; // get last digit in time

      if (i == 1) {

        cursor = 65; //82

        //Serial.print("Digit 4 is : ");
        //Serial.print(digit);
        //Serial.print(", the array is : ");

        for (int k = 0; k <= 20; k++) {

          //Serial.print(digits[digit][k]);

          if (digits[digit][k] == 1) {
            leds[cursor] = ledColor;
          }

          else if (digits[digit][k] == 0) {
            leds[cursor] = 0x000000;
          };

          cursor ++;

        }; // fin for

        //   Serial.println();


      }// fin if

      else if (i == 2) {

        cursor = 44;

        //Serial.print("Digit 3 is : ");
        //Serial.print(digit);
        //Serial.print(", the array is : ");

        for (int k = 0; k <= 20; k++) {

          //Serial.print(digits[digit][k]);

          if (digits[digit][k] == 1) {
            leds[cursor] = ledColor;
          }

          else if (digits[digit][k] == 0) {
            leds[cursor] = 0x000000;
          };

          cursor ++;

        };

        // Serial.println();

      }

      else if (i == 3) {

        cursor = 21;

        //Serial.print("Digit 2 is : ");
        //Serial.print(digit);
        //Serial.print(", the array is : ");

        for (int k = 0; k <= 20; k++) {

          //Serial.print(digits[digit][k]);

          if (digits[digit][k] == 1) {
            leds[cursor] = ledColor;
          }

          else if (digits[digit][k] == 0) {
            leds[cursor] = 0x000000;
          };

          cursor ++;

        };

        //Serial.println();

      }

      else if (i == 4) {

        cursor = 0;

        //Serial.print("Digit 1 is : ");
        //Serial.print(digit);
        //Serial.print(", the array is : ");

        for (int k = 0; k <= 20; k++) {
          //Serial.print(digits[digit][k]);
          if (digits[digit][k] == 1) {
            leds[cursor] = ledColor;
          }
          else if (digits[digit][k] == 0) {
            leds[cursor] = 0x000000;
          };
          cursor ++;
        };
        //      Serial.println();

      };

      Now /= 10;

    };
  }
};

//not used yet
void TimeAdjust() {

  int buttonH = digitalRead(5);

  int buttonM = digitalRead(4);

  if (buttonH == LOW || buttonM == LOW) {

    delay(500);

    tmElements_t Now;

    RTC.read(Now);

    int hour = Now.Hour;

    int minutes = Now.Minute;

    if (buttonH == LOW) {

      if (Now.Hour == 24) {
        Now.Hour = 1;
      }

      else {
        Now.Hour += 1;
      };

    }
    else {

      if (Now.Minute == 59) {
        Now.Minute = 0;
      }

      else {
        Now.Minute += 1;
      };

    };

    RTC.write(Now);

  }

}

/* coool effect function*/
void fadeall() {
  for (int m = 0; m < NUM_LEDS; m++) {
    leds[m].nscale8(250);
  }
}

void fadefonction () {
  static uint8_t hue = 0;
  // First slide the led in one direction
  for (int i = 0; i < NUM_LEDS; i++) {
    // Set the i'th led to red
    leds[i] = CHSV(hue++, 255, 255);
    // Show the leds
    FastLED.show();
    // now that we've shown the leds, reset the i'th led to black
    // leds[i] = CRGB::Black;
    fadeall();
    // Wait a little bit before we loop around and do it again
    delay(10);
  }


  // Now go in the other direction.
  for (int i = (NUM_LEDS) - 1; i >= 0; i--) {
    // Set the i'th led to red
    leds[i] = CHSV(hue++, 255, 255);
    // Show the leds
    FastLED.show();
    // now that we've shown the leds, reset the i'th led to black
    // leds[i] = CRGB::Black;
    fadeall();
    // Wait a little bit before we loop around and do it again
    delay(10);
  }

}

/******IR check****
   Check the command on the serial port sent by
   the other arduino depending on the button pressed
*/
void IR_Check() {

  if (Serial.available() > 0) {
    // read the incoming byte:
    incoming_command = Serial.read();
    unsigned long startTime = 0;
    switch (incoming_command) {
      
      //colors
      case 'R' :

        //Serial.println("RED");
        ledColor = CRGB::Red;
        break;

      case 'B' :

        ledColor = CRGB::Blue;
        break;

      case 'G' :

       
        ledColor = CRGB::Green;
        break;

      case 'W' :

       
        ledColor = CRGB::White;
        break;

      case 'I' :

        
        ledColor = CRGB::OrangeRed;
        break;

      case 'J' :

       
        ledColor = CRGB::GreenYellow;
        break;

      case 'K' :

        
        ledColor = CRGB::MediumSlateBlue;
        break;

      case 'L' :

       
        ledColor = CRGB::Pink;
        break;

      case 'M' :

       
        ledColor = CRGB::DarkOrange;
        break;

      case 'N' :

        
        ledColor = CRGB::Aqua;
        break;

      case 'P' :

        
        ledColor = CRGB::DarkSlateBlue;
        break;

      case 'Q' :

      
        ledColor = CRGB::LightPink;
        break;

      case 'S' :

       
        ledColor = CRGB::LightSalmon;
        break;

      case 'U' :

      
        ledColor = CRGB::LightSeaGreen;
        break;

      case 'V' :

       
        ledColor = CRGB::Purple;
        break;



      case 'X' :

       
        ledColor = CRGB::Yellow;
        break;

      case 'Y' :

       
        ledColor = CRGB::Teal;
        break;

      case 'Z' :

       
        ledColor = CRGB::PaleVioletRed;
        break;

      case '*' :

        
        ledColor = CRGB::PaleTurquoise;
        break;

      case 'F' :

        //pick a random color but not working yet
        ledColor = CRGB( random8(), 100, 50);
        break;

      case '+' : //brighter
        brightness += 10;
        if (brightness > 255) brightness = 255;
        FastLED.setBrightness( brightness );
        auto_brightness = 0;
        break;
      case '-' :

        brightness -= 10;
        if (brightness < 10) brightness = 10;
        FastLED.setBrightness( brightness );
        auto_brightness = 0;
        break;

      case 'O' : //auto brightness

        if (led_on)
        {
          brightness = 0;
          led_on = 0;
        }
        else
        {
          brightness = BRIGHTNESS_DEFAULT ;
          led_on = 1;

        }

        FastLED.setBrightness( brightness );
        break;


      case 'T' : //Temp

        Temp();


        break;


      case 'a' : //Date


        DateToArray();


        break;

      case 'A' :

        auto_brightness = 1;
        break;

      default:
        break;
        //Serial.println("error");
    }//switch

    // say what you got:
    //Serial.print("I received: ");
    //Serial.println(incoming_command);

  }
  /*  if (irrecv.decode(&results)) {
      Serial.println(results.value, HEX);
      switch(results.value) {
      case 0xFF1AE5 :

        Serial.println("RED");
        ledColor = CRGB::Red;
        break;
      default:
        Serial.println("error");
      }
      irrecv.resume(); // Receive the next value
    }
  */

};

//print the internal temperature
void Temp()
{
  FastLED.clear();
  int cursor = 21; //65
  float t = RTC.temperature();
  int celsius = t / 4.0;
  Serial.print(celsius);


  unsigned long currentMillis = millis();
  while (millis() - currentMillis < interval) {
    FastLED.show();
    int cursor = 21; //65
    float t = RTC.temperature();
    int celsius = t / 4.0;
    for (int i = 1; i <= 2; i++) {

      int digit = celsius % 10; // get last digit in time
      Serial.print("digit");
      Serial.println(digit);
      if (i == 1) {



        //Serial.print("Digit 4 is : ");
        //Serial.print(digit);
        //Serial.print(", the array is : ");

        for (int k = 0; k <= 20; k++) {

          //Serial.print(digits[digit][k]);

          if (digits[digit][k] == 1) {
            leds[cursor] = ledColor;
          }

          else if (digits[digit][k] == 0) {
            leds[cursor] = 0x000000;
          };

          cursor ++;

        }; // fin for

        FastLED.show();

      }// fin if

      else if (i == 2) {

        cursor = 0;

        //Serial.print("Digit 3 is : ");
        //Serial.print(digit);
        //Serial.print(", the array is : ");

        for (int k = 0; k <= 20; k++) {

          //Serial.print(digits[digit][k]);

          if (digits[digit][k] == 1) {
            leds[cursor] = ledColor;
          }

          else if (digits[digit][k] == 0) {
            leds[cursor] = 0x000000;
          };

          cursor ++;

        };

        // Serial.println();
      }

      celsius /= 10;
      FastLED.show();
    }
    for (int m = 44; m < 56; m++) {
      leds[m] = ledColor;
    }
    for (int m = 72; m < 83; m++) {
      leds[m] = ledColor;
    }
    FastLED.show();
    //check_for_input();
  }//fin while animate

};


//not used yet
void check_for_input() {
  if (animation_change_timeout > 100) {
    if (Serial.available() > 0) {
      // read the incoming byte:
      incoming_command = Serial.read();

      // say what you got:
      Serial.print("I received: ");
      Serial.println(incoming_command);
      animate = false;
    }
  }
}


void loop() // Main loop

{

  BrightnessCheck(); // Check brightness
  TimeToArray(); // Get leds array with required configuration
  IR_Check();
  FastLED.show(); // Display leds array
 
}

Dj-toha, в этом коде нет плавной настройки, тут только две яркости

На самом деле, у Одиночка проблема не в коде, а похоже в непнимании логики работы автояркости. У него сейчас есть все данные для правильной настройки, их только надо верно использовать

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

new_bright_f = new_bright_f * coef - new_bright * (1 - coef); 

как для вычисления неизвестного, мы это самое неизвестное умножаем на коэфициент?? Не тут ли ошибка?

МЕстами поменял в МАРе, но картинку увижу только вечером.

Если резистор работает в обратную сторону - он может стоять не в том плече.