Arduino.ru

вы от ответа не уходите. У вас лента прям с встроенным IR и блютусом? Или к чему вы это написали?

Дайте ссылку на лот ленты на Алике

 только блок питания еще надо. а если есть wifi достаточно любой ESP и ленты .

С этим проблем нет как раз...Этих часов размер будет не грандиозный как метр конечно. Цифры уже начал резать В каждый сегмент будет по 5 светодиодов....Так что думаю 20 метров мне должно хватить:))) А с проводами вашпе не вопрос.... Я в депо на пожарной сигнализации работаю, если что пару тепловозов обдеру!!!!:))))

https://aliexpress.ru/item/1005003746431372.html?spm=a2g39.orderlist.0.0...

Понятно.

Блок управления с пультом можете выкинуть (отложить в сторонку) - он для часов не подойдет.

Лента вроде нормальная.

Вы бы не могли бы мне помочь с этим девайсом? Как я уже говорил я первый раз столкнулся с этим вообще... Нужно найти где то схему, ПО... В городе бы может э\то было бы как то попроще...В деревне и спросить некого:(

DIM425 - так эта тема на 19 страниц как раз про часы - схемы, прошивки. обсуждения. Почитайте. а как что непонятно - задавайте вопросы

Спасибо.Надеюсь что то усвою.

Вообщем хватило меня на 3 страницы чтоб понять, что ничего не понятно и что придется мне все это выкинуть в ведро и довольствоваться стрелочными часами:((( Очень жаль. Всем удачи и успехов...

тут после 16 страницы всё разжевано и подписано. и даже рабочий скетч выложен.

а до 16 страницы нет? - тут скетчей этих как минимум десяток разныхю и все рабочие...

Ребят, вы конечно считаете что тут все разжованно и остается только положить в рот...Может оно так и есть, но для знающего....Это как допустим я посадив вас за орган буду говорить " Ну что у тебя за руки крюки!!! Тут же так просто играть рапсодию....Жми и слушай!!!!" Ладно, извините если кого то обижаю этим...

DIM425

Вот скетч проверенный и рабочий, выставил 5 LED на сегмент. Все подключения в скетче расписаны. Если что-то не понятно напишите.

//   Скетч доработал <FenickSnet> с Arduino.ru,  проверен на Arduino IDE 1.8.13 
//   Часы на RTC_ds3231,ws2812, bme280, ds18b20, автояркость, кнопки установки: час. мин. цвета, и ещё куча настроек под любые хотелки
//   Вывод давления, влажности, двух температур с разделительной точкой 00.0 и без точки 00 и без первого ноля (в часах тоже) см.настройки
//   ЦВЕТ: цвет цифр температуры зависит от температуры, можно менять, по умолчанию меньше или равно 00 СИНИЙ, выше 00 КРАСНЫЙ
//   Цвета тут https://github.com/FastLED/FastLED/wiki/Pixel-reference#predefined-color...
//   ТОЧКИ: если точек 2  могут мигать поочередно, одновременно или вообще не гореть
//   Код найден здесь http://arduino.ru/forum/programmirovanie/bolshie-nastennye-chasy-na-arduino ,
//   и  испорчен (но это не точно) --== FenickSnet ==-- .главное "Говнокод" работает.
//   Для atmega 168pa (~ 15918 байт (97%) ) загружать через через программатор:
//     >>>     Use bootloater: "No ( ISP Pragrammer Upload)"

// БИБЛИОТЕКИ:
#include <Adafruit_BME280.h>  // библиотека для работы c метеодатчиком BME280
#include <DS3232RTC.h>        // библиотека для работы c модулем часов DS3231
#include <FastLED.h>          // библиотека для работы с лентой ws2812

// ПИНЫ ПОДКЛЮЧЕНИЯ НА Ардуино
//  SDA -> A4      к часам DS3231 и датчику ВМЕ280
//  SCL -> A5      подключаются параллельно
//  DS18b20 -> PIN 9 или какой укажете в строке 23

#define DS18_PIN 0                            // 0 нет датчика, пин для датчика ds18b20   
                                               // 5V --> R4.7K -->PIN ( НЕ забыть резистор 4.7кОм), 
                                               // если ds18b20 в виде модуля(на плате) то резистор 4.7k не надо
#if(DS18_PIN >0)
#include <microDS18B20.h>                      // библиотека для работы с датчиком DS18b20
MicroDS18B20 sensor(DS18_PIN);                 // Создаем термометр без адресации

#define temp2_color  1                         // менять цвет при минусе 1 вкл. , не менять цвет 0 выкл.
long temp_plus2 =  CRGB::Red;                  // цвет цифр температуры при плюсе
long temp_minus2 =  CRGB::Blue;                // цвет цифр температуры при минусе  если включена смена цвета.
#endif

#define DATA_PIN 6             // подключение ленты           PIN --> R100-470 --> Din
#define BRI_PIN A1             // фоторезистор                GND --> RES --> BRI_PIN --> R10K --> +5V
                               // если фоторезистор в виде модуля то GND --> RES --> BRI_PIN --> R10K --> +5V не надо
#define M_PIN 3                // установка часов (D3)            GND --> КНОПКА --> PIN
#define H_PIN 4                // установка минут (D4)            GND --> КНОПКА --> PIN
#define D_PIN 5                // смена цвета     (D5)             GND --> КНОПКА --> PIN
#define Button_Tuoch 0         // 0 - обычные кнопки, 1 - сенсорные кнопки, 

#define LEDS_IN_SEGMENT 5      // Задаём сколько у нас светодиодов в сегменте.
#define DOTS_NUM 2             // Задаём количество разделительных точек
#define DDOT 1                 // РЕЖИМ ТОЧЕК: 0 - мигают одновременно, 1 - мигают поочередно, 2 - точки не горят 

//==================== ЕСЛИ НУЖНЫ ТОЧКИ РАСКОМЕНТИРУЙТЕ В БЛОКЕ ВЫВОДА ТЕМПЕРАТУРЫ там есть коментарии =========================
#if (DOTS_NUM==2)
#define DOT_UP 1               // если точек 2 и нижняя  разделительная ставим 1, если верхняя 0
                               // точка разделения показа температуры
#endif                        

#define Time_Zero 0            // показывать 0 или нет, если время 01:11 --> показать 1:11 (1 - показать 0, 0 - не показывать 0)
#define Csec  1                // на какой секунде смена цвета ( 0 > Csec < 60 и не попадать в диапазон (temp1_sec + work_sec) 
                               // и (temp2 + work_sec_sec) иначе смены не будет)
                               
#define COLOR_CHANGE 1         // смена цвета в минутах ( 0 - НИКОГДА, 1 - каждую минуту, 2 - каждые 2 мин, 3 - каждые 3 мин,.....10 - каждые 10 минут.... и т.д.
                               // 60 каждый час, 120 - 2 часа.... первая смена цвета в 00.00 далее через каждые COLOR_CHANGE минут  )

#define NUM_COLORS 40          // цветовая гамма 40 цветов
#define COLOR_ORDER GRB        // 12V ( BRG )   5V ( GRB )( если цвета диодов не сотвествуют, меняем )
#define auto_bright 1          // автоматическая подстройка яркости от уровня внешнего освещения (1 - включить, 0 - выключить)
#define max_bright 50         // максимальная яркость (0 - 255) если автоматическая подстройка яркости выключена, то яркость будет равна указаной 
#define min_bright 3           // минимальная яркость (0 - 255)
#define bright_constant 1021   // константа усиления от внешнего света (0 - 1023), чем МЕНЬШЕ константа, тем "резче" будет прибавляться яркость
#define coef 0.9               // коэффициент фильтра (0.0 - 1.0), чем больше - тем медленнее меняется яркость
#define bri_time 100           // период опроса фоторезистора в мс, чем больше цифра тем медленней реагирует 100

//=================================== НАСТРОЙКА ВЫВОДА МЕТЕОДАННЫХ =======================================================

//++++++++++++++++++++++++++++++++++++++++++++++  ПРОЧТИ НИЖЕ  +++++++++++++++++++++++++++++++++++++++++++++++++++++

//     на каких секундах показывать данные, можно менять по своему, в любой последовательности,
//     НО! желательно, чтобы диапазоны не накладывались.
//     например:  pres_sec был БОЛЬШЕ или РАВЕН temp1_sec  (temp_sec 10 + work_sec 4),  в данном случае pres_sec будет РАВЕН минимум 14.
//     соотвественно следующий ,будет минимум 18 ( pres_sec 14 + work_sec 4 ). и т.д. НЕ КРИТИЧНО.
//     если равно 0 то, не показываем (пропускаем или если есть промежуток то показываем время)
//     например: temp1_sec - 10, а temp2_sec - 15, а work_sec 4 то 1 сек будет отображаться время

//================================= НАСТРОЙКА НА КАКИХ СЕКУНДАХ ПОКАЗЫВАТЬ ДАННЫЕ ==========================================

#define Temp_Zero 0                  //  показывать 0 или нет, если температура 03.4 --> показать 3.4 (1 - показать 0, 0 - не показывать 0)
#define temp1_sec 5                  //  показ температуры bme280, если 0 то вместо температуры отображается время
#define temp2_sec 20                  //  показ температуры  ds18b20 или второй раз с вме280 при отсутствии ds18b20, если 0 то не отображается
#define pres_sec 10                  //  показ давления, если 0 то вместо давления отображается время
#define himy_sec 15                  //  показ влажности, если 0 то вместо влажности отображается время
#define work_sec 5                   //  сколько секунд показывать, для всех. если 0 то показываем только время.

#define temp1_color  1               // менять цвет при минусе 1 вкл. , не менять цвет 0 выкл.
long temp_plus =  CRGB::Red;        // цвет цифр температуры при плюсе bme280
long temp_minus = CRGB::Blue;        // цвет цифр температуры при минусе bme280 если включена смена цвета.

#if(DS18_PIN == 0)                   //если нет ds18b20 используем вме280
#define temp2_color (temp1_color)
long temp_plus2 =  temp_plus;       // цвет цифр температуры при плюсе
long temp_minus2 = temp_minus;      // цвет цифр температуры при минусе, если включена смена цвета.
#endif

int bri ;                           // яркость
int newTime;                        // время для времени
int ChangeTime;                     // время для смены цвета
int sec;                            // секунды
int c;                              // температура
int h;                              // влажность
int p;                              // давление
int c2;                             // температура ds18b20
int flag = 0;
int m = 0;

#if(DOTS_NUM>2)
// бред конечно
int n = 0;
int o = 1;

#endif
int new_bright, new_bright_f;
unsigned long bright_timer;        // off_timer;

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

//================================ ВЫЧИСЛЯЕМЫЕ КОНСТАНТЫ, НЕ РЕДАКТИРОВАТЬ! =================================

#define NUM_LEDS (LEDS_IN_SEGMENT * 28 + DOTS_NUM)      //общее количество светодиодов в ленте
#define DOT_X (LEDS_IN_SEGMENT * 14 )                   // координата начала точек
CRGB leds[NUM_LEDS];

#define DIG1 (NUM_LEDS - LEDS_IN_SEGMENT * 28 - DOTS_NUM)   // 1 ЦИФРА
#define DIG2 (NUM_LEDS - LEDS_IN_SEGMENT * 21 - DOTS_NUM)   // 2 ЦИФРА
#define DIG3 (NUM_LEDS - LEDS_IN_SEGMENT * 14 )             // 3 ЦИФРА
#define DIG4 (NUM_LEDS - LEDS_IN_SEGMENT * 7 )              // 4 ЦИФРА

uint8_t  digits[] = { // определяем символы для отображения
// код начинается с 0b0, далее идут 7 цифр, каждая цифра это номер фрагмента, 1 - включен, 0- отключен
// далее указан получающийся символ и порядковый номер в массиве
  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
  0b00000000,     // Digit  пусто    11 ничего не показывать
  0b01111100,     // Digit P         12
  0b01111000,     // Digit % знак % из двух частей 13
  0b01000111,     // Digit % знак % из двух частей 14
  // 0b01011000,     // Digit с  маленькая "С" справа вверху 15  если нужна большая закоментируйте эту строку и наоборот
  0b00011110,     // Digit с  большая "С" справа  15             если нужна большая раскоментируйте эту строку и наоборот
  // 0b01000000,     // знак (-) минус 16
};
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

int last_digit = 0;
long ledColor;
// другие цвета ТУТ https://github.com/FastLED/FastLED/wiki/Pixel-reference#predefined-color...
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::LawnGreen,
  CRGB::Tomato,
  CRGB::Violet,
  CRGB::Salmon,
  CRGB::Green,
  CRGB::Orange,
  CRGB::DarkOrchid,
  CRGB::YellowGreen,
  CRGB::Red,
  CRGB::Orchid,
  CRGB::Indigo,
  CRGB::DarkBlue,
  CRGB::WhiteSmoke,
  CRGB::SkyBlue,
  CRGB::BlueViolet,
  CRGB::AliceBlue,
  CRGB::Crimson,
  CRGB::DarkRed,
  CRGB::OrangeRed,
  CRGB::SeaGreen,
  CRGB::MediumOrchid,
  CRGB::SpringGreen,
  CRGB::RoyalBlue,
  CRGB::Yellow,
  CRGB::Lime,
  CRGB::DarkCyan,
  CRGB::HotPink,
  CRGB::DodgerBlue
 };
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

void setup()
{
  LEDS.addLeds<WS2812, DATA_PIN, COLOR_ORDER>(leds, NUM_LEDS);
  bme.begin(0x76); //датчик температуры bme280
  pinMode(BRI_PIN, INPUT_PULLUP);    // фоторезистор                        GND --> фоторез --> PIN --> R10K --> +5V

// для простых кнопок
#if (Button_Tuoch == 0)
  pinMode(D_PIN, INPUT_PULLUP);      // Кнопка смены цветов                 GND --> КНОПКА --> PIN
  pinMode(H_PIN, INPUT_PULLUP);      // Кнопка установка часов              GND --> КНОПКА --> PIN
  pinMode(M_PIN, INPUT_PULLUP);      // Кнопка установки минут              GND --> КНОПКА --> PIN

// для сенсорных кнопок
#elif(Button_Tuoch == 1)      // для сенсорных кнопок. у меня меньше глючит такое подключение  КНОПКА --> PIN --> R10K --> GND
  pinMode(D_PIN, INPUT);      // Кнопка смены цветов                   КНОПКА --> PIN --> R10K --> GND
  pinMode(H_PIN, INPUT);      // Кнопка установка часов                КНОПКА --> PIN --> R10K --> GND
  pinMode(M_PIN, INPUT);      // Кнопка установки минут                КНОПКА --> PIN --> R10K --> GND

#endif
  
  ledColor = ColorTable[random(NUM_COLORS)];
  New();                             // опрос при включении, иначе придется подождать
}
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 == 1)  {                        // если включена адаптивная яркость
    if (millis() - bright_timer > bri_time) {     // каждые  мс
      bright_timer = millis();                    // сброить таймер
      new_bright = map(analogRead(BRI_PIN), 0, bright_constant, max_bright, min_bright);   // когда темно яркость уменьшается
  //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)
      bri = 255 - new_bright_f;
    }
  }
  else  {
    bri = max_bright;                     // если выключена адаптивная яркость
  }
}

//=========================================== ФУНЦИИ ВЫВОДА МЕТЕОДАННЫХ =====================================

//================================== ВЫВОД ТЕМПЕРАТУРЫ С ДАТЧИКА ВМЕ280 ==============================

void TempToArray()                         // температура bme280
{
  int celsius = c;                         //
  dot_off();                               // погасим все точки
  if (temp2_color == 1) {                  // покажем при минусе другой цвет или нет
    if (celsius > 0)  {                    // если + красные цифры
      ledColor = temp_plus;
 //     leds[DOT_X + DOT_UP] = temp_plus;  // включает разделительную точку при показе температуры если надо раскоментируйте
   
    }
    else if (celsius <= 0 )  {             // если -  синие цифры
      ledColor = temp_minus;
    //  leds[DOT_X + DOT_UP] = temp_minus; // включает разделительную точку при показе температуры если надо раскоментируйте
    
    }
  }
  else {                                   // плюс и минус одним цветом
    ledColor = temp_plus;
 //   leds[DOT_X + DOT_UP] = temp_plus;    // включает разделительную точку при показе температуры если надо раскоментируйте
 
  }
  BrightDigit(digits[15], DIG4 );          //  маленький или большой знак Цельсия (с) 4й блок
  int digit = celsius % 10;
//  BrightDigit(digits[digit], DIG3);      // вывод 1/10 градуса при вкл. раделительной точки см. чуть выше то раскоментировать
   BrightDigit(digits[10], DIG3);          // знак градуса (*) 3й блок если включать показ 1/10 градуса закоментировать
  celsius /= 10;
  digit = celsius % 10;
  BrightDigit(digits[digit], DIG2);       // вторая цифра градусов
  celsius /= 10;
  digit = celsius % 10;
  if (digit == 0 && Temp_Zero == 0) {
    BrightDigit(digits[11], DIG1);        // если [digit] то показывает ноль (07 градусов), если [11]  то без ноля (7 градусов)
  }                                       // если включать показ 1/10 градуса вместо [11] вставить [digit]
  else {
    BrightDigit(digits[digit], DIG1);     // первая цифра градусов  
  } 
}

//================================== ВЫВОД ТЕМПЕРАТУРЫ С ДАТЧИКА DS18b20 ИЛИ ВМЕ280 ==============================

void TempToArray2()                       // температурa ds18b20 или вме280
{
  int celsius = c2;                       //
  dot_off();                              // погасим все точки

  if (temp2_color == 1)  {                // покажем при минусе другой цвет
    if (celsius > 0)    {                 // если плюс такой цвет цифр
      ledColor = temp_plus2;
//      leds[DOT_X + DOT_UP] = temp_plus2; // включает разделительную точку при показе температуры если нужна раскоментируйте
    }
    else if (celsius <= 0 )    {          // если минус  другой цвет цифр
      ledColor = temp_minus2;
//   leds[DOT_X + DOT_UP] = temp_minus2;  // включает разделительную точку при показе температуры если нужна раскоментируйте
     
    }
  }
  else  {                                 // плюс и минус одним цветом
    ledColor = temp_plus2;
//    leds[DOT_X + DOT_UP] = temp_plus2;  // включает разделительную точку при показе температуры если нужна раскоментируйте
  }

  BrightDigit(digits[15], DIG4 );         //  маленький или большой знак Цельсия (с) 4й блок см.строки (134-151)там поймешь
  int digit = celsius % 10;
 // BrightDigit(digits[digit], DIG3);     // вывод 1/10 градуса если вкл. раделительная точка см. чуть выше то раскоментировать
  BrightDigit(digits[10], DIG3);          // знак градуса (*) 3й блок, если включать показ 1/10 градуса то закоментировать
  celsius /= 10;  
  digit = celsius % 10;
  BrightDigit(digits[digit], DIG2);       // вторая цифра градусов
  celsius /= 10;
  digit = celsius % 10;
  if (digit == 0 && Temp_Zero == 0) {
    BrightDigit(digits[11], DIG1);        // если [digit] то показывает ноль (07 градусов), если [11]  то без ноля (7 градусов)
  }                                       // если включать показ 1/10 градуса вместо [11] вставить [digit]
                                          // что такое [11] [15] [10] (см. строки 134-151)
  else {
    BrightDigit(digits[digit], DIG1);     // первая цифра градусов  
      }
}
    
//======================================== ВЫВОД ДАВЛЕНИЯ С ДАТЧИКА ВМЕ280 ===============================

void PressureToArray()                    // показ давления
{
  int Pressure = p;

  BrightDigit(digits[12], DIG1);          //  начало знака Давления (Р) 1й блок
  int digit = Pressure % 10;
  BrightDigit(digits[digit], DIG4);       //
  Pressure /= 10;
  digit = Pressure % 10;
  BrightDigit(digits[digit], DIG3);       //
  Pressure /= 10;
  digit = Pressure % 10;
  BrightDigit(digits[digit], DIG2);       //
}

//========================================== ВЫВОД ВЛАЖНОСТИ С ДАТЧИКА ВМЕ280 ===============================

void HumidityToArray()                    //показ влажности
{
  int humidity = h;

  BrightDigit(digits[14], DIG4);          //  конец знака процентов (%) 4й блок
  BrightDigit(digits[13], DIG3);          //  начало знака процентов (%) 3й блок
  int digit = humidity % 10;
  BrightDigit(digits[digit], DIG2);       //
  humidity /= 10;
  digit = humidity % 10;
  BrightDigit(digits[digit], DIG1);       //
}

//===================================== СМЕНА ЦВЕТА ЛЕНТЫ КНОПКОЙ "DST" ================================

void DSTcheck()                           //смена цвета ленты кнопкой DST Pin
{
  int buttonDST = digitalRead(D_PIN);

  if (Button_Tuoch == 0 && buttonDST == LOW) {
    ledColor =  ColorTable[random(NUM_COLORS)];
  }
  else if (Button_Tuoch == 1 && buttonDST == HIGH) {
    ledColor =  ColorTable[random(NUM_COLORS)];
  }
  delay(100);   //время реакции на нажатие
}

//================================== УСТАНОВКА ЧАСОВ И МИНУТ ======================================

void TimeAdjust()                         // установка часов и минут
{
#if (Button_Tuoch == 0)
  int buttonH = digitalRead(H_PIN);
  int buttonM = digitalRead(M_PIN);
  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);
    New();
  }
  newTimeToArray();

