Arduino.ru

Здесь. Свою далласовую температуру выкиньте. И по образу и подобию как там. 
Вариантов два - если вывод достаточно частый, запустили конвертацию сразу после считывания, перед выводом считали и напечатали. Будет отставать на интервал вывода на экран. Если вывод редко, за секунду до него, запустили конвертацию, перед выводом считали.

не поэтому, а потому что библиотека кривая - между строчками 174 и 175 кода у вас фактичеки вставлен delay(750)

Так что прислушайтесь к совету - выкиньте нафиг Далласовскую библиотеку и сделайте запрос температуры как в ссылке у bwn

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

очень интересную темку подкинули благодарствую, интересно, но в силу своей неграмотности в этой области много не понятного =) и еще вот интересно, а почему таких затупов нет при снятии темпера с DHT11 и RTC они в скетче закоментированы /* ..... */

да и с DS18B20 нет никаких затупов, если писать правильно. bwn же дал ссылку, как это делать. Если что непонятно - спрашивайте

с вариантом предложеным bwn так и не допёр как сделать (ругается на строчку ISR (WDT_vect){), библиотеку далосовскую убрал и сделал так, вроде ни че не изменилось =) то же только сбоку =)

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


#define LEDS_IN_SEGMENT 1         // задаём сколько у нас светодиодов в сегменте
#define DOTS_NUM 1                // задаём сколько у нас разделительных точек
#define COLOR_CHANGE 0            // смена цвета ( 0 - никогда, 1 - раз в минуту, 2 - каждые десять минут, 3 - каждый час, 4 - каждые десять часов)
#define NUM_COLORS 16             // количество цветов
#define COLOR_ORDER BGR           // по умолчанию цвет стоит зелёный при выключенных режимах
#define DATA_PIN 13               // пин ленты 
#define BRI_PIN A3                // пин фоторезистора
#define auto_bright 1             // автоматическая подстройка яркости от уровня внешнего освещения (1 - включить, 0 - выключить)
#define max_bright 250            // максимальная яркость (0 - 255)
#define min_bright 80             // минимальная яркость (0 - 255)
#define bright_constant 1000      // константа усиления от внешнего света (0 - 1023), чем МЕНЬШЕ константа, тем "резче" будет прибавляться яркость
#define coef 0.9                  // коэффициент фильтра (0.0 - 1.0), чем больше - тем медленнее меняется яркость

