Sterownik aabratek LM/VM- arduino

[rastro]

To się tak musiało skończyć, może lepiej wcześniej niż później... bo to nie sztuka wyłożyć jakieś tam fundusze i dojść do wniosku że i tak nic z tego nie wyjdzie.

Albo może jest inaczej... developer w trakcie rehabilitacji, a Arduino + moduły płyną od ping-pongów

[crobe]

Oby bo zapowiadało się ciekawie

[rastro]

Zawsze możemy spróbować coś w temacie zrobić, ale przeważnie w takich hobbystycznych projektach jest problem z zasobami, szczególnie brakuje czasu. Z Harare też jest trochę tak że wymaga to też pewnych nakładów finansowych.

Niestety ja nie potrafię pomóc w zakresie Arduino w tym sensie że nie mam tego w swoich zasobach i raczej nie będę miał. Bardziej interesują mnie rozwiązania oparte na ARMach. W Arduino mogę popatrzeć na kod i wyłapać kwiatki typu opóźnienia itp. jak w tym linkowanym wcześniej kodzie.

[crobe]

Ja muszę wykombinować jak zapisać adresy DS do EPROM. Resztę chyba bym dał rade

[rastro]

Nigdy nie miałem potrzeby korzystania z EEPROM w moim krótkim epizodzie z AVR'ami, ale to wydaje się proste, do pisania i czytania z eepromu są odpowiednie procedury z biblioteki dołączonej do kompilatora eeprom_read_block i eeprom_write_block. No i trzeba zadeklarować dwie zmienne jedną w ram drugą z eeprom i pewnie gdzieś na początku zrobić odczyt i zapis przy ew. zmianie.

W Arduino pewnie to jest jakoś opakowane w jakieś ichnie api więc przynajmniej teoretycznie powinno być łatwiej.

[Rafcio321]

Ja muszę wykombinować jak zapisać adresy DS do EPROM. Resztę chyba bym dał rade

Witam, spróbuj tak:
#Include <EEPROM.h>
#define termometr_1 0
#define termometr_2 1


Masz już dołączoną bibliotekę i nazwane adresy w pamięci eeprom

EEPROM.write(termometr_1, zmienna przechowująca adres DS)

Właśnie zapisałeś zawartość zmiennej przechowującej adres DS do pamięci EEPROM pod adresem 0
Pozdro

Pozdrawiam Rafał

[rastro]

blee... jednak wolał bym coś takiego:

Kod: Zaznacz cały

typedef struct {
	uint8_t[8] ds_head,
	uint8_t[8] ds_keg,
	uint8_t[8] ds_process
} DS_Config;

DS_Config EEMEM ee_ds_config;
DS_Config ds_config;

gdzieś na początki programu:

Kod: Zaznacz cały

eeprom_read_block(&ee_ds_config, &ds_config, sizeof(ds_config));

Natomiast w razie potrzeby zapisania nowej konfiguracji

Kod: Zaznacz cały

eeprom_write_block(&ds_config, &ee_ds_config, sizeof(ds_config));

bo po jaki grzyb pamiętać że pod adresem 0 to jest termometr z głowicy a pod jakimś innym z kega. Niech się o to martwi kompilator. Jeżeli jednak bardzo będziesz chciał upierać się przy libach z arduino to raczej proponuję zainteresować się EEPROM.put() i EEPROM.get() zamiast EEPROM.write() i EEPROM.read()

Kod: Zaznacz cały

EEPROM.put(eeAddress, ds_config);

Cociaż nadal nie podoba mi się to eeAdress, bo wszystko jest fajnie jak piszemy jedną strukturę do eeprom, jak mamy tego więcej to znowu pojawią się magiczne cyferki. Jak mamy program co ma w całości góra 1000 linii kodu i kilka takich numerków to jeszcze to jest do ogarnięcia, ale jak kod zaczyna się komplikować to zaczyna być bardzo upierdliwe.

[Rafcio321]

Każdy sposób jest dobry, który prowadzi do celu a co do pamiętania adresu to nie trzeba tego pamiętać. Przecież jest pod nazwą do której się odwołujemy dziś wykorzystuje ten sposób ale kiedyś może będę robił to lepiej.

Pozdrawiam Rafał

[rastro]

Tak każde rozwiązanie jest dobre tylko niektóre są lepsze od innych.

Generalnie problem jest bardziej skomplikowany, jak się pisze jeden bajt to spoko, ale jak program się rozwija i okazuje się że będzie trzeba będzie zapisać coś jeszcze, powiedzmy że zechcemy zapisywać konfigurację procesu to sprawy zaczynają się co nieco komplikować, będzie trzeba liczyć te wszystkie bajty a pomyłkę całkiem nietrudno. Jeszcze gorzej jak z tym kodem z różnych przyczyn będzie musiał pracować inny programista. A w wersji ze strukturą dopisujemy coś na końcu i już, a całe liczenie jest po stronie kompilatora. Wady są takie że do eeprom zawsze jest zapisywana cała konfiguracja a eeprom a to pewną chwilę trwa (ale to w sumie powinno być bez znaczenia) no i eeprom nie jest wieczny i ma jakieś ograniczenie na ilość zapisów, a w zasadzie nawet nie zapisów co operacji wymazywania.

