[kopcor07]

Witam,

mam pomysł na stworzenie zegarka do mojego biurka, który będzie wyświetlał czas, datę, temperaturę, wilgotność, ciśnienie atmosferyczne, poziom CO2 w pokoju. Jestem na etapie wyświetlania czasu, daty i pomiaru temperatury. 
Część odpowiedzialną za czas i datę oparłem o moduł DS3231. Mam problem z przeskakującymi sekundami ( niekiedy co 2 sekundy). Czytałem o przeskakiwaniu sekund w google ale nie rozumiem o co tam chodzi. Nie wiem gdzie robię błąd.
Oto kod:

Kod:

#include <TimerOne.h>
#include <Wire.h>
#include <DS3231.h>
#include <LiquidCrystal_I2C.h>
#include <OneWire.h>
#include <DallasTemperature.h>

//////////////////Do czujnika/////////////////////////////
int temperatura;
const byte oneWireBus = 11;                                  // Tutaj jest określony port magistrali 1-wire.
OneWire oneWire(oneWireBus);                                 // Tutaj definiuje się port magistrali dla biblioteki.
DallasTemperature sensors(&oneWire);                         // Teraz można już przekazać bibliotece obsługi termometru namiary na bibliotekę obsługi magistrali.
///////////////////////////////////////////////


//////////////////Do wyświetlacza/////////////////////////////
LiquidCrystal_I2C lcd(0x27, 20, 4);
////////////////////////////////////////////////////////


//////////////////Do Zegara/////////////////////////////
DS3231 clock;
RTCDateTime dt;
///////////////////////////////////////////////
void setup()
{
  //////////////////Do czyjnika/////////////////////////////
  sensors.begin();
  ///////////////////////////////////////////////
  //////////////////Do wyświetlacza/////////////////////////////
  lcd.begin();
  lcd.backlight();
  ///////////////////////////////////////////////
  //////////////////Do zegara/////////////////////////////
  clock.begin();
  clock.setDateTime(__DATE__, __TIME__);
  //////////////////Do przerwania/////////////////////////////
  Timer1.initialize(500000);
  Timer1.attachInterrupt(Temperatura);
  //////////////////////////////////////////////

}

void loop()
{
  //////////////////////////////////Zegarek//////////////////////////////////////
  dt = clock.getDateTime();
  lcd.setCursor(0, 0);
  if (dt.hour < 10 )
  {
    lcd.print(F(" "));
  }
  lcd.print(dt.hour);
  lcd.print(F(":"));
  if (dt.minute < 10 )
  {
    lcd.print(F("0"));
  }
  lcd.print(dt.minute);
  lcd.print(F(":"));
  if (dt.second < 10 )
  {
    lcd.print(F("0"));
  }
  lcd.print(dt.second);
  ////////////////////////////////////////////////////////////////////////////////
  ////////////////////////////Data do zegarka///////////////////////////////
  lcd.setCursor(0, 1);
  lcd.print(dt.day);
  lcd.print(F("/"));
  lcd.print(dt.month);
  lcd.print(F("/"));
  lcd.print(dt.year);
  ///////////////////////////////////////////////////////////////////////////
  ///////////////////////////////////////////Do Temperatury//////////////////////////////////////////////////////
  lcd.setCursor(0, 2);
  lcd.print(F("Temp.:"));
  lcd.setCursor(0, 3);

  if (temperatura < 0)                                       // Gdy wartość jest ujemna...
  {
    temperatura--;                                           // odejmij jeden ze względu na zaokrąglenia liczb ujemnych.
    lcd.print(F("-"));                                       // rysuj znak minusa.
  }
  else
  {
    lcd.print(F(" "));                                       // W przeciwnym razie rysuj spację.
  }

  temperatura = abs(temperatura);                            // Wyciągnij wartość bezwzględną.

  if (temperatura < 100)                                     // Jeśli temperatura będzie większa od 9 bądź mniejsza od -9 stopni...
  {
    lcd.print(F(" "));                                       // rysuj dodatkową spację.
  }


  lcd.print(float(temperatura) / 10, 1);
  lcd.print((char)223);
  lcd.print(F("C"));
  ///////////////////////////////////////////////////////////////////////////////////////
  delay(1000);
}