#elif(Button_Tuoch == 1)

  int buttonH = digitalRead(H_PIN);
  int buttonM = digitalRead(M_PIN);
  if (buttonH == HIGH || buttonM == HIGH)
  {
    delay(100);          //время реакции на нажатие
    tmElements_t Now;
    RTC.read(Now);
    int hour = Now.Hour;
    int minutes = Now.Minute;
    int second = Now.Second;
    if (buttonH == HIGH)    {
      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);
    New();
  }
  newTimeToArray();
#endif
}

//========================================== ТОЧКИ ======================================

void dots()    // мигаем точкам
{
#if (DOTS_NUM == 2)               // если тoчек 2
  if (DDOT == 1) {                // мигаем поочереди
    if (sec % 2 == 0)      {
      leds[DOT_X ] = ledColor;
      leds[DOT_X + 1 ] = CRGB::Black;
    }
    else      {
      leds[DOT_X ] = CRGB::Black;
      leds[DOT_X + 1] = ledColor;
    }
  }
  else  if (DDOT == 0 ) {        // мигают одновременно
    if (sec % 2 == 0)      {
      for (int y = 0; y < DOTS_NUM ; y++) {
        leds[DOT_X + y ] = ledColor;
      }
    }
    else {
      dot_off();              // погасим точки
    }
  }
#elif (DOTS_NUM > 2)        // если точек больше двух(не знаю зачем)
  if (DDOT == 1)
  {
    many_dot();
  }
  else if (DDOT == 0)    {
    if (sec % 2 == 0)      {
      for (int y = 0; y < DOTS_NUM ; y++)        {
        leds[DOT_X + y ] = ledColor;
      }
    }
    else      {
      dot_off();        // погасим точки
    }
  }

#else                    // если всего 1 точка
  if (sec % 2 == 0)    {
    leds[DOT_X ] = ledColor;
  }
  else    {
    leds[DOT_X ] = CRGB::Black;
  }
#endif
}
#if (DOTS_NUM>2)
void many_dot()   // знаю знаю
{
  if (sec == 59 || m == DOTS_NUM + 1 )  {
    n = 0;
    o = 1;
    m = 0;
  }
  if (sec % 2 == 0)  {
    if (n == 0 && o == 1)    {
      leds[DOT_X + m] = ledColor;
      leds[DOT_X + m - 1] = CRGB::Black;
      m = m + 1;
      n = 1;
      o = 0;
    }
  }
  else  {
    if ( n == 1 && o == 0)    {
      leds[DOT_X + m] = ledColor;
      leds[DOT_X + m - 1] = CRGB::Black;
      m = m + 1;
      o = 1;
      n = 0;
    }
  }
}
#endif
void dot_off()    // Функция гасит все точки
{
  m = 0;
  for (int y = 0; y < DOTS_NUM ; y++)  {
    leds[DOT_X + y ] = CRGB::Black;
  }
}