Czyli generalnie można zrobić spiryt prima sort na zimnych palcach, ale o ile łatwiej jest z z jakimś sprzętem LM/OLM

[Rafcio321]

W pełni się zgadzam. Właśnie gotuję, jeszcze nie tak dawno nie wiedziałem że gotowanie daje tyle frajdy

Pozdrawiam Rafał

[crobe]

Własnie problemem jest address DS on ma chyba 8 bajtów , ale EEPROM.put powinno załatwić sprawę jutro popróbuję . EEPROM.write przechowuje tylko 1 bajt.

Chyba ze kolega zgoda już coś ma ? to szkoda dublować.

[rastro]

Na moje oko właśnie jest dokładnie tak jak napisałeś adres ma osiem bajtów, dokładnie 64bity, zdaje się że można z tego było by co nieco urwać bo pierwsze 8 bitów to jest CRC a ostatnie osiem to chyba Device Type czy coś takiego, w każdym bądź razie dla ds18b20 powinno być zawsze takie samo.

[crobe]

To jaki system sterowania enkoder czy 4 przyciski.
System Menu i pod Menu na 4 przyciskach mam w miarę opanowany.

[275synio]

Koledzy...
Uwielbiam ten temat, czternaście stron teori i nic z tego nie będzie.
Ale tak jak pisałem wcześniej, bardzo mocno trzymam kciuki.
POWODZENIA!!!

[rastro]

Ja bym sobie nie zawracał głowy encoderem, zresztą i tak pewnie jakiś jeden czy dwa przyciski będą potrzebne (no bo jakoś trzeba zatwierdzać czy tam anulować). Ale to tylko moja opinia, ale ja nie lubię encoderów.

Oj tam zaraz nic nie będzie, kwestia czy nadal będą chętni autor tematu jak się zaczęły pojawiać konkrety zaniknął, developer też ma jakiś problem...

Jak mawia mój kolega: Ch*jowo wczoraj, ch*jowo dzisiaj i jutro też będzie chu*jowo.... czyżby długo oczekiwana stabilizacja

[fuks81]

Witam. Jestem 'świeży' w sprawach arduino i brak mi narazie elementarnej wiedzy na temat. Ale skleciłem termostat oparty na trzech ds18b20 ( keg, kolumna, glowica lm). Temp. glowicy do wglądu procesu. Temp kolumny do rozłączenia grzałki nr 1. Temp. keg zamyka proces po osiągnieciu zadanej temperatury. Oczywiście wizualizacja temperatur na lcd 16x2 plus odliczanie czasu od początku procesu w minutach. Sterowanie zawrem iglicowym calkowicie ręczne. Myślałem o strerowaniu zaworka iglicowego silnikiem krokowym, ale upłynie dużo % zanim sie nauczę co z czym. Kibicuje postępom w temacie. Pozdrawiam.

[Cressi]

Ja mam gotowego "pająka" z pomiarem z 2 termometrów, zapamiętywaniem wartości referencyjnej ("temperatura dnia") i zamykaniem zaworu kiedy temperatura na czujniku wzrośnie o 0.1 stopnia w stosunku do zapamiętanej.(dokładnie to kiedy średnia z 3 ostatnich pomiarów jest większa o 0,1 stopnia. W założeniu ma to uodpornić układ na reakcje związane z błędem kwantyzacji)
Termometry na DS18B20, plytka drukowana zaprojektowana, tylko wytrawić, polutować kupic tranzystor i elektrozawór.
Projekt powstał jako wprawka w Arduino i pewnie mozna go rozbudować na wiele sposobów (w planach termometr na PT100 i wyświetlacz graficzny), ale juz w tej postaci działa. Od czegoś trzeba było zacząc, chocby po to by pomysły na algorytm ewentualnie zmodyfikować.
Tu nie ma co za bardzo deliberowac a po prostu usiąść do Arduino.
Jakby sie ktoś chciał pobawić udostępnię kod.

[hydromac]

Cressi, czy mogę prosić kod do analizy?

[robert4you]

Też poproszę.

[irken]

Ja również.

Wysłane z mojego HTC One_M8 przy użyciu Tapatalka

[rastro]

I ja, i ja....

[robert4you]

Ktoś coś dostał od kolegi ?

[rastro]

Obiecanki cacanki, a głupiemu radość

[Cressi]

Sorry, nie sledze watku na bieząco.
Ponizej kod - to moje pierwsze "podejscie" do Arduino wiec moze nie jest optymalny. Przepraszam za zamieszanie i posypuje niniejszym głowe popiołem. Od miesiaca jestem w praktycznie permamentnej podróży służbowej i trochę jestem rozkojarzony..
W załącznikach schemat połaczeń i płytka PCB. Zastrzzegam ze płytka nie jest zweryfikowana w praktyce i mogą być jakieś błędy (chociaż jest dość dokładnie sprawdzona )

Kod: Zaznacz cały

//#include <LiquidCrystal.h>
#include <OneWire.h>
#include <DallasTemperature.h>
#include <Wire.h>
#include <LiquidCrystal_I2C.h>