void Temperatura()
{
  sensors.requestTemperatures();                             // Wyślij rozkaz zmierzenia temperatury.
  temperatura = 10 * (sensors.getTempCByIndex(0) + 0.05);    // Przekształć wartość odczytaną w całkowitą (dokładność: jedno miejsce po przecinku)
  return temperatura;
}

[kaczakat]

Błąd leży w używaniu delay, przeszukaj moje posty, znajdź funkcję czas, albo w inny sposób naucz się używać millis, jest kurs Arduino za darmo do znalezienia w Internecie, np. na Forbot.
Używasz delay 1000, każda funkcja/czynność w loop zajmuje czas, jeśli jakiś czujnik czytasz po pauzie 1000ms, a jego odczyt zajmuje 800ms, to nic innego w programie nie dzieje się w sumie przez 1800ms.
Np. DS18b20, jak wyłączysz czekanie na pomiar to zrobi zlecenie pomiaru w 15ms, tyle typowo trwa wysłanie komunikatu ONE WIRE ( wieczność w świecie uC, ale i tak << niż delay 1000) jak czekasz to program stoi w tym miejscu ponad 750ms - herezja. Ale jak wyłączysz czekanie na pomiar to trzeba to zrobić w taki sposób, żeby nie pytać o temperaturę przez minimum kolejne 750ms. Trzeba umieć mierzyć sobie czas w programie między zdarzeniami i poznać używane biblioteki, jakie mają opcje.
Można najprościej wywołać funkcje do DS co 1s, ale odwrotnie, odczytać temperaturę i zlecić pomiar, jak zliczysz sobie że już minęła sekunda od ostatniego zlecenia pomiaru to znowu odczytujesz temperaturę i zlecasz kolejny pomiar.
Nie ma jednak żadnego sensu robić coś takiego z temperaturą w pokoju, wystarczy raz na 15s, w czternastej sekundzie minuty zlecasz pomiar, w 15 robisz odczyt. Masz w każdej 15 sekund 13 takich, gdzie komunikacja ONE WIRE zajmuje 0ms i 2 takie, gdzie ONE WIRE zajmuje po 15ms. Powtarzasz to co 15s, w inne sekundy można upchnąć inne funkcje, w każdej odświeżyć licznik sekund na LCD.
Jak nie nauczysz się tak zarządzać zadaniami to będzie jak ruska Armia w natarciu, wszyscy lecą na raz z okrzykiem URAAAAAAAAAA potykając się o siebie.
Każda komunikacja I2C to też parę lub nawet kilkanaście ms.
W ten sposób należy przeanalizować każdy używany komponent, np. jakbyś używał czujnika wilgotności, którego można odczytywać co 2s, to nie stoisz czekając 2s. W uC jak możesz coś zrobić w us i co sekundy to będzie działać OK, przy kilku ms i co 1s też jeszcze OK, ale już można zauważyć czkawkę jak tego jest dużo, jak robisz program, gdzie wrzucasz rzeczy w setkach/tysiącach ms i chcesz to robić co 1s to już jest absurd. Czasami trzeba coś robić co kilkaset us i trwa to kilka us, a sterować trzeba setkami ns, wtedy już jest większa gimnastyka.
Liznąłeś temat Arduino i bierzesz się za rozbudowany projekt, a na to trochę za wcześnie.

[kopcor07]

Dziękuję za odpowiedź. Znalazłem post o wielozadaniowości arduino  na Fotbot. Opisano tam bibliotekę Timers.h.
Zastosowałem ją, układ niby działa. Nie występuje już przeskakiwanie sekund. Może ktoś mi to sprawdzić ?
W kodzie występują ,,zadania" . Dwoje z tych zadań już wykorzystałem. ,,Zadanie1" obsługuje czas i datę, ,, Zadanie2" temperaturę. Rozumiem, że kolejny pomiar np: wilgotności może być umieszczony w kolejnym zadaniu. Mogę sobie tak ,, podpinać" do kolejnych zadań czujniki ?? Będzie mi to działać ? Czy jednak muszę na coś zwrócić uwagę ?

Oto kod :

Kod:

#include <Timers.h>
#include <TimerOne.h>
#include <Wire.h>
#include <DS3231.h>
#include <LiquidCrystal_I2C.h>
#include <OneWire.h>
#include <DallasTemperature.h>