//================================================ ВЫВОД ВРЕМЕНИ ==========================

void newTimeToArray()              // кажем  время
{
  int NEWtime = newTime;                    //
  int digit = NEWtime % 10;
  BrightDigit(digits[digit], DIG4);         //
  NEWtime /= 10;
  digit = NEWtime % 10;
  BrightDigit(digits[digit], DIG3);         //
  NEWtime /= 10;
  digit = NEWtime % 10;
  BrightDigit(digits[digit], DIG2);         //
  NEWtime /= 10;
  digit = NEWtime % 10;
  if (digit == 0 && Time_Zero == 0)  {
    BrightDigit(digits[11], DIG1);
  }
  else   {
    BrightDigit(digits[digit], DIG1);
  }
}

//=============================================== ПОЛУЧАЕМ ВРЕМЯ ==================================

void New()        //
{
  //=========  Получаем время ===============
  tmElements_t New;
  RTC.read(New);
  newTime =  New.Hour * 100 + New.Minute;      // время для отображения
  ChangeTime =  New.Hour * 60 + New.Minute;    // для расчета смены цвета

//  ==================================== Получаем данные с bme280 ========================
  c = bme.readTemperature() * 10;
  h = bme.readHumidity();
  p = bme.readPressure() / 133.322; // переводим в мм.в.ст ( *0.008264814301;)

//  ======= Получаем температуру с DS18В20 или вме280 ==================
#if (DS18_PIN >0)
  sensor.requestTemp();
  c2 = sensor.getTemp() * 10;
#else
  c2 = bme.readTemperature() * 10;
#endif
  FastLED.clear ();
}
//===============================================================