#define ile_czujnikow 2    //ilosc podlaczonych czujnikow
#define alarm_treshold 0.1
#define relay_treshold 0.3
#define ONE_WIRE_BUS 10     //maagistrala onewire pin 10
#define reference_pin 12    //klawisz ustawiania wartosci referencyjnej podpiety pod pin 12
#define reset_pin 11        //klawisz resetowania wartosci referencyjnej podpiety pod pin 7
#define relay_pin 9        //przekaznik elektrozaworu podpiety pod pin 9
#define buzzer_pin 8

OneWire magistrala(ONE_WIRE_BUS);
DallasTemperature sensors(&magistrala);
LiquidCrystal_I2C lcd(0x3F, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE);
DeviceAddress adresy [ile_czujnikow] =
{ 0x28, 0xFF, 0x43, 0xB7, 0x82, 0x16, 0x3, 0x71, //adresy czujnikow - ustawic wlasne
  0x28, 0xFF, 0x41, 0x58, 0x82, 0x16, 0x5, 0xFC
};
byte symbol[8] = {
  0b00110,
  0b01001,
  0b01001,
  0b00110,
  0b00000,
  0b00000,
  0b00000,
  0b00000
};




void setup() {

  pinMode (reference_pin, INPUT_PULLUP);
  pinMode (reset_pin, INPUT_PULLUP);
  pinMode (relay_pin, OUTPUT);
  pinMode (buzzer_pin, OUTPUT);
  digitalWrite (relay_pin, LOW);
  digitalWrite (buzzer_pin, LOW);
  
  lcd.begin(20, 4);
  lcd.createChar (0, symbol);

  
  lcd.home();
  lcd.print (F("10'th:"));    //tu mozna wstawic wlasna nazwe czujnika                 //wyswietlenie stalych tekstĂłw na wyswietlaczu w celu oszczedzenia czasu procesora
  lcd.setCursor (18, 0);                                                               //
  lcd.print(char(0));
  lcd.print(F("C"));

  lcd.setCursor(0, 1);
  lcd.print (F("Head:"));     ////tu mozna wstawic wlasna nazwe czujnika
  lcd.setCursor (18, 1);
  lcd.print(char(0));
  lcd.print(F("C"));

  
  lcd.setCursor(0, 3);
  lcd.print (F("Ref:"));     ////tu mozna wstawic wlasna nazwe czujnika
  lcd.setCursor (18, 3);
  lcd.print(char(0));
  lcd.print(F("C"));



  sensors.begin();
  sensors.setResolution (12);
  
}



void loop() {
  float mean;
  static float reference = 100;
  byte wiersz = 0;
  float temperatura;

  sensors.requestTemperatures();
  for (wiersz = 0; wiersz < ile_czujnikow; wiersz++)
  {
    temperatura = (sensors.getTempC(adresy [wiersz]));
    display_temp (&temperatura, 12, wiersz);
    if (wiersz == 0) {
            mean = obliczSrednia(temperatura);
            if (digitalRead(reference_pin) == LOW)
            {
              reference = mean;
              // digitalWrite (relay_pin, LOW);
            }
            if (digitalRead (reset_pin) == LOW)
            {
              digitalWrite (buzzer_pin, LOW);
              digitalWrite (relay_pin, LOW);
            }
            if (mean > (reference + alarm_treshold)) digitalWrite (buzzer_pin, HIGH);
            if (mean > (reference + relay_treshold)) digitalWrite (relay_pin, HIGH);
            //display_temp (&mean, 12, 2);
            display_temp (&reference, 12, 3);

    }
  }
}
//delay (300);




void display_temp(float *value, byte column, byte row) //funkcja wyswietla wartosc value w kolumnie column i wierszu row
{
  char outstr[9];
  //value = value + corr[wiersz];
  *value = round (*value * 100);
  *value = (*value / 100.0);
  dtostrf(*value, 6, 2, outstr); //wyswieltenie bo 2 miejsc po przecinku
  lcd.setCursor(column, row);
  lcd.print(outstr);
}

float obliczSrednia (float svalue)    //svalue to wynik jednego pomiaru (SingleValue)
{
#define z_ilu_srednia 3
  static byte k;  //numer pomiaru, albo inaczej pozycja w tablicy
  byte i;
  float mvalue = 0.0;   //zmienna przechowujaca wartosc sredniej
  static float values [z_ilu_srednia]; //tablica przechowujaca wyniki n ostatnich pomiarow

  if (k > (z_ilu_srednia - 1)) k = 0;
  values [k] = svalue;
  k++;
  for (i = 0; i < z_ilu_srednia; i++)
    mvalue = mvalue + values [i];
  mvalue = mvalue / z_ilu_srednia;
  return (mvalue);
}

[rastro]

A jak tam z reakcją na przyciski? Bo na moje oko to pętla trwa co najmniej 750ms. Jak się załączy alarm i mamy peszek to przycisk trza trzymać 3/4 sekundy, to już bardzo długo.

[Cressi]