int temperatura;
const byte oneWireBus = 11;                                  // Tutaj jest określony port magistrali 1-wire.
OneWire oneWire(oneWireBus);                                 // Tutaj definiuje się port magistrali dla biblioteki.
DallasTemperature sensors(&oneWire);                         // Teraz można już przekazać bibliotece obsługi termometru namiary na bibliotekę obsługi magistrali.
///////////////////////////////////////////////


//////////////////Do wyświetlacza/////////////////////////////
LiquidCrystal_I2C lcd(0x27, 20, 4);
////////////////////////////////////////////////////////


//////////////////Do Zegara/////////////////////////////
DS3231 clock;
RTCDateTime dt;
///////////////////////////////////////////////



Timers <2> akcja; // na poczatek 8 niezależnych wątków (procesów, zadań, procedur, akcji itp.)
int x = 1, y = 2; // takie zmienne pomocnicze, dla testów;

void setup()
{

  //////////////////Do czyjnika/////////////////////////////
  sensors.begin();
  ///////////////////////////////////////////////
  //////////////////Do wyświetlacza/////////////////////////////
  lcd.begin();
  lcd.backlight();
  ///////////////////////////////////////////////
  //////////////////Do zegara/////////////////////////////
  clock.begin();
  clock.setDateTime(__DATE__, __TIME__);



  // Teraz najważniejsze :-)
  akcja.attach(0, 1000, zadanie1); // Wątek 1: wcześniej zdefiniowana funkcja o nazwie zadanie1, wywoływana co ok  1 sek.
  akcja.attach(1, 2000, zadanie2);    // anlogicznie dla zadanie2 , ale tutaj na razie nie robimy nic, bo interwał =0;.

}
void loop()
{
  akcja.process(); // inicjalizacja lub aktualizacja wszystkich procedur(wątków, zdarzeń itp.)
  if (x == 0) {
    akcja.updateInterval(0, 1000); // odpalamy akcje dla zadania 2, co 300 ms.
  }
  if (x == 2) {
    akcja.updateInterval(1, 500); // zatrzymujemy zadanie 5
  }
}

// --- poniżej przykładowe definicje zadań: ------
void zadanie1()
{

  //////////////////////////////////Zegarek//////////////////////////////////////
  dt = clock.getDateTime();
  lcd.setCursor(0, 0);
  if (dt.hour < 10 )
  {
    lcd.print(F(" "));
  }
  lcd.print(dt.hour);
  lcd.print(F(":"));
  if (dt.minute < 10 )
  {
    lcd.print(F("0"));
  }
  lcd.print(dt.minute);
  lcd.print(F(":"));
  if (dt.second < 10 )
  {
    lcd.print(F("0"));
  }
  lcd.print(dt.second);
  ////////////////////////////////////////////////////////////////////////////////
  ////////////////////////////Data do zegarka///////////////////////////////
  lcd.setCursor(0, 1);
  lcd.print(dt.day);
  lcd.print(F("/"));
  lcd.print(dt.month);
  lcd.print(F("/"));
  lcd.print(dt.year);

}

void zadanie2()
{

  sensors.requestTemperatures();                             // Wyślij rozkaz zmierzenia temperatury.
  temperatura = 10 * (sensors.getTempCByIndex(0) + 0.05);    // Przekształć wartość odczytaną w całkowitą (dokładność: jedno miejsce po przecinku)
  if (temperatura < 0)                                       // Gdy wartość jest ujemna...
  {
    temperatura--;                                           // odejmij jeden ze względu na zaokrąglenia liczb ujemnych.
    lcd.print(F("-"));                                       // rysuj znak minusa.
  }
  else
  {
    lcd.print(F(" "));                                       // W przeciwnym razie rysuj spację.
  }

  temperatura = abs(temperatura);                            // Wyciągnij wartość bezwzględną.

  if (temperatura < 100)                                     // Jeśli temperatura będzie większa od 9 bądź mniejsza od -9 stopni...
  {
    lcd.print(F(" "));                                       // rysuj dodatkową spację.
  }
  lcd.setCursor(0, 2);
  lcd.print(F("Temp.:"));
  lcd.setCursor(0, 3);
  lcd.print(float(temperatura) / 10, 1);
  lcd.print((char)223);
  lcd.print(F("C"));

}

// ------------------------------------------------

[oscarX]

Możesz użyć czujników kompleksowych np. łatwo dostępny BME280 od razu mierzy temperaturę, wiglotność i ciśnienie. Jest na I2C.