void loop() 
{
  tmElements_t ti;
  RTC.read(ti);
  sec = ti.Second;
  BrightnessCheck();                  // Проверяем датчик освещения
  LEDS.setBrightness(bri);            // установим яркость
  DSTcheck();                         // СМЕНА цвета кнопкой (ненужная функция, имхо).
  TimeAdjust();                       // Проверяем время если сменилось на 1 цифру

  if (sec == 0) {                      // допросим всех в
    New();
    flag = 0 ;
  }
#if(Csec !=0 && COLOR_CHANGE > 0 )
  if (sec == Csec) {                                                                // смена цвета на какой секунде

    if ( COLOR_CHANGE == 1 && flag == 0 )  {                                        // каждую минуту
      ledColor =  ColorTable[random(NUM_COLORS)]; flag = 1;
    }
    else if ( COLOR_CHANGE > 1 && flag == 0 && ChangeTime % COLOR_CHANGE == 0 )  {  // каждые COLOR_CHANGE мин
      ledColor =  ColorTable[random(NUM_COLORS)]; flag = 1;
    }
  }
#endif

#if (temp1_sec != 0)
  if (sec >= temp1_sec && sec < temp1_sec + work_sec) {   //
    long preledColor = ledColor;                          // запомним цвет
    TempToArray();                                        // покажем температуру
    ledColor = preledColor;                               // вернем цвет
    FastLED.show();
  }
#endif

#if (temp2_sec != 0)
  else if ( sec >= temp2_sec && sec < temp2_sec + work_sec) {
    long preledColor = ledColor;                             // запомним цвет
    TempToArray2();                                          // покажем температуру
    ledColor = preledColor;                                  // вернем цвет
    FastLED.show();
  }
#endif

#if (himy_sec != 0)
  else if (sec >= himy_sec && sec < himy_sec + work_sec )    //
  {
    dot_off();                                               // погасим точки
    HumidityToArray();                                       // покажем влажность
    FastLED.show();
  }
#endif

#if ( pres_sec != 0 )
  else  if (sec >= pres_sec && sec < pres_sec + work_sec)   //
  {
    dot_off();                                              // погасим точки
    PressureToArray();                                      // покажем давление
    FastLED.show();
  }
#endif

  else
  {
    dots();                                                 // точки
    newTimeToArray();                                       // покажем время
    FastLED.show();
  }
}
// END

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

А в реальных проектах обычно предполагается. что человек такую книжку уже прочитал и хоть какие-то основы знает.

[quote=kym13]

DIM425

Вот скетч проверенный и рабочий, выставил 5 LED на сегмент. Все подключения в скетче расписаны. Если что-то не понятно напишите.

Огромное вам спасибо за скетч. Попробую завтра сходить до родственника и покумекасть с самой схемой сборки всего этого...Да он вроде на ардуине лампу собирал. так что может что подскажет как это все сростить и залить. Но вам все же спасибо что помогли не просто словами а делом..

Вы бывали когда нибудь на страницах сайта alexgyver.ru ? Вот там кака раз так и сделано, но к сожалению часов там нет, Лампу огонь я бы смог воспроизвести по его объяснениям.....Но мне нужны часы...Есть проекты где вроде все объяснено, но я немного поторопился и купил з/части не под конкретный проект. а как потом исправить и сростить все...вообщем сижу и как баран на новые ворота смотрю...

это вы просто искать не умеете. На форуме гайвера таких часов как минимум два проекта, один на ардуино,  основанный на скетчах из этой ветки, а второй на ЕСП - выросший из первого...

И участники там, кстати. наполовину те же, что и здесь :)

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

Здесь проекты часов

https://community.alexgyver.ru/threads/bolshie-chasy-na-ws2812-esp8266-narodnyj-monitoring.5067/page-14

https://community.alexgyver.ru/threads/bolshie-chasy-na-adresnyx-svetodiodax-ws2812b.233/page-55#post-111755

А здесь уроки по ардуино для начинающих.

https://alexgyver.ru/arduino_lessons/

Вы бы не могли дать на тот форум ссылочку?

kym13 выше уже дал

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

Спасибо,Я обязательно почитаю....Если бы не полная уверенность что это моя единственная работа будет, то я бы поучил....Я уже больше к земле привыкаю:)))

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

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

Мне тоже 58 лет, тяжело даётся согласен.

Мне 54, но в нашей местности при трехкратном уровне радиации из-за урановых рудников в окресностях редко кто доживает до 60. Я таких по пальцам перечислить могу:)))

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

Ладно ребят(как ровесников назову вас так)....Спасибо за помощь, а то нас за флуд тут пнут, а потом и спросить некого будет:)))

Начал читать ваши ссылочки...Познавательно, основательно и залипательно.Спасибо.

[quote=DIM425]

[quote=kym13]

......что это моя единственная работа будет, то я бы поучил.... Я  тоже так думал, а потом втянулся, интересно стало. И стал собирать часы не только на WS2812, сейчас жду LED панель Р4 буду на ней часы-информер собирать. Это уже другой уровень.

мое творчество на тему LED панелей видели уже? :) - будут вопросы обращайтесь :)

С панелями какое творчество то ? С лентами руки есть куда приложить !

согласен, тогда "творчество" :)

b707

Вот это тема. Простите за наглость, а скетч к часам выше есть? Не важно на ESP8266, ESP32 или ардуина любая.

Или может на каком форуме тема есть, а то в нете в основном англоязычные сайты и их мало.

есть, выложен на амперке. Основной МК - СТМ32, доступ к сети через есп-01. Правда по сети только время синхронизируется, на веб-интерфейс уже усидчивости не хватило.

У Вас дисплей одноцветный?

Давно хотел STM взять и дождался когда на  103С8 цены взвинтили, а С6 дешевые но памяти в 2 раза меньше

можно монохром, можно двухцветные, можно RGB (разных типов)

Лучше пойти это обсуждать в отдельную тему работы с матрицами на СТМ, а то тут это оффтоп

Ну и напоследок - на матрицах ведь не только буквы можно выводить :) так что Командир зря так, там и творчество возможно. Вот например VU-метр на матрицах (картинка с Али, но собрать самому такой никаких проблем)