Retro, masz racje. Tak wlasnie jest. Po rozkazie rozpoczęcia konwersji uP czeka ok 750 ms i tu nic sie nie dzieje.
Pisałem przecież ze to moje pierwsze podejście. Kod jest otwarty i każdy może go sobie poprawiać wedle własnego uznania. Pewnie nawet sam algorytm trzeba by lekko zmodyfikować, ale od czegos trzeba zacząć.
Zaczalem juz pisac inną wersje, ale troche to potrwa .

[rastro]

No trzeba by tam ustawić żeby konwertował asynchronicznie, tylko później trzeba trochę pomyśleć jak zrealizować czekanie na koniec konwersji. Pewnie jakiś timer i zaraz po konwersji trzeba by ustawić flagę i odpalić timer. Jak się timer odpali to flaga jest zerowana i można spokojnie zrealizować odczyt temperatury i obsługę wyświetlacza, a jak nie to tylko skanowanie klawiszy. Ja tam arduino szczególnie nie znam, ale takie rzeczy jak opóźnienia są zawsze słabe zwłaszcza jeżeli mamy do czynienia ze sterowaniem. Ale dramatu nie ma, bo już widziałem sterownik, co to miał tych opóźnień nasianych że główna pętla w porywach szła minutę .

[Cressi]

Tia, w arduino zapomnij o bezpośredniej obsłudze timerów. Ale jest metoda z wykorzystaniem time_milis() i włączeniem w bibliotece dallas_temperature opcji nie czekania na konwersje
W nowej wersji chce zrobić mniej wiecej tak

Kod: Zaznacz cały

{
1. rozpocznij konwersje
2. zapisz bieżący stan time_milis()
{tutaj obsługa wyświetlacza, przycisków etc;
policzenie średnich, zapamiętanie wartości referencyjnej
sprawdź czy minęło 750 ms, jeśli nie, zajmuj sie dalej obsługą wyświetlacza etc.
}
odczytaj termometry, umieść wyniki w tablicy i wróć na początek.
}

W takim układzie można się bawić w debounce, rozpoznawanie jak długo naciśnięty jest klawisz itd. Powolutku. W założeniach miał to być prymitywny dwukanałowy termometr, a obsługę zaworu dopisywałem później.( stad wynika sposób obliczania średniej - ma miejsce tylko gdy program sprawdza sensor o adresie czujnika z pierwszego wiersza tablicy adresów) Zgadzam się z Tobą ze można to znacznie ulepszyć, ale nie od razu Kraków zbudowano. Na szczęście platforma Arduino pozwala na śmiesznie łatwe zaktualizowanie kodu w procesorze.
Z doświadczenia (choć z zupelnie innej branży) powiem Ci,m ze wielu poległo stawiając sobie (albo innym) zbyt wysokie wymagania na początku. Ja jestem zwolennikiem pracy krok po kroku.
Na razie zrobiłem PCB i całość jest w zasadzie już polutowana. Jak wrócę do domu będę kończył hardware i pewnie znów wrócę do softu. Ostatni kontakt z programowaniem to miałem na studiach, ale frajda z samodzielnego stworzenia czegoś co działa jest niemała.

[rastro]

Nie no bez przesady, też się da w sumie całe to arduino to nic innego jak c opakowane w c++ do tego jest edytorek i biblioteki, na upartego pewnie da się nawet wstawki w asm porobić. Do timerów jest nawet lib TimerLibrary czy jakoś tak, wydaje się że to jest to co jest potrzebne do obsługi DS'a w trybie asynchronicznym.

https://github.com/JChristensen/Timer - szczególnie ciekawa jest metoda after z tego liba

[Cressi]

Tyle ze ryzyko jest takie, ze Ci inne biblioteki sie rozsypia jak zaczniesz grzebac. Zeby miec kontrole nad wszystkim trzebaby pisac w czystym C.
Ale dzięki za naprowadzenie, poszperam za ta biblioteką.

[rastro]

Ten lib wydaje się fajny... robisz funkcję readTemp() {}, czytającą temperaturę, w główne pętli zlecasz konwersję do czujników w trybie async, zaraz potem after(750ms, readTemp) i to tyle, jak czas minie to zrobi się call do obsługi odczytu temperatury. Z drugiej strony ten timer raczej jest softwarowy i działa mniej więcej tak jak w twoim opisie.

[crobe]

W jednej bibliotece do DS18b20 jest tak że program nie czeka na czujnik, zrobiłem tak termometr jak chcecie wkleję kod.

Wyświetlacz 2x16 3x 18b20 i alarmy do temperatur

[rastro]

Ale jak nie czeka? To jak odczytujesz temperaturę? Bo to jest tak że zlecasz konwersję do czujnika, a następnie trzeba odczekać aż konwersja się zakończy. Sposoby są dwa albo czekasz aż konwersja się skończy i czytasz, albo nie czekasz i zajmujesz się innymi rzeczami a odczyt realizujesz za jakiś czas (albo liczysz czas z boku, albo używasz timera). Jak masz tak że używasz liba w ten sposób że zadajesz konwersję i potem odczyt i zaraz wyświetlasz to zwyczajnie nie wiesz że czekasz, ew. zwyczajnie nie wiesz że czekasz . Jak to tylko termometr to pół biedy, jak sterujesz elektrozaworem to też ujdzie, bo i tak musisz reagować na odczyt, ale jak wpadniesz na pomysł żeby dodać przycisk do alarmu to czas reakcji blisko sekundy będzie najwyżej irytujący. Ale jak będziesz chciał zrobić sterownik grupowy na SSR to się można nieco zdziwić że nie za bardzo działa.