Dlaczego zawsze w setup ustawiasz zegarek? __DATE__ i __TIME__ to symbole oznaczające date i czas kompilacji kodu - jeśli działasz tak, że w IDE dajesz od razu kompilacje, wgranie i uruchomienie to będzie w miarę OK, najwyżej kilka sekund opóźnienia, ale jak wyresetujesz/uruchomisz urządzenie jeszcze raz, zegarek znowu wystartuje od tego samego czasu. Układ zegarka zwykle ma bateryjkę, raz ustawiony zegarek powinien cały czas trzymać aktualny czas, po to on jest. Nie ustawia go się normalnie w programie, jedynie na życzenie użytkownika, gdy się rozjedzie (każdy zegarek z czasem tak robi) trzeba go poprawić - najprościej byłoby przewidzieć np. opcje wyrównania do najbliższej pełnej minuty. No i po wymianie baterii - każda w końcu się kończy - trzeba wpisać pełny czas.
W komputerach zwykle zegarek odczytuje się raz, na starcie, potem odliczaniem czasu zajmuje się program, ale w arduino można czytać częściej. Tylko coś słyszałem, że któryś układ zegarkowy jakoś się spóźnia przy częstym odczycie, ale nie pamiętam szczegółów.

[kopcor07]

Znalazłem przykład obsługujący DS3231 na tej stronie:
https://www.jarzebski.pl/arduino/kompone...s3231.html
Tam w przykładzie jest __DATE__ i __TIME__. Bezmyślnie to skopiowałem byle by kod działał.
W przyszłości będę chciał dodać możliwość ustawiania czasu z przycisku. Mam wsadzoną baterię do DS3231 ale po odłączeniu zasilania gubi ustawiony czas. Nie wiem czemu. To jest zwykła CR2032. Czytałem, że musi chyba być LIR2032

[kaczakat]

Trzecie zadanie dodajesz analogicznie, podajesz dla niego funkcję do wywołania i ustalony interwał.
Dalej się będzie rozjeżdżać, nic nie zrobiłeś z tym ONE WIRE.
Z ONE WIRE możesz ewentualnie zrobić tak z tym timerem, że na zmianę raz zlecasz pomiar, przy następnym wywołaniu odczytujesz, odczyty będą efektywnie co 2s, ale musisz użyć funkcji waitforconversion =0 by program nie czekał na odczyt. Do zliczania może być użyta zmienna globalna lub lokalna zmienna static w funkcji.
Taka zmienna static zapamiętuje swoją wartość do kolejnych wywołań funkcji.

[kopcor07]

Coś takiego napisałem

Kod:

#include <Timers.h>
#include <TimerOne.h>
#include <Wire.h>
#include <DS3231.h>
#include <LiquidCrystal_I2C.h>
#include <OneWire.h>
#include <DallasTemperature.h>


int temperatura;
const byte oneWireBus = 11;                                  // Tutaj jest określony port magistrali 1-wire.
OneWire oneWire(oneWireBus);                                 // Tutaj definiuje się port magistrali dla biblioteki.
DallasTemperature sensors(&oneWire);                         // Teraz można już przekazać bibliotece obsługi termometru namiary na bibliotekę obsługi magistrali.
///////////////////////////////////////////////


//////////////////Do wyświetlacza/////////////////////////////
LiquidCrystal_I2C lcd(0x27, 20, 4);
////////////////////////////////////////////////////////


//////////////////Do Zegara/////////////////////////////
DS3231 clock;
RTCDateTime dt;
///////////////////////////////////////////////



Timers <3> akcja; // na poczatek 8 niezależnych wątków (procesów, zadań, procedur, akcji itp.)
int x = 3, y = 2; // takie zmienne pomocnicze, dla testów;