как вариант если есть интернет.

[code]
// часы на ESP 8266 (проверено на ESP01), DS18B20 и адресной ленте WS281x 
// как то так собрано из примеров библиотек, вроде работает. --==FenicksNet==--
// 

#include <microDS18B20.h>
MicroDS18B20<0> sensor;        // подключение ds18b20 к GPIO 0  --> DATA --> R4.7K --> +3.3V 
int tempC = 888;               // 

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

const char ssid[] = "сеть";              //  имя сети
const char pass[] = "пароль";            //  пароль сети

// NTP Servers:
static const char ntpServerName[] = "2.ru.pool.ntp.org";      // адрес NTP сервера
const int timeZone = 3;                                  // часовой пояс
#define NTP_UPDATE 60                                    // ПЕРИОД ОБНОВЛЕНИЯ ВРЕМЕНИ, МИНУТ

WiFiUDP Udp;
unsigned int localPort = 8888;                           // local port to listen for UDP packets
time_t getNtpTime();
void sendNTPpacket(IPAddress &address);
const int NTP_PACKET_SIZE = 48;                         // NTP time is in the first 48 bytes of message
byte packetBuffer[NTP_PACKET_SIZE];                     //buffer to hold incoming & outgoing packets


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

#define DATA_PIN 2             // пин подключения ленты GPIO 2  --> R 1k --> Din
#define COLOR_ORDER GRB        // 12V ( BRG )   5V ( GRB )( если цвета диодов не сотвествуют меняем:( GRB, GBR, RGB, RBG, BGR, BRG) )
#define LEDS_IN_SEGMENT 1      // Задаём сколько у нас светодиодов в сегменте.
#define DOTS_NUM 2             // Задаём количество разделительных точек
#define DDOT 1                 // миание точками одновременно(0) или поочередно(1)
#define NUM_COLORS 16          // кол-во цветов
#define Date_on  0            // показывать (1) или нет (0) . число : месяц 
#define Temp_on   1            // показывать температуру 1, нет 0
bool flag1;

// Вычислемые константы, НЕ РЕДАКТИРОВАТЬ!но если очень хочется то можно.
#define NUM_LEDS (LEDS_IN_SEGMENT * 28 + DOTS_NUM)      //общее количество светодиодов в ленте
#define DOT_X (LEDS_IN_SEGMENT * 14 )                   // координата начала точек
CRGB leds[NUM_LEDS];

#define DIG1 (NUM_LEDS - LEDS_IN_SEGMENT * 28 - DOTS_NUM)   // 1 ЦИФРА
#define DIG2 (NUM_LEDS - LEDS_IN_SEGMENT * 21 - DOTS_NUM)   // 2 ЦИФРА
#define DIG3 (NUM_LEDS - LEDS_IN_SEGMENT * 14 )             // 3 ЦИФРА
#define DIG4 (NUM_LEDS - LEDS_IN_SEGMENT * 7 )              // 4 ЦИФРА

uint8_t  digits[] = {
  0b00111111,     // 0  Digit 0
  0b00100001,     // 1  Digit 1
  0b01110110,     // 2  Digit 2
  0b01110011,     // 3  Digit 3
  0b01101001,     // 4  Digit 4
  0b01011011,     // 5  Digit 5
  0b01011111,     // 6  Digit 6
  0b00110001,     // 7  Digit 7
  0b01111111,     // 8  Digit 8
  0b01111011,     // 9  Digit 9
  0b00000000,     // 10 Digit  пусто (ничего не показывать)
  0b01000000,     // 11 Digit - ( знак минус)
  0b01011000,     // 12 Digit c
};

int last_digit = 0;

// другие цвета ТУТ https://github.com/FastLED/FastLED/wiki/Pixel-reference#predefined-color...
long ColorTable[NUM_COLORS] = {
  CRGB::Amethyst,
  CRGB::Aqua,
  CRGB::Blue,
  CRGB::Chartreuse,
  CRGB::DarkMagenta,
  CRGB::DarkOrange,
  CRGB::DeepPink,
  CRGB::Fuchsia,
  CRGB::Gold,
  CRGB::GreenYellow,
  CRGB::LightCoral,
  CRGB::Tomato,
  CRGB::Salmon,
  CRGB::Green,
  CRGB::Orchid,
  CRGB::DarkOrchid
};
long ledColor;

void setup()
{

  LEDS.addLeds<WS2812, DATA_PIN, COLOR_ORDER>(leds, NUM_LEDS);

  Serial.begin(115200);
  while (!Serial) ; // Needed for Leonardo only
  delay(250);
  Serial.println("TimeNTP Example");
  Serial.print("Connecting to ");
  Serial.println(ssid);
  WiFi.begin(ssid, pass);

  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
    TempToArray();
    ledColor =  ColorTable[random(NUM_COLORS)];
    FastLED.show();
  }

  Serial.print("IP number assigned by DHCP is ");
  Serial.println(WiFi.localIP());
  Serial.println("Starting UDP");
  Udp.begin(localPort);
  Serial.print("Local port: ");
  Serial.println(Udp.localPort());
  Serial.println("waiting for sync");
  setSyncProvider(getNtpTime);
  setSyncInterval(NTP_UPDATE * 60);

  sensor.requestTemp();
  tempC = sensor.getTemp() * 10 ;
  flag1 = false;

}

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 TimeToArray()              // кажем  время
{
  dots();

  uint8_t  MH = minute();
  uint8_t digit = MH % 10;
  BrightDigit(digits[digit], DIG4);         //

  MH /= 10;
  digit = MH % 10;
  BrightDigit(digits[digit], DIG3);         //

  MH = hour();
  digit = MH % 10;
  BrightDigit(digits[digit], DIG2);         //

  MH /= 10;
  digit = MH % 10;

  if (digit == 0)  {
    BrightDigit(digits[10], DIG1);
  }
  else   {
    BrightDigit(digits[digit], DIG1);
  }
}

void DateToArray()              // кажем  дату
{
  if ( DOTS_NUM == 2 )
  {
    leds[DOT_X ] = ledColor;
    leds[DOT_X + 1 ] = ledColor;
  }
  else
  {
    leds[DOT_X ] = ledColor;
  }

  uint8_t MH = month();
  uint8_t digit = MH % 10;
  BrightDigit(digits[digit], DIG4);         //
  MH /= 10;
  digit = MH % 10;
  BrightDigit(digits[digit], DIG3);         //
  MH = day();

  digit = MH % 10;
  BrightDigit(digits[digit], DIG2);         //
  MH /= 10;
  digit = MH % 10;
  if (digit == 0)  {
    BrightDigit(digits[10], DIG1);
  }
  else   {
    BrightDigit(digits[digit], DIG1);
  }
}


void TempToArray()
{
  if ( DOTS_NUM == 2 )
  {
    leds[DOT_X ] = ledColor;
    leds[DOT_X + 1 ] = CRGB::Black;
  }
  else
  {
    leds[DOT_X ] = ledColor;
  }

  BrightDigit(digits[12], DIG4);         //
  int temp = tempC;
  uint8_t digit = temp % 10;
  BrightDigit(digits[digit], DIG3);         //
  temp /= 10;
  digit = temp % 10;
  BrightDigit(digits[digit], DIG2);         //
  temp /= 10;
  digit = temp % 10;
  if (digit == 0)
  {
    BrightDigit(digits[10], DIG1);
  }
  else
  {
    BrightDigit(digits[digit], DIG1);
  }
}
void dots()                               // мигаем точкам
{
  if ( DOTS_NUM == 2)
  {
    if (DDOT == 1 )                      // мигаем поочереди
    {
      if (second() % 2 == 0)
      {
        leds[DOT_X ] = ledColor;
        leds[DOT_X + 1 ] = CRGB::Black;
      }
      else
      {
        leds[DOT_X ] = CRGB::Black;
        leds[DOT_X + 1] = ledColor;
      }
    }
    else  if (DDOT == 0 )                // мигают одновременно
    {
      if (second() % 2 == 0)
      {
        leds[DOT_X ] = ledColor;
        leds[DOT_X + 1 ] = ledColor;
      }
      else
      {
        leds[DOT_X ] = CRGB::Black;
        leds[DOT_X + 1 ] = CRGB::Black;
      }
    }
  }
  else if ( DOTS_NUM == 1)
  {
    if (second() % 2 == 0)
    {
      leds[DOT_X ] = ledColor;
    }
    else
    {
      leds[DOT_X ] = CRGB::Black;
    }
  }
}