Kod: Zaznacz cały

void DallasTemperature::requestTemperatures()
{
  _wire->reset();
  _wire->skip();
  _wire->write(STARTCONVO, parasite);

  // ASYNC mode?
  if (!waitForConversion) return; 
  blockTillConversionComplete(&bitResolution, 0);

  return;
}

a w środku blockTillConversionColmplete(... jest:

Kod: Zaznacz cały

void DallasTemperature::blockTillConversionComplete(uint8_t* bitResolution, uint8_t* deviceAddress)
{
	if(deviceAddress != 0 && checkForConversion && !parasite)
	{
	  	// Continue to check if the IC has responded with a temperature
	  	// NB: Could cause issues with multiple devices (one device may respond faster)
	  	unsigned long start = millis();
		while(!isConversionAvailable(0) && ((millis() - start) < 750));	
	}
	
  	// Wait a fix number of cycles till conversion is complete (based on IC datasheet)
	  switch (*bitResolution)
	  {
	    case 9:
	      delay(94);
	      break;
	    case 10:
	      delay(188);
	      break;
	    case 11:
	      delay(375);
	      break;
	    case 12:
	    default:
	      delay(750);
	      break;
	  }

}

przy czym domyślnie waitForConversion jest ustawiane na true, a więc zwykle program czeka ile potrzeba, a że nas zwykle interesuje konwersja 12bit więc sam rozumiesz. Jak przestawisz tryb na async to czekanie musisz sobie zorganizować we własnym zakresie. Ale może znasz jakiś inny lib do ds'a, mi się nie udało znaleźć, ale też jakoś szczególnie nie przykładałem się do szukania czegoś innego.

[crobe]

Odczyt jest opóźniony, ale to działa tak że biblioteka sprawdza czy czujnik przesłał dane jak dane wpłynęły to przekazuje wartość do "glownego" programu.

Nie ma problemu z przyciskami bo właśnie miałem opóźnienia przy klikaniu. Teraz jest ok.

[rastro]

A możesz załączyć kawałek kodu, albo chociaż zdradzić co to za biblioteka? Jakoś nie bardzo sobie mogę wyobrazić jak ta biblioteka działa że w magiczny sposób przekazuje dane jak już konwersja się zakończy. Bo tu z kolegą Cressi kombinujemy, a może rozwiązanie jest pod ręką tylko nam umknęło.

[crobe]

chodzi o " sensors.setWaitForConversion(false); "
a i fakt pisałem ten program dawno odświeża temperatury co sekundę ....

cały program

Kod: Zaznacz cały

#include <EEPROMex.h>
#include <EEPROMVar.h>
#include <LiquidCrystal.h>
#include <OneWire.h>
#include <DallasTemperature.h>
#include <avr/wdt.h>

#define ONE_WIRE_BUS 8
#define TEMPERATURE_PRECISION 12

OneWire oneWire(ONE_WIRE_BUS);
DallasTemperature sensors(&oneWire);
DeviceAddress czuj1, czuj2, czuj3;
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);

unsigned long previousMillis = 0;

//ZMIENNE WARTOSCI MENU////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
int menuin = 0;
int menu = 1;
float val = 0;
float valold = 0;
//#########################################################################################################################################################################################

//ZMIENNE KLAWIATURY  /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
int klaw;
int klawold;
int kwart;
int klawsek = 0;
//#########################################################################################################################################################################################

float temp1;
float temp1min = 20;
float temp1max = 90;

float temp2;
float temp2min = 30 ;
float temp2max = 100;

float temp3;
float temp3min = 40;
float temp3max = 110 ;

int al1 = 0;
int al2 = 0;
int al3 = 0;
int ton = 0;
int dzwiek = 0;

int al1stan = 0;
int al2stan = 0;
int al3stan = 0;

int al1min = 0;
int al1max = 0;

int al2min = 0;
int al2max = 0;

int al3min = 0;
int al3max = 0;


unsigned long czas;  
int klawsek1;

byte st1[8] = {
  0b01000,
  0b10100,
  0b01000,
  0b00011,
  0b00100,
  0b00100,
  0b00100,
  0b00011
};

byte st2[8] = {
  0b01110,
  0b01110,
  0b01110,
  0b01110,
  0b01110,
  0b00000,
  0b01110,
  0b01110
};

byte al[8] = {
  0b00010,
  0b00101,
  0b00111,
  0b00101,
  0b10000,
  0b10000,
  0b10000,
  0b11100
};

byte b1[8] = {
  0b00001,
  0b00001,
  0b00001,
  0b00001,
  0b00001,
  0b00001,
  0b00001,
  0b00001
};