OneWire  ds(10); 
//byte addr[8]={0x28, 0xFF, 0x2E, 0x75, 0xB3, 0x16, 0x03, 0xC7};


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,     // цифра 0
  0b00100001,     // цифра 1
  0b01110110,     // цифра 2
  0b01110011,     // цифра 3
  0b01101001,     // цифра 4
  0b01011011,     // цифра 5
  0b01011111,     // цифра 6
  0b00110001,     // цифра 7
  0b01111111,     // цифра 8
  0b01111011,     // цифра 9
  0b01111000,     // символ * градус 10
  0b00011110,     // символ C        11
  0b01111100,     // символ P        12
  0b01111000,     // символ % знак % из двух частей 13
  0b01000111,     // символ % знак % из двух частей 14
};
//---------------------------------------------------------------------------------------------------
bool Dot = true;
bool TempShow = true;
int last_digit = 0;
//---------------------------------------------------------------------------------------------------
long ledColor = CRGB::Aqua; // используемый цвет
long ColorTable[NUM_COLORS] = {
  CRGB::Red,
  CRGB::Orange,
  CRGB::Yellow,
  CRGB::Blue,
  CRGB::Green,
  CRGB::Purple,
  CRGB::Pink,
  CRGB::White,
  CRGB::Violet,
  CRGB::SkyBlue,
  CRGB::LightBlue,
  CRGB::Green,
  CRGB::Lime,
  CRGB::Blue,
  CRGB::Red,
  CRGB::Cyan
};
//---------------------------------------------------------------------------------------------------
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);      // установить новую яркость
    }
  }
};
//---------------------------------------------------получаем время--------------------------------------------------------------
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;
  };
};
//----------------------------------------------Функция вывода температуры----------------------------------------------------------
void TempToArray(){      // вывод температуры с DALLAS DS18B20          
  tmElements_t tm;
  RTC.read(tm); 
  if (tm.Second != 30) {        
  TempShow = false;          
    return;                    
  }
 TempShow = true;             
 byte data[2];
ds.reset(); 
ds.write(0xCC);
ds.write(0x44);
delay(750);
ds.reset();
ds.write(0xCC);
ds.write(0xBE);
data[0] = ds.read(); 
data[1] = ds.read();
int Temp = (data[1]<< 8)+data[0];
 int celsius = Temp>>4;
  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() {       //Вывод температуры с DHT11 
  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(){        //Вывод температуры с RTC3231 
  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 (2000); // время отображения температуры (3000 = 3 сек)
}

Чтобы мозк Вам не взрывать, спуститесь ниже. Там на 1-й странице тоже самое, но на миллис. Глобально объявляете адрес датчика addr[], переменную хранения температуры float Temp, и переменную времени считывания byte flagDallRead. В самой функции, для одного датчика, убираете цикл for {....}, оставив его тело. Вызов из луп - dallRead(flagDallRead*1000);.  Значения берете из глобальной Temp, где Вам нужно.

P/S Втулив 177 строку, Вы повторили ту библиотеку, измениться ничего и не должно было.

P/P/S И это, не пихайте вывод на экран во все щели, пусть функция считывания, будет функцией считывания, а отображения, отображением, самому много легше будет. ИМХО.

вот это 

//***Функция считывания температуры c Далласов*****
void dallRead(unsigned long interval){
  static unsigned long prevTime = 0;
  if (millis() - prevTime > interval) { //Проверка заданного интервала
  static boolean flagDall = 0; //Признак операции
  prevTime = millis();
  flagDall =! flagDall; //Инверсия признака
  if (flagDall) {
    ds.reset();
    ds.write(0xCC); //Обращение ко всем датчикам
    ds.write(0x44); //Команда на конвертацию
    flagDallRead = 1; //Время возврата в секундах
  }
  else {
    byte i;
     int temp;
    for (i = 0; i < 3; i++){ //Перебор количества датчиков
     ds.reset();
     ds.select(addr[i]);
     ds.write(0xBE); //Считывание значения с датчика
     temp = (ds.read() | ds.read()<<8); //Принимаем два байта температуры
     Temp[i] = (float)temp / 16.0; 
     flagDallRead = 2; //Время возврата в секундах
     }
   }
  }
}
//--------------------------------------------------

а если так? 

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


#define LEDS_IN_SEGMENT 1         // задаём сколько у нас светодиодов в сегменте
#define DOTS_NUM 1                // задаём сколько у нас разделительных точек
#define COLOR_CHANGE 0            // смена цвета ( 0 - никогда, 1 - раз в минуту, 2 - каждые десять минут, 3 - каждый час, 4 - каждые десять часов)
#define NUM_COLORS 16             // количество цветов
#define COLOR_ORDER BGR           // по умолчанию цвет стоит зелёный при выключенных режимах
#define DATA_PIN 13               // пин ленты 
#define BRI_PIN A3                // пин фоторезистора
#define auto_bright 1             // автоматическая подстройка яркости от уровня внешнего освещения (1 - включить, 0 - выключить)
#define max_bright 250            // максимальная яркость (0 - 255)
#define min_bright 90             // минимальная яркость (0 - 255)
#define bright_constant 1000      // константа усиления от внешнего света (0 - 1023), чем МЕНЬШЕ константа, тем "резче" будет прибавляться яркость
#define coef 0.9                  // коэффициент фильтра (0.0 - 1.0), чем больше - тем медленнее меняется яркость

OneWire  ds(10); 
//byte addr[8]={0x28, 0xFF, 0x2E, 0x75, 0xB3, 0x16, 0x03, 0xC7};
int temperature = 0; // Глобальная переменная для хранения значение температуры с датчика DS18B20
long lastUpdateTime = 0; // Переменная для хранения времени последнего считывания с датчика
const int TEMP_UPDATE_TIME = 1000; // Определяем периодичность проверок

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,     // цифра 0
  0b00100001,     // цифра 1
  0b01110110,     // цифра 2
  0b01110011,     // цифра 3
  0b01101001,     // цифра 4
  0b01011011,     // цифра 5
  0b01011111,     // цифра 6
  0b00110001,     // цифра 7
  0b01111111,     // цифра 8
  0b01111011,     // цифра 9
  0b01111000,     // символ * градус 10
  0b00011110,     // символ C        11
  0b01111100,     // символ P        12
  0b01111000,     // символ % знак % из двух частей 13
  0b01000111,     // символ % знак % из двух частей 14
};
//---------------------------------------------------------------------------------------------------
bool Dot = true;
bool TempShow = true;
int last_digit = 0;
//---------------------------------------------------------------------------------------------------
long ledColor = CRGB::Aqua; // используемый цвет
long ColorTable[NUM_COLORS] = {
  CRGB::Red,
  CRGB::Orange,
  CRGB::Yellow,
  CRGB::Blue,
  CRGB::Green,
  CRGB::Purple,
  CRGB::Pink,
  CRGB::White,
  CRGB::Violet,
  CRGB::SkyBlue,
  CRGB::LightBlue,
  CRGB::Green,
  CRGB::Lime,
  CRGB::Blue,
  CRGB::Red,
  CRGB::Cyan
};
//---------------------------------------------------------------------------------------------------
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);      // установить новую яркость
    }
  }
};
//---------------------------------------------------получаем время--------------------------------------------------------------
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;
  };
};
//----------------------------------------------Функция чтения температуры----------------------------------------------------------
int detectTemperature(){
  byte data[2];
  ds.reset();
  ds.write(0xCC);
  ds.write(0x44);
  if (millis() - lastUpdateTime > TEMP_UPDATE_TIME)
  {
    lastUpdateTime = millis();
    ds.reset();
    ds.write(0xCC);
    ds.write(0xBE);
    data[0] = ds.read();
    data[1] = ds.read();
    // Формируем значение
    temperature = (data[1] << 8) + data[0];
    temperature = temperature >> 4;
  }
} 
//----------------------------------------------Функция вывода температуры----------------------------------------------------------
void TempToArray(){      // вывод температуры с DALLAS DS18B20          
  tmElements_t tm;
  RTC.read(tm); 
  if (tm.Second != 30) {        
  TempShow = false;          
    return;                    
  }
 TempShow = true;             
 int celsius = temperature >> 4; 
  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() {       //Вывод температуры с DHT11 
  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(){        //Вывод температуры с RTC3231 
  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() { 
  detectTemperature(); // Определяем температуру от датчика DS18b20
  BrightnessCheck();                  // проверяем датчик освещения
  DSTcheck();                         // проверяем режимы
  TimeAdjust();                       // проверяем время если сменилось на 1 цифру
  TimeToArray();                      // проверяем часы если сменилось на 1 цифру
  TempToArray();                      // температура
  FastLED.show();                     // задаём массив светодиодов
  if (TempShow == true) delay (2000); // время отображения температуры (3000 = 3 сек)
}

dj-toxa - плохо, пробуйте еще :)

Куча ошибок: дергаете датчик каждый проход loop(), время не запоминаете, соответвенно таймер никогда не обновляется и температура считается один раз.

Не надо пытаться "упрощать" - сделайте точно по образцу из сообщения #209.

#208? каюсь безграмотен, ща еще попробую =)

как то так что ли?

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


#define LEDS_IN_SEGMENT 1         // задаём сколько у нас светодиодов в сегменте
#define DOTS_NUM 1                // задаём сколько у нас разделительных точек
#define COLOR_CHANGE 0            // смена цвета ( 0 - никогда, 1 - раз в минуту, 2 - каждые десять минут, 3 - каждый час, 4 - каждые десять часов)
#define NUM_COLORS 16             // количество цветов
#define COLOR_ORDER BGR           // по умолчанию цвет стоит зелёный при выключенных режимах
#define DATA_PIN 13               // пин ленты 
#define BRI_PIN A3                // пин фоторезистора
#define auto_bright 1             // автоматическая подстройка яркости от уровня внешнего освещения (1 - включить, 0 - выключить)
#define max_bright 250            // максимальная яркость (0 - 255)
#define min_bright 90             // минимальная яркость (0 - 255)
#define bright_constant 1000      // константа усиления от внешнего света (0 - 1023), чем МЕНЬШЕ константа, тем "резче" будет прибавляться яркость
#define coef 0.9                  // коэффициент фильтра (0.0 - 1.0), чем больше - тем медленнее меняется яркость

OneWire  ds(10); 
byte addr[8]={0x28, 0xFF, 0x2E, 0x75, 0xB3, 0x16, 0x03, 0xC7};
float Temp;
byte flagDallRead;

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,     // цифра 0
  0b00100001,     // цифра 1
  0b01110110,     // цифра 2
  0b01110011,     // цифра 3
  0b01101001,     // цифра 4
  0b01011011,     // цифра 5
  0b01011111,     // цифра 6
  0b00110001,     // цифра 7
  0b01111111,     // цифра 8
  0b01111011,     // цифра 9
  0b01111000,     // символ * градус 10
  0b00011110,     // символ C        11
  0b01111100,     // символ P        12
  0b01111000,     // символ % знак % из двух частей 13
  0b01000111,     // символ % знак % из двух частей 14
};
//---------------------------------------------------------------------------------------------------
bool Dot = true;
bool TempShow = true;
int last_digit = 0;
//---------------------------------------------------------------------------------------------------
long ledColor = CRGB::Aqua; // используемый цвет
long ColorTable[NUM_COLORS] = {
  CRGB::Red,
  CRGB::Orange,
  CRGB::Yellow,
  CRGB::Blue,
  CRGB::Green,
  CRGB::Purple,
  CRGB::Pink,
  CRGB::White,
  CRGB::Violet,
  CRGB::SkyBlue,
  CRGB::LightBlue,
  CRGB::Green,
  CRGB::Lime,
  CRGB::Blue,
  CRGB::Red,
  CRGB::Cyan
};
//---------------------------------------------------------------------------------------------------
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);      // установить новую яркость
    }
  }
};
//---------------------------------------------------получаем время--------------------------------------------------------------
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;
  };
};
//----------------------------------------------Функция чтения температуры----------------------------------------------------------
void dallRead(unsigned long interval){
  static unsigned long prevTime = 0;
  if (millis() - prevTime > interval) { //Проверка заданного интервала
  static boolean flagDall = 0; //Признак операции
  prevTime = millis();
  flagDall =! flagDall; //Инверсия признака
  if (flagDall) {
    ds.reset();
    ds.write(0xCC); //Обращение ко всем датчикам
    ds.write(0x44); //Команда на конвертацию
    flagDallRead = 1; //Время возврата в секундах
  }
  else {
    byte i;
     int temp;
     ds.reset();
     ds.select(addr);
     ds.write(0xBE); //Считывание значения с датчика
     temp = (ds.read() | ds.read()<<8); //Принимаем два байта температуры
     Temp = (float)temp / 16.0; 
     flagDallRead = 2; //Время возврата в секундах
     }
  }
}
//----------------------------------------------Функция вывода температуры----------------------------------------------------------
void TempToArray(){      // вывод температуры с DALLAS DS18B20          
  tmElements_t tm;
  RTC.read(tm); 
  if (tm.Second != 30) {        
  TempShow = false;          
    return;                    
  }
 TempShow = true;             
 int celsius = Temp; 
  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() {       //Вывод температуры с DHT11 
  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(){        //Вывод температуры с RTC3231 
  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 (2000); // время отображения температуры (3000 = 3 сек)
}

только не понятно куда это dallRead(flagDallRead*1000); втыкать =) перед  if (TempShow == true) delay (2000); что ли? и сколько тут ставить flagDallRead = 2; //Время возврата в секундах

dallRead(....) вызывается в каждый проход loop, при входе проверяет прошедший интервал и либо возвращается в основную программу, либо отрабатывает if-else. flagDallRead задает интервалы возврата, после запуска конвертации устанавливает интервал в одну секунду, после считывания, тот который нужен Вам (до 4 минут 14сек, дальше byte переполниться). Можете заменить ее на инт или лонг и оперировать миллисекундами (не умножать на 1000).

Ваша 329 строка, она за гранью добра и зла, ее надо переделывать. ИМХО.
Изобразить какой-нибудь диспетчер экранов и из него оперировать выводом значений. Если вывод частый, то пойдет как у меня, только второе значение flagDallRead подобрать для синхронности с Вашим выводом (получится в секундах - значение в ветке else + 1). 

P/S Для Вашего тухес вывода на экран, можно сделать так: вместо flagDallRead=2; добавляете свои строки вывода, и переводите tempShow в true.  В луп, где 329 строка, делаете свой делей, flagDallRead = сколько надо, tempShow = false;. (где tempShow изменяется еще, не рылся, посмотрите, чтобы коллизий не возникло). dallRead(...) вставляем непосредственно перед 329.

 для меня тут все описанное за гранью %) и не только добра и зла, но и разума =) одно мне точно понятно, что ни чего не понятно ))

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

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

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