void loop()
{
  if (second() == 0 && flag1 == true)
  {
    sensor.requestTemp();
    tempC = sensor.getTemp() * 10 ;
    flag1 = false;
  }
  else if ( second() != 0)
  {
    flag1 = true;
  }
  
  if ( Date_on == 1  && ((second() >= 10 && second() < 12) || (second() >= 30 && second() < 32) || (second() >= 50 && second() < 52)))
  {
    DateToArray()  ;
  }
  else if (  Temp_on == 1 && ((second() >= 12 && second() < 16) || (second() >= 32 && second() < 36) || (second() >= 52 && second() < 56)))
  {
    TempToArray();
  }
  else
  {
    TimeToArray();
  }
  FastLED.show();
}

/*-------- NTP code ----------*/

time_t getNtpTime()
{
  IPAddress ntpServerIP; // NTP server's ip address

  while (Udp.parsePacket() > 0) ; // discard any previously received packets
  Serial.println("Transmit NTP Request");
  // get a random server from the pool
  WiFi.hostByName(ntpServerName, ntpServerIP);
  Serial.print(ntpServerName);
  Serial.print(": ");
  Serial.println(ntpServerIP);
  sendNTPpacket(ntpServerIP);
  uint32_t beginWait = millis();
  while (millis() - beginWait < 1500) {
    int size = Udp.parsePacket();
    if (size >= NTP_PACKET_SIZE) {
      Serial.println("Receive NTP Response");
      Udp.read(packetBuffer, NTP_PACKET_SIZE);  // read packet into the buffer
      unsigned long secsSince1900;
      // convert four bytes starting at location 40 to a long integer
      secsSince1900 =  (unsigned long)packetBuffer[40] << 24;
      secsSince1900 |= (unsigned long)packetBuffer[41] << 16;
      secsSince1900 |= (unsigned long)packetBuffer[42] << 8;
      secsSince1900 |= (unsigned long)packetBuffer[43];
      return secsSince1900 - 2208988800UL + timeZone * SECS_PER_HOUR;
    }
  }
  Serial.println("No NTP Response :-(");
  return 0; // return 0 if unable to get the time
}

// send an NTP request to the time server at the given address
void sendNTPpacket(IPAddress &address)
{
  // set all bytes in the buffer to 0
  memset(packetBuffer, 0, NTP_PACKET_SIZE);
  // Initialize values needed to form NTP request
  // (see URL above for details on the packets)
  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;
  // all NTP fields have been given values, now
  // you can send a packet requesting a timestamp:
  Udp.beginPacket(address, 123); //NTP requests are to port 123
  Udp.write(packetBuffer, NTP_PACKET_SIZE);
  Udp.endPacket();
}
[/code]

P.S. тапками не кидать.

Fenicksnet, для есп8266 есть отдельная библиотека NTPClient.h, весь ваш код начиная со строки 300 выродится в пару строк.

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

Начиная с 300 строки моего вообще ничего нет. Я пока даже смотреть туда боюсь. :-)

пока сложно. попробовал вот так, но так светодиоды начинают  хаотично мерцать при использовании с DS18B20. если закомментировать  стр 218 или 223  то мерцаний  нет.

[code]
#include <NTPClient.h>
#include <ESP8266WiFi.h>
#include <WiFiUdp.h>

// датчик температуры // 0x28, 0xB1, 0xCD, 0x56, 0xB5, 0x01, 0x3C, 0x61
// не работает, температура не соответствует даже в примерах.
//#include <OneWire.h>
//#include <DallasTemperature.h>
//OneWire oneWire(0); // вход датчиков 18b20
//DallasTemperature sensor(&oneWire);

#include <microDS18B20.h>
MicroDS18B20<0> sensor;

int TempC = 888;

// лента WS281х
#include <FastLED.h>           // библиотек для ленты
#define DATA_PIN 2             // пин подключения ленты GPIO 2  --> R 1k --> Din
#define COLOR_ORDER GRB        // 12V ( BRG )   5V ( GRB )( если цвета диодов не сотвествуют меняем:( GRB, GBR, RGB, RBG, BGR, BRG) )
#define LEDS_IN_SEGMENT 1      // Задаём сколько у нас светодиодов в сегменте.
#define DOTS_NUM 2             // Задаём количество разделительных точек
#define DDOT 1                 // миание точками одновременно(0) или поочередно(1)
#define NUM_COLORS 16          // кол-во цветов
#define Date_on  1             // показывать (1) или нет (0) . число : месяц 
#define Temp_on   1            // показывать температуру 1, нет 0

uint32_t timer;
uint8_t Hour, Min, Sec;
bool flag;

const char *ssid     = "lcrn";                    // имя сети
const char *password = "12341234";                // пароль сети

#define TIME_ZONE 3                              //  часовой пояс
const char ntpServerName[] = "192.168.1.53";     //  сервер времени
#define NTP_UPDATE 60                            //  период обновления времени минут
WiFiUDP ntpUDP;
NTPClient timeClient(ntpUDP, ntpServerName, TIME_ZONE * 3600, NTP_UPDATE * 60000);

// Вычислемые константы, НЕ РЕДАКТИРОВАТЬ!но если очень хочется то можно.
#define NUM_LEDS (LEDS_IN_SEGMENT * 28 + DOTS_NUM)      //общее количество светодиодов в ленте
#define DOT_X (LEDS_IN_SEGMENT * 14 )                   // координата начала точек
CRGB leds[NUM_LEDS];

#define DIG1 (NUM_LEDS - LEDS_IN_SEGMENT * 28 - DOTS_NUM)   // 1 ЦИФРА
#define DIG2 (NUM_LEDS - LEDS_IN_SEGMENT * 21 - DOTS_NUM)   // 2 ЦИФРА
#define DIG3 (NUM_LEDS - LEDS_IN_SEGMENT * 14 )             // 3 ЦИФРА
#define DIG4 (NUM_LEDS - LEDS_IN_SEGMENT * 7 )              // 4 ЦИФРА

uint8_t  digits[] = {
  0b00111111,     // 0  Digit 0
  0b00100001,     // 1  Digit 1
  0b01110110,     // 2  Digit 2
  0b01110011,     // 3  Digit 3
  0b01101001,     // 4  Digit 4
  0b01011011,     // 5  Digit 5
  0b01011111,     // 6  Digit 6
  0b00110001,     // 7  Digit 7
  0b01111111,     // 8  Digit 8
  0b01111011,     // 9  Digit 9
  0b00000000,     // 10 Digit  пусто (ничего не показывать)
  0b01000000,     // 11 Digit - ( знак минус)
  0b01011000,     // 12 Digit c
};

long ledColor;
// другие цвета ТУТ https://github.com/FastLED/FastLED/wiki/Pixel-reference#predefined-color...
long ColorTable[NUM_COLORS] = {
  CRGB::Amethyst,
  CRGB::Aqua,
  CRGB::Blue,
  CRGB::Chartreuse,
  CRGB::DarkMagenta,
  CRGB::DarkOrange,
  CRGB::DeepPink,
  CRGB::Fuchsia,
  CRGB::Gold,
  CRGB::GreenYellow,
  CRGB::LightCoral,
  CRGB::Tomato,
  CRGB::Salmon,
  CRGB::Green,
  CRGB::Orchid,
  CRGB::DarkOrchid
};