byte b2[8] = {
  0b10000,
  0b10000,
  0b10000,
  0b10000,
  0b10000,
  0b10000,
  0b10000,
  0b10000
};
byte b3[8] = {
  0b01010,
  0b01011,
  0b01010,
  0b01010,
  0b01011,
  0b01000,
  0b01011,
  0b01111
};
byte b4[8] = {
  0b01010,
  0b10010,
  0b01010,
  0b01010,
  0b10010,
  0b00010,
  0b11010,
  0b11110
};

void setup() {
wdt_enable(WDTO_4S);

sensors.begin();
sensors.getAddress(czuj1, 0);
sensors.getAddress(czuj2, 1);
sensors.getAddress(czuj3, 2);
sensors.setResolution(czuj1, TEMPERATURE_PRECISION);
sensors.setResolution(czuj2, TEMPERATURE_PRECISION);
sensors.setResolution(czuj3, TEMPERATURE_PRECISION);
sensors.setWaitForConversion(false);
lcd.begin(16, 2);
lcd.clear();

lcd.createChar(1, st1);
lcd.createChar(2, st2);
lcd.createChar(3, al);
lcd.createChar(4, b1);
lcd.createChar(5, b2);
lcd.createChar(6, b3);
lcd.createChar(7, b4);

czas = millis();

temp1min = EEPROM.readFloat(1);
temp1max = EEPROM.readFloat(10);
temp2min = EEPROM.readFloat(20);
temp2max = EEPROM.readFloat(30);
temp3min = EEPROM.readFloat(40);
temp3max = EEPROM.readFloat(50);


}