void setup()
{

  //////////////////Do czyjnika/////////////////////////////

  sensors.begin();

  ///////////////////////////////////////////////
  //////////////////Do wyświetlacza/////////////////////////////
  lcd.begin();
  lcd.backlight();
  ///////////////////////////////////////////////
  //////////////////Do zegara/////////////////////////////
  clock.begin();
  clock.setDateTime(__DATE__, __TIME__);

  // zadanie np. 0 co 1 sek
  akcja.attach(0, 1000, zadanie1);
  akcja.attach(1, 2000, zadanie2);
  akcja.attach(2, 750, zadanie3);

}
void loop()
{
  akcja.process(); // inicjalizacja lub aktualizacja wszystkich procedur(wątków, zdarzeń itp.)
  if (x == 0) {
    akcja.updateInterval(0, 1000);
  }
  if (x == 1) {
    akcja.updateInterval(1, 2000);
  }
  if (x == 2) {
    akcja.updateInterval(2, 750);
  }
}
// --- poniżej przykładowe definicje zadań: ------
void zadanie1()
{

  //////////////////////////////////Zegarek//////////////////////////////////////
  dt = clock.getDateTime();
  lcd.setCursor(0, 0);
  if (dt.hour < 10 )
  {
    lcd.print(F(" "));
  }
  lcd.print(dt.hour);
  lcd.print(F(":"));
  if (dt.minute < 10 )
  {
    lcd.print(F("0"));
  }
  lcd.print(dt.minute);
  lcd.print(F(":"));
  if (dt.second < 10 )
  {
    lcd.print(F("0"));
  }
  lcd.print(dt.second);
  ////////////////////////////////////////////////////////////////////////////////
  ////////////////////////////Data do zegarka///////////////////////////////
  lcd.setCursor(0, 1);
  lcd.print(dt.day);
  lcd.print(F("/"));
  lcd.print(dt.month);
  lcd.print(F("/"));
  lcd.print(dt.year);

}

void zadanie2()
{
  temperatura = 10 * (sensors.getTempCByIndex(0) + 0.05);
 
  if (temperatura < 0)                                       // Gdy wartość jest ujemna...
  {
    temperatura--;                                           // odejmij jeden ze względu na zaokrąglenia liczb ujemnych.
    lcd.print(F("-"));                                       // rysuj znak minusa.
  }
  else
  {
    lcd.print(F(" "));                                       // W przeciwnym razie rysuj spację.
  }

  temperatura = abs(temperatura);                            // Wyciągnij wartość bezwzględną.

  if (temperatura < 100)                                     // Jeśli temperatura będzie większa od 9 bądź mniejsza od -9 stopni...
  {
    lcd.print(F(" "));                                       // rysuj dodatkową spację.
  }
  lcd.setCursor(0, 2);
  lcd.print(F("Temp.:"));
  lcd.setCursor(0, 3);
  lcd.print(float(temperatura) / 10, 1);
  lcd.print((char)223);
  lcd.print(F("C"));

}

void zadanie3()
{
  sensors.setWaitForConversion(false);
  sensors.requestTemperatures();
  sensors.setWaitForConversion(true);

}

// ------------------------------------------------

[Irvin]

Za często piszesz posty, między publikacjami powinna być przerwa na doczytanie i przetestowanie nowych materiałów.
Idea jest taka, w setup mierzysz temperaturę DS by jakaś była zmierzona choć raz, to trwa te 750ms, po czym wyłączasz czekanie na konwersje, wchodzisz w loop i tu co 1s, czy co 10s, wywołujesz funkcję, w której odczytujesz temperaturę i zlecasz pomiar kolejnej. A jeszcze lepiej raz czytasz, raz zlecasz.
Za każdym razem wywołując funkcję odczytujesz poprzednio zleconą temperaturę. Ma to sens bardziej dla interwału 1s niż 10, bo przy 10 odczytasz temperaturę sprzed 10s.
Po co włączasz ponownie czekanie na konwersję i czemu nie czytasz temperatury w tym samym zadaniu? Zadania nie są tu niestety w żaden sposób synchronizowane, jak masz zadanie 2 to ono będzie wywoływane co 2s, ale nie wiadomo jaki okres czasu upływa między zadaniem 2 i 3. Możesz sobie wymyślić sposób by podzielić sekundę na 1000 części i każdą z tych części jakoś wykorzystać, ale ta biblioteka tego nie ogarnia.
Obsługa LCD też jest pokaleczona, za każdym razem jak wywołujesz jakąś funkcję lcd. to ona gada z LCD po i2c, to trwa milisekundy, zrób sobie bufor/tablicę char na 16 znaków czy jaki masz tam LCD, wrzuć do niej wybrane literki, poustawiaj jak chcesz i raz wyślij cały napis na całą linię LCD. Operacje w pamięci na tablicy trwają mikrosekundy.

[kopcor07]

Witam,

napisałem coś takiego

Kod:

#include <Timers.h>
#include <TimerOne.h>
#include <Wire.h>
#include <DS3231.h>
#include <LiquidCrystal_I2C.h>
#include <OneWire.h>
#include <DallasTemperature.h>


int temperatura;
const byte oneWireBus = 11;                                  // Tutaj jest określony port magistrali 1-wire.
OneWire oneWire(oneWireBus);                                 // Tutaj definiuje się port magistrali dla biblioteki.
DallasTemperature sensors(&oneWire);                         // Teraz można już przekazać bibliotece obsługi termometru namiary na bibliotekę obsługi magistrali.
///////////////////////////////////////////////


//////////////////Do wyświetlacza/////////////////////////////
LiquidCrystal_I2C lcd(0x27, 20, 4);
////////////////////////////////////////////////////////


//////////////////Do Zegara/////////////////////////////
DS3231 clock;
RTCDateTime dt;
///////////////////////////////////////////////



Timers <3> akcja; // na poczatek 8 niezależnych wątków (procesów, zadań, procedur, akcji itp.)
int x = 3, y = 2; // takie zmienne pomocnicze, dla testów;

void setup()
{

  //////////////////Do czyjnika/////////////////////////////
  sensors.requestTemperatures();
  sensors.setWaitForConversion(false);

  sensors.begin();

  ///////////////////////////////////////////////
  //////////////////Do wyświetlacza/////////////////////////////
  lcd.begin();
  lcd.backlight();
  ///////////////////////////////////////////////
  //////////////////Do zegara/////////////////////////////
  clock.begin();
  clock.setDateTime(__DATE__, __TIME__);

  // zadanie np. 0 co 1 sek
  akcja.attach(0, 1000, zadanie1);
  akcja.attach(1, 1000, zadanie2);
  akcja.attach(2, 750, zadanie3);

}
void loop()
{
  akcja.process(); // inicjalizacja lub aktualizacja wszystkich procedur(wątków, zdarzeń itp.)
  if (x == 0) {
    akcja.updateInterval(0, 1000);
  }
  if (x == 1) {
    akcja.updateInterval(1, 1000);
  }
  if (x == 2) {
    akcja.updateInterval(2, 750);
  }
}
// --- poniżej przykładowe definicje zadań: ------
void zadanie1()
{

  //////////////////////////////////Zegarek//////////////////////////////////////
  dt = clock.getDateTime();
  lcd.setCursor(0, 0);
  if (dt.hour < 10 )
  {
    lcd.print(F(" "));
  }
  lcd.print(dt.hour);
  lcd.print(F(":"));
  if (dt.minute < 10 )
  {
    lcd.print(F("0"));
  }
  lcd.print(dt.minute);
  lcd.print(F(":"));
  if (dt.second < 10 )
  {
    lcd.print(F("0"));
  }
  lcd.print(dt.second);
  ////////////////////////////////////////////////////////////////////////////////
  ////////////////////////////Data do zegarka///////////////////////////////
  lcd.setCursor(0, 1);
  lcd.print(dt.day);
  lcd.print(F("/"));
  lcd.print(dt.month);
  lcd.print(F("/"));
  lcd.print(dt.year);

}

void zadanie2()
{
  sensors.setWaitForConversion(true);
  sensors.requestTemperatures();
 
  temperatura = 10 * (sensors.getTempCByIndex(0) + 0.05);

  if (temperatura < 0)                                       // Gdy wartość jest ujemna...
  {
    temperatura--;                                           // odejmij jeden ze względu na zaokrąglenia liczb ujemnych.
    lcd.print(F("-"));                                       // rysuj znak minusa.
  }
  else
  {
    lcd.print(F(" "));                                       // W przeciwnym razie rysuj spację.
  }

  temperatura = abs(temperatura);                            // Wyciągnij wartość bezwzględną.

  if (temperatura < 100)                                     // Jeśli temperatura będzie większa od 9 bądź mniejsza od -9 stopni...
  {
    lcd.print(F(" "));                                       // rysuj dodatkową spację.
  }
  lcd.setCursor(0, 2);
  lcd.print(F("Temp.:"));
  lcd.setCursor(0, 3);
  lcd.print(float(temperatura) / 10, 1);
  lcd.print((char)223);
  lcd.print(F("C"));

  sensors.setWaitForConversion(false);

}

void zadanie3()
{
 

}

// ------------------------------------------------