void setup() {
  Serial.begin(115200);

  LEDS.addLeds<WS2812, DATA_PIN, COLOR_ORDER>(leds, NUM_LEDS);
  ledColor =  ColorTable[random(NUM_COLORS)];
  WiFi.begin(ssid, password);

  //  =====dallas
  //  sensor.begin();

  while ( WiFi.status() != WL_CONNECTED ) {
    delay ( 500 );
    Serial.print ( "." );
  }
  Serial.println(" ");
  Serial.println(WiFi.localIP());

  timeClient.begin();
  timeClient.update();
  Min = timeClient.getMinutes();
  Hour = timeClient.getHours();
}

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 dots()                               // мигаем точкам
{
  if ( DOTS_NUM == 2)  {
    if (DDOT == 1 )                    // мигаем поочереди
    {
      if (Sec % 2 == 0)      {
        leds[DOT_X ] = ledColor;
        leds[DOT_X + 1 ] = CRGB::Black;
      }
      else      {
        leds[DOT_X ] = CRGB::Black;
        leds[DOT_X + 1] = ledColor;
      }
    }
    else  if (DDOT == 0 )                // мигают одновременно
    {
      if (Sec % 2 == 0)      {
        leds[DOT_X ] = ledColor;
        leds[DOT_X + 1 ] = ledColor;
      }
      else      {
        leds[DOT_X ] = CRGB::Black;
        leds[DOT_X + 1 ] = CRGB::Black;
      }
    }
  }
  else if ( DOTS_NUM == 1)  {
    if (Sec % 2 == 0)    {
      leds[DOT_X ] = ledColor;
    }
    else    {
      leds[DOT_X ] = CRGB::Black;
    }
  }
}

void TimeToArray()              // кажем  время
{
  dots();
  uint8_t  MH = Min;
  uint8_t digit = MH % 10;
  BrightDigit(digits[digit], DIG4);         //

  MH /= 10;
  digit = MH % 10;
  BrightDigit(digits[digit], DIG3);         //

  MH = Hour;
  digit = MH % 10;
  BrightDigit(digits[digit], DIG2);         //

  MH /= 10;
  digit = MH % 10;

  if (digit == 0)  {
    BrightDigit(digits[10], DIG1);
  }
  else   {
    BrightDigit(digits[digit], DIG1);
  }
}

void TempToArray()
{
  if ( DOTS_NUM == 2 )  {
    leds[DOT_X ] = ledColor;
    leds[DOT_X + 1 ] = CRGB::Black;
  }
  else  {
    leds[DOT_X ] = ledColor;
  }

  BrightDigit(digits[12], DIG4);         //
  int tempC = TempC;
  uint8_t digit = tempC % 10;
  BrightDigit(digits[digit], DIG3);         //
  tempC /= 10;
  digit = tempC % 10;
  BrightDigit(digits[digit], DIG2);         //
  tempC /= 10;
  digit = tempC % 10;
  if (digit == 0)  {
    BrightDigit(digits[10], DIG1);
  }
  else  {
    BrightDigit(digits[digit], DIG1);
  }
}

void loop() {

  if ( millis() - timer > 10000)
  {
    timer = millis();
    //======== dallas
    // sensor.requestTemperatures();
    // Serial.print(sensor.getTempCByIndex(0));     // глючит
    //TempC = sensor.getTempCByIndex(0);
    
    //=======  microDS
    sensor.requestTemp();
   // Serial.println(sensor.getTemp());             // и тут глючит
    TempC = sensor.getTemp();
  }

  timeClient.update();
  Sec = timeClient.getSeconds();
  if (  Sec == 0 && flag == true)
  {
    ledColor = ColorTable[random(NUM_COLORS)];
    Min = timeClient.getMinutes();
    Hour = timeClient.getHours();
    flag = false;
  }
  if (Sec == 59)
  {
    flag = true;
  }
  TimeToArray() ;
  FastLED.show();

}
[/code]

Fenicksnet

А Вы какую плату в менеджере ставили для прошивки?

 generic esp8266, lolin (wemos), nodemcu. от платы тоже не зависит,  на esp01,  wemos и  node тоже мерцают.

Гляньте ещё на мой вариант https://youtu.be/m-ZY15XYFMU
https://youtu.be/7eOAVlV6NaM
https://youtu.be/SFapLHFcLQc
Проработаный, вылизаный, с кучей фишек и настроек и с боем
Требует минимум компонентов

Еще немного поигрался на обеде.

// часики с температурой на ESP8266 и DS18B20.
// версия ядра ESP 2.7.4, версия выше не работает, мерцают светодиоды
// не забыть указвать часовой пояс, сервер NTP.
// для подключения к своему WIFI.  
//подключится к сети CLOCK_ESP, перейти по адресу 192.168.4.1 выбрать свою сеть и ввести  пароль.
/* последовательность подключения сегментов
     ---3----    ---10---        ---19--     ---26---
     |      |    |      |        |      |   |       |
     |      |    |      |        |      |   |       |
     4      2    11     9   16   20    18   27      25
     |      |    |      |   |    |      |   |       |
     |      |    |      |   |    |      |   |       |
  Di >--1----    ---8---    |    ---17---     ---24---
     |      |    |      |   |    |      |   |       |
     |      |    |      |   |    |      |   |       |
     5      7   12     14   15   21    23   28     30
     |      |    |      |        |      |   |       |
     |      |    |      |        |      |   |       |
     ---6---     ---13---        ---22---    ---29---
*/
#include <WiFiManager.h> // https://github.com/tzapu/WiFiManager
#include <NTPClient.h>
#include <WiFiUdp.h>

#define AP_SSID "CLOCK_ESP"                       //  имя wifi сети создаваемой esp для подключения 
char ntpServerName[] = "192.168.1.53";            //  сервер времени, например "3.ru.pool.ntp.org"
int TIME_ZONE = 30 ;                               //  часовой пояс ( если часовой пояс +1.30 указать 15) лень
int NTP_UPDATE = 60 ;                             //  период обновления времени минут
WiFiUDP ntpUDP;
NTPClient timeClient(ntpUDP, ntpServerName, TIME_ZONE * 360, NTP_UPDATE * 60000);

// лента WS281х
#include <FastLED.h>               // библиотека для ленты
#define DATA_PIN 2                 // пин подключения ленты GPIO 2  --> R 1k --> Din
#define COLOR_ORDER GRB            // 12V ( BRG )   5V ( GRB )( если цвета диодов не сотвествуют меняем:( GRB, GBR, RGB, RBG, BGR, BRG) )
#define LEDS_IN_SEGMENT 1          // Задаём сколько у нас светодиодов в сегменте.
#define DOTS_NUM 2                 // Задаём количество разделительных точек 0 , 1 или 2.
#define LEDS_IN_DOTS 1             // количество светодиодов в 1 точке
#define DOT_BLINK 1                // мигать точками одновременно(0) или поочереди (1) 
#define NUM_COLORS 16              // кол-во цветов
#define Bright 255                 // яркость ленты (0-255)
// температура
#include <microDS18B20.h>          // библиотека ds18b20
#define DS18_pin 0                 // пин подключения датчика DS18B20
#define TEMP_UPDATE 20             // период обновления датчика температуры секунд.
#define Temp_on   1                // показывать температуру 1, нет 0.
#define Temp_minus 1               // показывать знак минус 1, нет 0 ( если температура выше -10)
#define Temp_show 15               // периодичность показа температуры сек.
#define Temp_show_time 3           // сколько секунд показывать температуру
#define Temp_Resolution 11         // разрешение термометра (9-12)
#define Color_minus 1              // менять цвет температуры при отрицательном значении  1 менять, 0 не менять
#define Color_plus 1               // менять цвет температуры при положительном значении  1 менять, 0 не менять
long TempM_Color = CRGB::Blue;     // цвет температуры при отрицательном значении
long TempP_Color = CRGB::Red;      // цвет температуры при положительном значении

uint32_t Temp_timer;
uint8_t Hour, Min, Sec;
bool flag, Start = true;
int TempC = -888;
long PreledColor;

// другие цвета ТУТ <a href="https://github.com/FastLED/FastLED/wiki/Pixel-reference#predefined-colors-list"
long ColorTable[NUM_COLORS] = {
  CRGB::Amethyst,
  CRGB::Aqua,
  CRGB::Blue,
  CRGB::Chartreuse,
  CRGB::DarkMagenta,
  CRGB::DarkOrange,
  CRGB::DeepPink,
  CRGB::Fuchsia,
  CRGB::Gold,
  CRGB::GreenYellow,
  CRGB::LightCoral,
  CRGB::Tomato,
  CRGB::Salmon,
  CRGB::Green,
  CRGB::Orchid,
  CRGB::DarkOrchid
};
long ledColor =  ColorTable[random(NUM_COLORS)];