void loop() {

if ((millis()-czas) > 1000){ czas = millis(); klawsek = klawsek + 1; };



// ODCZYT Z A1 I USTALENIE KLAWISZA  ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 
kwart = analogRead(A1);
if (kwart > 1000 ) {klaw = 4;delay(200);}else
if (kwart > 500 & kwart < 520 ){klaw = 3;delay(200);}else   
if (kwart > 330 & kwart < 350 ){klaw = 2;delay(200);}else   
if (kwart > 240 & kwart < 270 ){klaw = 1;delay(200);} else {klaw = 0;};

if (klaw > 0) {klawsek = 0;};
if (klawsek > 2000){klawsek = 100;};
if (klawsek > 15){menuin = 0;};


// STEROWANIE MENU ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 
if (menuin == 0 && klaw == 1){menuin = 1; menu = 0;klaw = 0;lcd.clear();lcd.setCursor(0, 0);  lcd.print(F("Menu"));lcd.setCursor(0, 1);  lcd.print(F("Ustawien"));delay(1000);}

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
if (menuin == 0 && klaw == 2 && al1 == 0){al1=1;klaw = 0;} else if (menuin == 0 && klaw == 2 && al1 == 1){al1=0;}
if (menuin == 0 && klaw == 3 && al2 == 0){al2=1;klaw = 0;} else if (menuin == 0 && klaw == 3 && al2 == 1){al2=0;}
if (menuin == 0 && klaw == 4 && al3 == 0){al3=1;klaw = 0;} else if (menuin == 0 && klaw == 4 && al3 == 1){al3=0;}

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
if (menuin == 0 && al1==1) {
if (temp1min > 0 && temp1min >= temp1) {al1min = 1;} else {al1min = 0;};
if (temp1max > 0 && temp1max <= temp1) {al1max = 1;} else {al1max = 0;};
if (al1min == 1 || al1max == 1) {al1stan = 1;} else {al1stan = 0;};
} 


///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
if (menuin == 0 && al2==1) {
if (temp2min > 0 && temp2min >= temp2) {al2min = 1;} else {al2min = 0;};
if (temp2max > 0 && temp2max <= temp2) {al2max = 1;} else {al2max = 0;};
if (al2min == 1 || al2max == 1) {al2stan = 1;} else {al2stan = 0;};
}

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
if (menuin == 0 && al3==1) {
if (temp3min > 0 && temp3min >= temp3) {al3min = 1;} else {al3min = 0;};
if (temp3max > 0 && temp3max <= temp3) {al3max = 1;} else {al3max = 0;};
if (al3min == 1 || al3max == 1) {al3stan = 1;} else {al3stan = 0;};

} 
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////


if (menuin == 1){
if (klaw == 0){delay(100); ;}
lcd.clear();

if (klaw == 1 && menu < 9){menuin = 0;lcd.clear();menu = 0;}
if (klaw == 2 && menu < 99){menu = menu-1;}
if (klaw == 3 && menu < 99){menu = menu+1;}
if (klaw == 4 && menu < 99 ){menu = menu*10;klaw = 0;}

if (klaw == 1 && menu > 9){menu = menu/10;}

if (klaw == 1 && menu > 99){menu = menu/10;}
if (klaw == 2 && menu > 99){val = val - 0.1;}
if (klaw == 3 && menu > 99){val = val + 0.1;}

val=constrain(val,0,120);

switch (menu) {
case 0:  
    menu=1;
    break;
case 1:  
    lcd.setCursor(0, 0);  lcd.print(F("1. Ustaw. Al."));  
    lcd.setCursor(0, 1);  lcd.print(F("Termometr 1"));
    break;
    case 9:  
    menu = 10;
    break;
    case 10:  
    lcd.setCursor(0, 0);  lcd.print(F("1.1 Ustaw. Alarmu."));  
    lcd.setCursor(0, 1);  lcd.print(F("Min     [     ] "));
    lcd.setCursor(9, 1);  lcd.print(temp1min,1);
    lcd.setCursor(15, 1); lcd.write(byte(1));
    break;
    case 100:  
    val = temp1min;
    menu = 101;
    klaw = 0;
    break;
    case 101:  
    if (klaw == 4 && menu > 99){temp1min = val;menu = menu/10; EEPROM.writeFloat(1,val);}
    lcd.setCursor(0, 0);  lcd.print(F("1.1 Ustaw. Alarmu."));  
    lcd.setCursor(0, 1);  lcd.print(F("Min     >     < "));
    lcd.setCursor(9, 1);  lcd.print(val,1);
    lcd.setCursor(15, 1); lcd.write(byte(1));
    break;
    case 11:  
    lcd.setCursor(0, 0);  lcd.print(F("1.2 Ustaw. Alarmu."));  
    lcd.setCursor(0, 1);  lcd.print(F("Max     [     ] "));
    lcd.setCursor(9, 1);  lcd.print(temp1max,1);
    lcd.setCursor(15, 1); lcd.write(byte(1));
    break;
    case 110:  
    val = temp1max;
    menu = 111;
    klaw = 0;
    break;
    case 111:  
    if (klaw == 4 && menu > 99){temp1max = val;menu = menu/10;EEPROM.writeFloat(10,val);}
    lcd.setCursor(0, 0);  lcd.print(F("1.2 Ustaw. Alarmu."));  
    lcd.setCursor(0, 1);  lcd.print(F("Max     >     < "));
    lcd.setCursor(9, 1);  lcd.print(val,1);
    lcd.setCursor(15, 1); lcd.write(byte(1));
    break;
    case 12:  
    menu = 11;
    break;


case 2:  
    lcd.setCursor(0, 0);  lcd.print(F("2. Ustaw. AL."));  
    lcd.setCursor(0, 1);  lcd.print(F("Termometr 2"));
    break;
    case 19:  
    menu = 20;
    break;
    case 20:  
    lcd.setCursor(0, 0);  lcd.print(F("2.1 Ustaw. Alarmu."));  
    lcd.setCursor(0, 1);  lcd.print(F("Min     [     ] "));
    lcd.setCursor(9, 1);  lcd.print(temp2min,1);
    lcd.setCursor(15, 1); lcd.write(byte(1));
    break;
    case 200:  
    val = temp2min;
    menu = 201;
    klaw = 0;
    break;
    case 201:  
    if (klaw == 4 && menu > 99){temp2min = val;menu = menu/10;EEPROM.writeFloat(20,val);}
    lcd.setCursor(0, 0);  lcd.print(F("2.1 Ustaw. Alarmu."));  
    lcd.setCursor(0, 1);  lcd.print(F("Min     >     < "));
    lcd.setCursor(9, 1);  lcd.print(val,1);
    lcd.setCursor(15, 1); lcd.write(byte(1));
    break;
    case 21:  
    lcd.setCursor(0, 0);  lcd.print(F("2.2 Ustaw. Alarmu."));  
    lcd.setCursor(0, 1);  lcd.print(F("Max     [     ] "));
    lcd.setCursor(9, 1);  lcd.print(temp2max,1);
    lcd.setCursor(15, 1); lcd.write(byte(1));
    break;
    case 210:  
    val = temp2max;
    menu = 211;
    klaw = 0;
    break;
    case 211:  
    if (klaw == 4 && menu > 99){temp2max = val;menu = menu/10;EEPROM.writeFloat(30,val);}
    lcd.setCursor(0, 0);  lcd.print(F("2.2 Ustaw. Alarmu."));  
    lcd.setCursor(0, 1);  lcd.print(F("Max     >     < "));
    lcd.setCursor(9, 1);  lcd.print(val,1);
    lcd.setCursor(15, 1); lcd.write(byte(1));
    break;
    case 22:  
    menu = 21;
    break;
    
case 3:  
    lcd.setCursor(0, 0);  lcd.print(F("3. Ustaw. AL."));  
    lcd.setCursor(0, 1);  lcd.print(F("Termometr 3"));
    break;
    case 29:  
    menu = 30;
    break;
    case 30:  
    lcd.setCursor(0, 0);  lcd.print(F("3.1 Ustaw. Alarmu."));  
    lcd.setCursor(0, 1);  lcd.print(F("Min     [     ] "));
    lcd.setCursor(9, 1);  lcd.print(temp3min,1);
    lcd.setCursor(15, 1); lcd.write(byte(1));
    break;
    case 300:  
    val = temp3min;
    menu = 301;
    klaw = 0;
    break;
    case 301:  
    if (klaw == 4 && menu > 99){temp3min = val;menu = menu/10;EEPROM.writeFloat(40,val);}
    lcd.setCursor(0, 0);  lcd.print(F("3.1 Ustaw. Alarmu."));  
    lcd.setCursor(0, 1);  lcd.print(F("Min     >     < "));
    lcd.setCursor(9, 1);  lcd.print(val,1);
    lcd.setCursor(15, 1); lcd.write(byte(1));
    break;
    case 31:  
    lcd.setCursor(0, 0);  lcd.print(F("3.2 Ustaw. Alarmu."));  
    lcd.setCursor(0, 1);  lcd.print(F("Max     [     ] "));
    lcd.setCursor(9, 1);  lcd.print(temp3max,1);
    lcd.setCursor(15, 1); lcd.write(byte(1));
    break;
    case 310:  
    val = temp3max;
    menu = 311;
    klaw = 0;
    break;
    case 311:  
    if (klaw == 4 && menu > 99){temp3max = val;menu = menu/10;EEPROM.writeFloat(50,val);}
    lcd.setCursor(0, 0);  lcd.print(F("3.2 Ustaw. Alarmu."));  
    lcd.setCursor(0, 1);  lcd.print(F("Max     >     < "));
    lcd.setCursor(9, 1);  lcd.print(val,1);
    lcd.setCursor(15, 1); lcd.write(byte(1));
    break;
    case 32:
    menu = 31;
    break;
case 4:  
    menu=3;
    break;


}}

if (menuin == 0){

delay(100);
lcd.clear();



 
//lcd.setCursor(8, 1);  lcd.write(byte(5));
    
if (temp1 > 99) {lcd.setCursor(1, 0);} else {lcd.setCursor(2, 0);}  
lcd.print(temp1,1); 
lcd.setCursor(6, 0);
lcd.write(byte(1));

if (temp2 > 99) {lcd.setCursor(10, 0);} else {lcd.setCursor(11, 0);}
lcd.print(temp2,1); 
lcd.setCursor(15, 0);
lcd.write(byte(1));

if (temp3 > 99) {lcd.setCursor(1, 1);} else {lcd.setCursor(2, 1);}
lcd.print(temp3,1);

lcd.setCursor(6, 1);
lcd.write(byte(1));

//lcd.setCursor(12, 1);
//lcd.print(klawsek);
dzwiek = 0;
if (al1stan == 0 && al1==1) {lcd.setCursor(0, 0);lcd.write(byte(3));};
if (al1stan == 1 && al1==1) {lcd.setCursor(0, 0);lcd.write(byte(2));dzwiek = 1;};

if (al2stan == 0 && al2==1) {lcd.setCursor(9, 0);lcd.write(byte(3));};
if (al2stan == 1 && al2==1) {lcd.setCursor(9, 0);lcd.write(byte(2));dzwiek = 1;};

if (al3stan == 0 && al3==1) {lcd.setCursor(0, 1);lcd.write(byte(3));};
if (al3stan == 1 && al3==1) {lcd.setCursor(0, 1);lcd.write(byte(2));dzwiek = 1;};



if (millis() - previousMillis > 1000)   
 {
   temp1 = sensors.getTempC(czuj1);
   temp2 = sensors.getTempC(czuj2);
   temp3 = sensors.getTempC(czuj3); 
   sensors.setWaitForConversion(false);
   sensors.requestTemperatures();  
   previousMillis = millis(); 
 }

}

if (dzwiek == 1) { if (ton==0){ton=1;tone(10,2000);} else if (ton==1){ton=0;tone(10,1000);};} else {noTone(10);}
wdt_reset();

}