#define LEDS_IN_SEGMENT 1         // задаём сколько у нас светодиодов в сегменте
#define DOTS_NUM 1                // задаём сколько у нас разделительных точек
#define COLOR_CHANGE 0            // смена цвета ( 0 - никогда, 1 - раз в минуту, 2 - каждые десять минут, 3 - каждый час, 4 - каждые десять часов)
#define NUM_COLORS 16             // количество цветов
#define COLOR_ORDER BGR           // по умолчанию цвет стоит зелёный при выключенных режимах
#define DATA_PIN 13               // пин ленты 
#define BRI_PIN A3                // пин фоторезистора
#define auto_bright 1             // автоматическая подстройка яркости от уровня внешнего освещения (1 - включить, 0 - выключить)
#define max_bright 250            // максимальная яркость (0 - 255)
#define min_bright 90             // минимальная яркость (0 - 255)
#define bright_constant 1000      // константа усиления от внешнего света (0 - 1023), чем МЕНЬШЕ константа, тем "резче" будет прибавляться яркость
#define coef 0.9                  // коэффициент фильтра (0.0 - 1.0), чем больше - тем медленнее меняется яркость

OneWire  ds(10); 
byte addr[8]={0x28, 0xFF, 0x2E, 0x75, 0xB3, 0x16, 0x03, 0xC7};
float Temp;
byte flagDallRead;

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,     // цифра 0
  0b00100001,     // цифра 1
  0b01110110,     // цифра 2
  0b01110011,     // цифра 3
  0b01101001,     // цифра 4
  0b01011011,     // цифра 5
  0b01011111,     // цифра 6
  0b00110001,     // цифра 7
  0b01111111,     // цифра 8
  0b01111011,     // цифра 9
  0b01111000,     // символ * градус 10
  0b00011110,     // символ C        11
  0b01111100,     // символ P        12
  0b01111000,     // символ % знак % из двух частей 13
  0b01000111,     // символ % знак % из двух частей 14
};
//---------------------------------------------------------------------------------------------------
bool Dot = true;
bool TempShow = true;
int last_digit = 0;
//---------------------------------------------------------------------------------------------------
long ledColor = CRGB::Aqua; // используемый цвет
long ColorTable[NUM_COLORS] = {
  CRGB::Red,
  CRGB::Orange,
  CRGB::Yellow,
  CRGB::Blue,
  CRGB::Green,
  CRGB::Purple,
  CRGB::Pink,
  CRGB::White,
  CRGB::Violet,
  CRGB::SkyBlue,
  CRGB::LightBlue,
  CRGB::Green,
  CRGB::Lime,
  CRGB::Blue,
  CRGB::Red,
  CRGB::Cyan
};
//---------------------------------------------------------------------------------------------------
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);      // установить новую яркость
    }
  }
};
//---------------------------------------------------получаем время--------------------------------------------------------------
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;
  };
};
//----------------------------------------------Функция чтения температуры----------------------------------------------------------
void dallRead(unsigned long interval){
    tmElements_t tm;
  RTC.read(tm); 
  if (tm.Second != 30) {        
  TempShow = false;          
    return;                    
  }
  static unsigned long prevTime = 0;
  if (millis() - prevTime > interval) { //Проверка заданного интервала
  static boolean flagDall = 0; //Признак операции
  prevTime = millis();
  flagDall =! flagDall; //Инверсия признака
  if (flagDall) {
    ds.reset();
    ds.write(0xCC); //Обращение ко всем датчикам
    ds.write(0x44); //Команда на конвертацию
    flagDallRead = 1; //Время возврата в секундах
  }
  else {
    byte i;
     int temp;
   
     ds.reset();
     ds.select(addr);
     ds.write(0xBE); //Считывание значения с датчика
     temp = (ds.read() | ds.read()<<8); //Принимаем два байта температуры
     Temp = (float)temp / 16.0; 
      TempShow = true;             
 int celsius = Temp; 
  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(){      // вывод температуры с DALLAS DS18B20          
  tmElements_t tm;
  RTC.read(tm); 
  if (tm.Second != 30) {        
  TempShow = false;          
    return;                    
  }
 TempShow = true;             
 int celsius = Temp; 
  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() {       //Вывод температуры с DHT11 
  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(){        //Вывод температуры с RTC3231 
  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 цифру
  
  FastLED.show();                     // задаём массив светодиодов
  dallRead(flagDallRead*1000);
  if (TempShow == true)  flagDallRead = 5; // время отображения температуры 
  TempShow = false;
}

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

Сейчас уезжать надо, попозже подумаю. Где-то с условиями косячок.

Ну, что мне Вам сказать про Сахалин. Алгоритм и данные я дал правильно. Нижеприведенный код, послушно возвращается через пять и одну секунды:

byte flagDallRead;
bool TempShow = true;

//---------------------------------- -
void setup() {
  Serial.begin(9600);
}

//----------------------------------------------Функция чтения температуры----------------------------------------------------------
void dallRead(unsigned long interval) {
  //   tmElements_t tm;
  // RTC.read(tm);
  // if (tm.Second != 30) {
  // TempShow = false;
  //   return;
  //}
  static unsigned long prevTime = 0;
  if (millis() - prevTime > interval) { //Проверка заданного интервала
    static boolean flagDall = 0; //Признак операции
    prevTime = millis();
    flagDall = ! flagDall; //Инверсия признака
    if (flagDall) {
      //ds.reset();
      //ds.write(0xCC); //Обращение ко всем датчикам
      //ds.write(0x44); //Команда на конвертацию
      Serial.println ("5 sekund");
      flagDallRead = 1; //Время возврата в секундах
    }
    else {
      //byte i;
      //int temp;

      //ds.reset();
      //ds.select(addr);
      //ds.write(0xBE); //Считывание значения с датчика
      //temp = (ds.read() | ds.read()<<8); //Принимаем два байта температуры
      //Temp = (float)temp / 16.0;
      TempShow = true;
      Serial.println("1 sekunda");
      //int celsius = Temp;
      //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 loop() {
  //BrightnessCheck();                  // проверяем датчик освещения
  //DSTcheck();                         // проверяем режимы
  //TimeAdjust();                       // проверяем время если сменилось на 1 цифру
  //TimeToArray();                      // проверяем часы если сменилось на 1 цифру

  //FastLED.show();                     // задаём массив светодиодов
  dallRead(flagDallRead * 1000);
  if (TempShow == true)  flagDallRead = 5; // время отображения температуры
  TempShow = false;
}

Код из Вашего крайнего поста. Оставлена интересующая функция, из нее выкинуто тело, оставлены условия возврата и добавлена сигнализация входа. Все работает, как и задумывалось. В самом начале функции, Вы зачем то прикрутили, какой-то RTC, разбирайтесь с ним и его нужностью. Функция и условия возвратов работают. Можете проверить.

Да, и раз перешли на целочисленную, перепишите 194 строку, как int celsius = Temp + 0.5;. Так расово вернее.

P/S Здесь подумал, а я правильно Вас понял (навел на мысли комментарий в предпоследней строке), это не время отображения, это время следующего цикла конвертации-считывания. Если дисплей с динамической индикацией от МК или что то может извне затирать выведенные данные, то они могут исчезнуть, не успев появиться. Тогда такой метод не подойдет.

не знаю вроде не дурак, но понятного мало. ((( 

Давайте, чтобы не мучать Вас, Вы можете просто отображать переменную Temp, когда Вам нужно, не мешая основной программе? Если да, то с каким интервалом будете это делать?

ну должно быть так, вывожу температуру раз в минуту к примеру с 30-32 секунду, запрос к датчику за темературой делаю перед её выводом. и до следующей 30й секунды новой минуты к датчику не обращаюсь. не мешая основной программе, она то выводилась пост #200 до изменений, но были какие то затупы с кнопками то срабатывали то нет. как буд то мс занят чем то (может быть постоянным опросом датчика), а в промежутках между циклами опроса, иногда успевает отрабатать кнопки.

Тогда, dallRead() оставьте оригинальный, а за две секунды до вывода делайте flagDallRead = 0;. В ветке else приравнивайте flagDallRead = 60;.
В принципе, можно просто сделать flagDallRead = 59, но скорее всего пойдет рассинхронизация миллис и RTC, значит температура будет отставать, вплоть до целой минуты ( в вашем случае).

Попробуйте вот так: (это из #200):

//-----------------------------------------------------------------------------------------------------------
  void TempToArray(){        //Вывод температуры с RTC3231 
  tmElements_t tm;
  RTC.read(tm);
  if (tm.Second != 30) {
    TempShow = false;
    return;
  }
  TempShow = true;
  //int t = RTC.temperature();
  int celsius = Temp; //!!!!!!!!!!!!!!
  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й блок вывода первого символа
};

//В GetTime()
//после int second = Now.Second;
//добавить if(second == 28) {flagDallRead = 0;}

Естественно добавляете функцию dallRead() и вызываете ее из луп постоянно. В ветке else, flagDallRead = 60;

мое вот это 

void TempToArray(){      // вывод температуры с DALLAS DS18B20          
  tmElements_t tm;
  RTC.read(tm); 
  if (tm.Second != 30) {        
  TempShow = false;          
    return;                    
  }
 TempShow = true;             
  sensors.requestTemperatures();                                // отправляем команду для получения показаний температуры
  int celsius = sensors.getTempCByIndex(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й блок вывода первого символа
};

а то для RTC3231 оно закоментировано и работает нормально 

Тогда, dallRead() оставьте оригинальный, а за две секунды до вывода делайте flagDallRead = 0;. В ветке else приравнивайте flagDallRead = 60;.
 

тут что ли делать  flagDallRead = 0; В ветке else flagDallRead = 60;.

void dallRead(unsigned long interval){
  static unsigned long prevTime = 0;
  if (millis() - prevTime > interval) { //Проверка заданного интервала
  static boolean flagDall = 0; //Признак операции
  prevTime = millis();
  flagDall =! flagDall; //Инверсия признака
  if (flagDall) {
    ds.reset();
    ds.write(0xCC); //Обращение ко всем датчикам
    ds.write(0x44); //Команда на конвертацию
    flagDallRead = 1; //Время возврата в секундах
  }
  else {
    byte i;
     int temp;
     ds.reset();
     ds.select(addr);
     ds.write(0xBE); //Считывание значения с датчика
     temp = (ds.read() | ds.read()<<8); //Принимаем два байта температуры
     Temp = (float)temp / 16.0; 
     flagDallRead = 2; //Время возврата в секундах
     }
  }
}

все чердак уже съехал я в люлю

В первой функции, 9-ю строку убираете, в 10-й int celsius = Temp;
Во второй функции 21-я строка flagDallRead = 60;
flagDallRead = 0;, добавляется в GetTime()  - Функция постом выше, сделайте как в 22-24строках написал.  
В loop вставляете dallRead(flagDallRead*1000);

Вроде должно заработать.

Подскажите, кто сталкивался. При переключении цветов, наблюдается подмаргивание не активных светодиодов белым не большой интенсивности. Контроллер INK1003 (один на сегмент из 3-х led). По идее это аналог 2811, по даташиту немного отличаются интервалы напряжений, лента промаркирована на 12в(сигнальная линия одна). Лента б/ушная, но их несколько и одинаково себя ведут на примерах от библиотек, как адафруитовской, так и fastled. 

Подскажите,пожалуйста. Что нужно исправить в скетче, чтобы происходило отображение температуры с микросхемы DS3231? 

В схеме используются 30 светодиодов WS2812.

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

#include <iarduino_RTC.h>
iarduino_RTC   _RTC1(RTC_DS3231);

#define NUM_LEDS 30 // 
#define LED_TYPE WS2812
#define COLOR_ORDER GRB // Define color order for your strip
#define BRIGHTNESS 10
#define LED_PIN 6 // Data pin for led comunication

CRGB leds[NUM_LEDS]; // Define LEDs strip

byte digits[12][7] = {{0,1,1,1,1,1,1},  // Digit 0
                       {0,1,0,0,0,0,1},   // Digit 1
                       {1,1,1,0,1,1,0},   // Digit 2
                       {1,1,1,0,0,1,1},   // Digit 3
                       {1,1,0,1,0,0,1},   // Digit 4
                       {1,0,1,1,0,1,1},   // Digit 5
                       {1,0,1,1,1,1,1},   // Digit 6
                       {0,1,1,0,0,0,1},   // Digit 7
                       {1,1,1,1,1,1,1},   // Digit 8
                       {1,1,1,1,0,1,1},   // Digit 9 | 2D Array for numbers on 7 segment
                       {1,1,1,1,0,0,0},   // Digit *0
                       {0,0,1,1,1,1,0},};  // Digit C

byte firstdigit[2][7] = {
{
0,0,0,0,0,0,0 }
//0,0,0,0,0,0,0,0,0,0 }
, // Digit 0 first number

{
1,1,1,1,1,1,1 }
//1,1,1,1,1,1,1,1,1,1 }
}; // 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::DarkOrange; // Color used (in hex)
//long ledColor = CRGB::MediumVioletRed;
long ColorTable[17] = {
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::White,
CRGB::Orchid};
void setup(){

Serial.begin(9600);

Wire.begin();
FastLED.addLeds<WS2812B, LED_PIN, RGB>(leds, NUM_LEDS);
FastLED.addLeds<LED_TYPE, LED_PIN, COLOR_ORDER>(leds, NUM_LEDS).setCorrection( TypicalLEDStrip );
FastLED.setBrightness( BRIGHTNESS );
pinMode(2, INPUT_PULLUP); // Define DST adjust button pin
pinMode(4, INPUT_PULLUP); // Define Minutes adjust button pin
pinMode(5, INPUT_PULLUP); // Define Hours adjust button pin

}

// Check Light sensor and set brightness accordingly
void BrightnessCheck(){
const byte sensorPin = 3; // light sensor pin
const byte brightnessLow = 20; // Low brightness value
const byte brightnessHigh = 50; // High brightness value
int sensorValue = digitalRead(sensorPin); // Read sensor
if (sensorValue == 0) {
Serial.println("Brightness Low");
LEDS.setBrightness(brightnessLow);
}

else {
Serial.println("Brightness High");
LEDS.setBrightness(brightnessHigh);
}

};

// 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;
if (second % 2==0) {
Dot = false;
}
else {
Dot = true;
};
return (hour*100+minutes);
};

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 = 30; //116

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

if (Dot){
leds[15]=ledColor;
leds[14]=ledColor;

}

else {

leds[15]=0x000000;
leds[14]=0x000000;
//leds[54]=0x000000;
//leds[55]=0x000000;
//leds[56]=0x000000;
//leds[48]=0x000000;

};

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

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

if (i==1){

cursor =23; //82

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

for(int k=0; k<=6;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 =16;

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

for(int k=0; k<=6;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 =7;

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

for(int k=0; k<=6;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<=6;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;
};
};
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);
}
}
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);
}
}
void loop() // Main loop
{
BrightnessCheck(); // Check brightness
DSTcheck(); // Check DST
TimeAdjust(); // Check to se if time is geting modified*/
TimeToArray(); // Get leds array with required configuration
FastLED.show(); // Display leds array

float t = RTC.temperature();
float celsius = t / 4.0;
Serial.println();
Serial.print("Temp is : ");
Serial.print(celsius);
Serial.println();

}

в теме все описано. А код у вас старый. скорее всего кривой - смотрите в теме исправленную версию

добавлю - чтение температуры с RTC. есть, например, в коде сообщения #58

Попробую переделать скетч из сообщения #58 под 30 светодиодов. А там в нем чтение температуры с DS3231 работает?

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

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

Про температуру не знаю - не интересовался.

У меня вот этот работает. С инета спер у кого то, спасибо добрым людям. 

[code]
/*
Подключение к 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 1        // Смена цвета ( 0 - никогда, 1 - раз в минуту, 2 - каждые десять минут, 3 - каждый час, 4 - каждые десять часов)
#define NUM_COLORS 16         // Количество цветов
#define COLOR_ORDER BGR       // По умолчанию цвет стоит зелёный при выключенных режимах
#define DATA_PIN 6           // Пин ленты 
#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;
//---------------------------------------------------------------------------------------------------
#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 (5000); // время отображения температуры (3000 = 3 сек)
}
[/code]

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

Дико извиняюсь. Самому противно. Первый раз пишу. Где почитать как  правильно выкладывать?

а код здесь качал https://community.alexgyver.ru/attachments/new_clock_temp_reloaded-rar.3122/

Вот это прочитайте - хотя бы первые 2 сообщения

http://arduino.ru/forum/obshchii/pesochnitsa-dlya-vsekh-novichkov

Спасибо.

Тоже жду когда к тебе датчик придет. А то у меня мозгов не хватает к твоему скетчу BME280 прикрутить.

С новым скетчем получилось выводить температуру на экран. Все заработало, спасибо!

У меня имеется вопрос:

Как подключить правильно датчик освещенности к аналоговому входу ардуины?

Так правильно?

где ты -5Вольт возьмешь?  Мошт, это GND?

Да, правильно, земля. А как подключать то?

Ну может быть как то так

Спасибо попробую. Еще заметил в скетче выключение незначащего нуля в часах. У меня что-то неработает этот пункт.

//  Получаем время в одном номере, если часы будет только одна цифра то будет отображаться 155  вместо 0155
int GetTime()
{
  tmElements_t Now;
  RTC.read(Now);
  //time_t Now = RTC.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);
};

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

В последнем выложенным мной скетче все работает. Посмотрите как там сделано

Или перевернуть землю и +5 в делителе или местами резистор и фоторезистор поменять, что вобщем то тоже самое. 

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

Сейчас поищу, спасибо.

Ноль в значении часов все равно не гаснет. Покажите, пожалуйста, эту строку в скетче, которая отвечает за эту функцию.

Заинтересовал второй вариант изменения яркости. У меня он тоже почему-то не работает. Хотя в мониторе порта видно изменение значений фоторезистора.

Что означает "0" в этой строке?

new_bright = map(analogRead(BRI_PIN), 0, bright_constant, min_bright, max_bright);   // считать показания с фоторезистора, перевести диапазон

Так наоборот работает. У меня резистор 4,7кОм на плюс припаян. 

По всей видимости мое фото сопротивление работает наоборот.