// Вычислемые константы, НЕ РЕДАКТИРОВАТЬ!но если очень хочется то можно.
#define Temp_Update (TEMP_UPDATE*1000)                  // опрос датчика температуры
MicroDS18B20<DS18_pin> DS18;

#define NUM_DOTS (DOTS_NUM * LEDS_IN_DOTS)              //  количество диодов в точках
#define NUM_LEDS (LEDS_IN_SEGMENT * 28 + NUM_DOTS)      //  общее количество светодиодов в ленте
#define DOT_X (LEDS_IN_SEGMENT * 14 )                   //  координата начала точек
CRGB leds[NUM_LEDS];

#define DIG1 (NUM_LEDS - LEDS_IN_SEGMENT * 28 - NUM_DOTS)     // 1 ЦИФРА
#define DIG2 (NUM_LEDS - LEDS_IN_SEGMENT * 21 - NUM_DOTS)     // 2 ЦИФРА
#define DIG3 (NUM_LEDS - LEDS_IN_SEGMENT * 14 )               // 3 ЦИФРА
#define DIG4 (NUM_LEDS - LEDS_IN_SEGMENT * 7 )                // 4 ЦИФРА

uint8_t  digits[] = {
  0b00111111,     // 0  Digit 0
  0b00100001,     // 1  Digit 1
  0b01110110,     // 2  Digit 2
  0b01110011,     // 3  Digit 3
  0b01101001,     // 4  Digit 4
  0b01011011,     // 5  Digit 5
  0b01011111,     // 6  Digit 6
  0b00110001,     // 7  Digit 7
  0b01111111,     // 8  Digit 8
  0b01111011,     // 9  Digit 9
  0b00000000,     // 10 Digit  пусто (ничего не показывать)
  0b01000000,     // 11 Digit - ( знак минус)
  0b01011000,     // 12 Digit c
};

void setup() {

  WiFi.mode(WIFI_STA);
  //Serial.begin(115200);
  DS18.setResolution(Temp_Resolution);
  LEDS.addLeds<WS2812, DATA_PIN, COLOR_ORDER>(leds, NUM_LEDS);
  FastLED.setBrightness(Bright);
  PreledColor = ledColor;
  timeClient.begin();
  WiFiManager wm;
  wm.autoConnect(AP_SSID);

  if (Color_minus == 0 ) {
    TempM_Color = ledColor;
  }
  if (Color_plus == 0)    {
    TempP_Color = ledColor;
  }
}
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 TimeToArray() {
  dots();
  uint8_t  MH = Min;
  uint8_t digit = MH % 10;
  BrightDigit(digits[digit], DIG4);         //
  MH /= 10;
  digit = MH % 10;
  BrightDigit(digits[digit], DIG3);         //
  MH = Hour;
  digit = MH % 10;
  BrightDigit(digits[digit], DIG2);         //
  MH /= 10;
  digit = MH % 10;
  if (digit == 0)  {
    BrightDigit(digits[10], DIG1);
  }
  else   {
    BrightDigit(digits[digit], DIG1);
  }
}
//===== температура
void TempToArray() {
  int tempC;
  if ( TempC < 0)  {
    tempC = (TempC * (-1));
    ledColor = TempM_Color;
  }
  else  {
    tempC = TempC;
    ledColor = TempP_Color;
  }

  if ( DOTS_NUM == 1 )  {
    for (int i = 0; i < NUM_DOTS; i++) {
      leds[DOT_X + i ] = ledColor;
    }
  }
  else  {
    for (int i = 0; i < NUM_DOTS / 2 ; i++)
    {
      leds[DOT_X + i ] = ledColor;
      FastLED.show();
    }
    for (int i = NUM_DOTS / 2 ; i < NUM_DOTS; i++)
    {
      leds[DOT_X + i ] = CRGB::Black;
      FastLED.show();
    }
  }
  BrightDigit(digits[12], DIG4);         //

  uint8_t digit = tempC % 10;
  BrightDigit(digits[digit], DIG3);         //
  tempC /= 10;
  digit = tempC % 10;
  BrightDigit(digits[digit], DIG2);         //
  tempC /= 10;
  digit = tempC % 10;
  if (digit == 0)  {
    if (Temp_minus == 1 && TempC <= 0)
    {
      BrightDigit(digits[11], DIG1);
    }
    else
    {
      BrightDigit(digits[10], DIG1);
    }
  }
  else  {
    BrightDigit(digits[digit], DIG1);
  }
}
//========// мигаем точками
void dots()
{
  if ( DOTS_NUM == 1)  {                                   // если  1 точка
    if (Sec % 2 == 0)    {
      for (int i = 0; i < NUM_DOTS; i++) {
        leds[DOT_X + i ] = ledColor;
        FastLED.show();
      }
    }
    else    {
      for (int i = 0; i < NUM_DOTS; i++) {
        leds[DOT_X + i ] = CRGB::Black;
        FastLED.show();
      }
    }
  }

  else  if ( DOTS_NUM == 2)  {                               // если 2 точки
    if (DOT_BLINK) {                                         //  мигаем поочереди
      if (Sec % 2 == 0)      {
        for (int i = 0; i < NUM_DOTS / 2; i++) {
          leds[DOT_X + i ] = ledColor;
          leds[DOT_X + NUM_DOTS / 2 + i ] = CRGB::Black;
          FastLED.show();
        }
      }
      else      {
        for (int i = 0; i < NUM_DOTS / 2; i++) {
          leds[DOT_X + i ] = CRGB::Black;
          leds[DOT_X + NUM_DOTS / 2 + i ] = ledColor;
          FastLED.show();
        }
      }
    }
    else                                                    // 2 точки мигают одновременно
    {
      if (Sec % 2 == 0)      {
        for (int i = 0; i < NUM_DOTS; i++) {
          leds[DOT_X + i ] = ledColor;
          FastLED.show();
        }
      }
      else      {
        for (int i = 0; i < NUM_DOTS; i++) {
          leds[DOT_X + i ] = CRGB::Black;
          FastLED.show();
        }
      }
    }
  }
}

void loop() {
  timeClient.update();
  Sec = timeClient.getSeconds();

  if (Start == true && Min != timeClient.getMinutes())  {
    Min = timeClient.getMinutes();
    Hour = timeClient.getHours();
    Start = false;
  }

  if ( millis() - Temp_timer >= Temp_Update)  {
    DS18.requestTemp();
    if (DS18.readTemp()) {
      TempC = (DS18.getTemp() * 10);
    }
    Temp_timer = millis();
  }

  if (  Sec == 0 && flag == true)  {
    ledColor = ColorTable[random(NUM_COLORS)];
    Min = timeClient.getMinutes();
    Hour = timeClient.getHours();
    flag = false;
  }
  else if (Sec == 59)  {
    flag = true;
  }
  if ( Temp_on  == 1 && ( Sec % Temp_show > 0  && Sec % Temp_show <= Temp_show_time))
  {
    PreledColor = ledColor;
    TempToArray();
    ledColor = PreledColor;
  }
  else  {
    TimeToArray() ;
  }
  FastLED.show();
}

Библиотеку microDS1820 которую Вы использовали скиньте, а то не компилируется.

Счас меня тапками закидают https://github.com/GyverLibs/microDS18B20

ну почему - хотите, используйте либы гайвера на здоровье :) Только если вдруг вылезут проблемы - не жалуйтесь и не спрашивайте, как их исправить, потому что первый ответ будет - сначала выкинуть все его либы, а потом пробовать :)

....часовой пояс ( если часовой пояс +1.30 указать 15) лень .... Чё то я это не очень понял!!! А если у меня +6 то что писать?

писать  60. т.е. часовой пояс умножить на 10,но  если он еще плюс 30 минут, то +5. если кто нибудь напишет как правильно  пересчитать, буду премного благодарен.