[rastro]

E... tak to wiemy, tu magi żadnej nie ma, jest dokładnie tak jak proponował Cressi, aplikacja w pętli liczy sobie czas dokładnie tutaj

Kod: Zaznacz cały

if (millis() - previousMillis > 1000)   
 {
   temp1 = sensors.getTempC(czuj1);
   temp2 = sensors.getTempC(czuj2);
   temp3 = sensors.getTempC(czuj3);
   sensors.setWaitForConversion(false);
   sensors.requestTemperatures(); 
   previousMillis = millis();
 }

tylko tak,

• to: sensors.setWaitForConversion(false); bym wywalił do sekcji setup() bo po co tą flagę ustawiać za każdym razem?
• to: millis() - previousMillis > 1000 to bym zmienił na millis() - previousMillis > 750, bo tak jak jest odświeżanie jest poniżej sekundy, bo komunikacja z trzema czujnikami swoje zajmuje

[crobe]

No faktycznie można dać do setup

Ale 1000 bym zostawił .

Poza tymi program działa jak ktos chce termometr 3 czujniki.

System menu tez działa

[rastro]

Twoja wola, według specyfikacji czujnika jednak nie jest to potrzebne, zwyczajnie ja bym to zrobił inaczej, najważniejsze że działa i jesteś zadowolony

[Cressi]

Ja wykoncypowalem w tak zwanym miedyczasie cos innego, tylko musze to sprawdzi praktyce (nie mam ze soba Arduino.)
Licznik 1 jest skonfigurowany na generowanie przerwania co 1 sek . W przerwaniu :
odczytuje temperature
zleca kolejna konwersje
Cala reszta to juz zabawa w petli głownej. Jak zweryfikuje dzialanie to sie oczywiście podzielę.

Crobe, jedno pytanie. Widze ze odczytujesz adresy czujnikow bezposrednio w programie. Nie zdaza sie, ze Ci program zamieni czujniki miejscami?