Projekt zegara z termometrem, fotorezystorem i PIR

//********************************************************************************************
//**********************PROGRAM STEROWNIKA WĘDZARNI*******************************************
//**************************WWW.ARDUINOWO.PL**************************************************
//********************************************************************************************

#include  // Dołączenie biblioteki LiquidCrystal_I2C dla wyświetlacza LCD
#include  // Dołączenie biblioteki OneWire dla komunikacji z czujnikiem temperatury
#include  // Dołączenie biblioteki DallasTemperature do obsługi czujnika temperatury

#define sbi(sfr, bit) (_SFR_BYTE(sfr) |= _BV(bit)) // Makro do ustawiania bitów w rejestrach
volatile boolean flaga = 0; // Zmienna typu boolean do sterowania flagą

// Tworzenie obiektu dla wyświetlacza LCD z adresem I2C, liczba kolumn i wierszy
LiquidCrystal_I2C lcd(0x27, 20, 4);

volatile byte tryb = 0; // Zmienna do zliczania naciśnięć przycisku

const byte opoznienie = 25; // Opóźnienie odsprzęgania w milisekundach
unsigned long ostatni_czas1 = millis(); // Czas ostatniego zmienia stanu pierwszego przycisku
boolean poprzedni_stan1 = LOW; // Poprzedni stan pierwszego przycisku

int etap = 1; // Zmienna etapu
long czas; // Zmienna czasu
float temperatura_aktualna=0; // Zmienna aktualnej temperatury
byte wentylator_aktualny; // Zmienna aktualnej prędkości wentylatora

float temperatura_zadana; // Ustawienie żądanej temperatury
boolean grzanie=0; // Zmienna sterująca przekaźnikiem (0 - wyłączony, 1 - włączony)

//********************************************************************************************
//*******************************KONFIGURACJA*************************************************
//********************************************************************************************

// Deklaracja i inicjalizacja zmiennej globalnej - użycie pinu nr 7 dla czujnika temperatury
const byte nr_pinu = 7;

// Definicja numeru pinu, do którego podłączony jest przekaźnik
const int pin_przek = 5;

const int pwmPin = 3; // Definicja numeru pinu PWM

// Tablica z ustawieniami temperatury dla poszczególnych etapów w stopniach C
float temperatura[] = {40.00, 50.00, 60.00, 35.00}; 

// Tablica z czasami trwania poszczególnych etapów w sekundach
unsigned int sekundnik[] = {13, 14, 15, 16}; 

// Tablica z ustawieniami prędkości wentylatora dla poszczególnych etapów w procentach
byte wentylator[] = {10, 20, 100, 23}; 

float histereza = 2; // Ustawienie wartości histerezy dla temperatury


// Tworzenie obiektu dla protokołu OneWire
OneWire oneWire(nr_pinu);
// Tworzenie obiektu dla czujnika temperatury
DallasTemperature sensor(&oneWire);

//********************************************************************************************
//*******************************FUNKCJA SETUP************************************************
//********************************************************************************************

void setup()
{
  //Ustawienie wartości początkowych
  czas = sekundnik[0];
  wentylator_aktualny = wentylator[0];
  temperatura_zadana = temperatura[0];

  // TIMER 1 for interrupt frequency 1 Hz:
  cli(); // stop interrupts
  TCCR1A = 0; // set entire TCCR1A register to 0
  TCCR1B = 0; // same for TCCR1B
  TCNT1  = 0; // initialize counter value to 0
  // set compare match register for 1 Hz increments
  OCR1A = 62499; // = 16000000 / (256 * 1) - 1 (must be <65536)
  // turn on CTC mode
  TCCR1B |= (1 << WGM12);
  // Set CS12, CS11 and CS10 bits for 256 prescaler
  TCCR1B |= (1 << CS12) | (0 << CS11) | (0 << CS10);
  // enable timer compare interrupt
  TIMSK1 |= (1 << OCIE1A);
  sei(); // allow interrupts

  lcd.init(); // Inicjalizacja wyświetlacza LCD
  lcd.backlight(); // Włączenie podświetlenia wyświetlacza
  sensor.begin(); // Inicjalizacja czujnika temperatury
  Serial.begin(9600); // Rozpoczęcie komunikacji szeregowej z prędkością 9600 bps

  pinMode(2, INPUT_PULLUP); // Ustawienie pinu 2 jako wejście z podciągnięciem do VCC
  sbi(PCICR, PCIE2); // Włączenie przerwań pin-change dla grupy PCINT2
  sbi(PCMSK2, PCINT18); // Włączenie przerwania dla pinu PCINT18 (pin 2)

  pinMode(pin_przek, OUTPUT); // Ustawienie pinu przekaźnika jako wyjście
  digitalWrite(pin_przek, grzanie); // Ustawienie początkowego stanu przekaźnika

  pinMode(pwmPin, OUTPUT); // Ustawienie pinu PWM jako wyjście
}

//********************************************************************************************
//*******************************FUNKCJA LOOP*************************************************
//********************************************************************************************

void loop()
{
  sensor.requestTemperatures(); // Żądanie odczytu temperatury z czujnika
  temperatura_aktualna = sensor.getTempCByIndex(0); // Pobranie odczytu temperatury

  // Wyświetlanie trybu pracy na wyświetlaczu LCD
  if (tryb == 0) {
    wyswietlanie_trybu(tryb, temperatura_aktualna, czas, wentylator_aktualny);
  } else {
    wyswietlanie_trybu(tryb, temperatura[tryb - 1], sekundnik[tryb - 1], wentylator[tryb - 1]);
  }

  // Implementacja logiki histerezy dla grzania
  if (temperatura_aktualna < temperatura_zadana - histereza && grzanie == 0) {
    grzanie = 1; // Włączenie grzania, gdy temperatura jest znacznie poniżej żądanej
  } else if (temperatura_aktualna > temperatura_zadana + histereza && grzanie == 1) {
    grzanie = 0; // Wyłączenie grzania, gdy temperatura przekracza żądaną wartość
  }
  digitalWrite(pin_przek, grzanie); // Sterowanie przekaźnikiem

  // Sterowanie prędkością wentylatora za pomocą PWM
  analogWrite(pwmPin, (wentylator_aktualny * 255) / 100);
}

//********************************************************************************************
//*******************************PRZERWANIE PIN***********************************************
//********************************************************************************************

ISR(PCINT2_vect)
{
  boolean stan1 = !bitRead(PIND, 2); // Odczytanie bieżącego stanu trzeciego przycisku
  if (stan1 != poprzedni_stan1) // Sprawdzenie, czy stan trzeciego przycisku się zmienił
  { // Sprawdzenie, czy przycisk jest wciśnięty i czy upłynęło odpowiednio
    // dużo czasu od ostatniego wciśnięcia
    if (stan1 == LOW && millis() - ostatni_czas1 > opoznienie)
    {
      tryb++; // Inkrementacja zmiennej "tryb"
      if (tryb > 4) {
        tryb = 0;  // Reset wartości "tryb" po przekroczeniu 2
      }
      // lcd.clear();
    }
    // Aktualizacja czasu ostatniego wciśnięcia, gdy przycisk jest zwolniony
    if (stan1 == HIGH) ostatni_czas1 = millis();
  }
  poprzedni_stan1 = stan1; // Aktualizacja poprzedniego stanu trzeciego przycisku

}

//********************************************************************************************
//*******************************PRZERWANIE ZEGARA********************************************
//********************************************************************************************

ISR(TIMER1_COMPA_vect)
{
  czas--; // Dekrementacja zmiennej czasu
  if (czas < 0) { // Sprawdzenie, czy czas jest mniejszy niż 0
    if (etap != 5) { // Sprawdzenie, czy etap nie jest równy 5
      etap++; // Inkrementacja etapu
    }
    if (etap == 2) { // Sprawdzenie, czy etap jest równy 2
      czas = sekundnik[1]; // Ustawienie czasu na wartość z tablicy sekundnik dla etapu 2
      wentylator_aktualny = wentylator[1]; // Ustawienie prędkości wentylatora dla etapu 2
      temperatura_zadana = temperatura[1]; // Ustawienie temperatury zadanej dla etapu 2
    }
    if (etap == 3) { // Sprawdzenie, czy etap jest równy 3
      czas = sekundnik[2]; // Ustawienie czasu na wartość z tablicy sekundnik dla etapu 3
      wentylator_aktualny = wentylator[2]; // Ustawienie prędkości wentylatora dla etapu 3
      temperatura_zadana = temperatura[2]; // Ustawienie temperatury zadanej dla etapu 3
    }
    if (etap == 4) { // Sprawdzenie, czy etap jest równy 4
      czas = sekundnik[3]; // Ustawienie czasu na wartość z tablicy sekundnik dla etapu 4
      wentylator_aktualny = wentylator[3]; // Ustawienie prędkości wentylatora dla etapu 4
      temperatura_zadana = temperatura[3]; // Ustawienie temperatury zadanej dla etapu 4
    }
    if (etap == 5) { // Sprawdzenie, czy etap jest równy 5
      czas = 0; // Ustawienie czasu na 0
      wentylator_aktualny = 0; // Wyłączenie wentylatora
      temperatura_zadana = 0; // Ustawienie temperatury zadanej na 0
    }
  }
}

//********************************************************************************************
//*******************************FUNKCJE******************************************************
//********************************************************************************************

void wyswietlanie_trybu(byte tryb_f, float temp, unsigned long sekundy, byte went)
{
  lcd.setCursor(0, 0); // Ustawienie kursora na początku pierwszego wiersza
  if (tryb_f != 0) { // Sprawdzenie, czy tryb jest różny od 0
    lcd.print("   Ust. Etap_"); // Wyświetlenie tekstu "Ust. Etap_"
    lcd.print(tryb); // Wyświetlenie numeru aktualnego trybu
    lcd.print("  "); // Wyświetlenie dwóch spacji
  } else { // Jeśli tryb jest równy 0
    lcd.print("Proces: "); // Wyświetlenie tekstu "Proces: "
    if (etap != 5) { // Sprawdzenie, czy etap jest różny od 5
      lcd.print("Etap_"); // Wyświetlenie tekstu "Etap_"
      lcd.print(etap); // Wyświetlenie numeru aktualnego etapu
    } else { // Jeśli etap jest równy 5
      lcd.print("KONIEC"); // Wyświetlenie tekstu "KONIEC"
    }
  }

  lcd.setCursor(2, 1); // Ustawienie kursora
  lcd.print("Temp: "); // Wyświetlenie tekstu "Temp:"
  lcd.print(temp + 0.05, 1); // Wyświetlenie temperatury z dokładnością do 1 miejsca po przecinku
  lcd.write(0b11011111); // Symbol stopnia
  lcd.print("C"); // Symbol stopnia Celsjusza
  lcd.print("   "); // Czyszczenie niepotrzebnych znaków

  lcd.setCursor(2, 2); // Ustawienie kursora
  lcd.print("Czas: "); // Wyświetlenie tekstu "Czas:"
  lcd.print(sekundy); // Wyświetlenie pozostałego czasu
  lcd.print("s"); // Wyświetlenie symbolu sekund
  lcd.print("   "); // Czyszczenie niepotrzebnych znaków

  lcd.setCursor(2, 3); // Ustawienie kursora
  lcd.print("Went: "); // Wyświetlenie tekstu "Went:"
  lcd.print(went); // Wyświetlenie aktualnej prędkości wentylatora
  lcd.print("%"); // Wyświetlenie symbolu procenta
  lcd.print("  "); // Czyszczenie niepotrzebnych znaków

}

#include    // Sterowanie LCD przez I²C
#include              // Protokół 1-Wire dla DS18B20
#include    // Obsługa DS18B20

#define sbi(sfr, bit) (_SFR_BYTE(sfr) |= _BV(bit)) // Ustawianie bitów
volatile boolean flaga = 0;                       // Flaga do przerwań
    

volatile byte tryb = 0;               // 0=auto, 1–4=ręczne etapy
const byte opoznienie = 25;           // Debounce przycisku (ms)
unsigned long ostatni_czas1 = millis();
boolean poprzedni_stan1 = LOW;

int etap = 1;                         // Numer bieżącego etapu
long czas;                            // Licznik sekund
float temperatura_aktualna = 0;       // Odczyt z DS18B20
float temperatura_zadana;             // Cel histerezy
boolean grzanie = 0;                  // Stan przekaźnika
byte wentylator_aktualny;             // PWM wentylatora

const byte nr_pinu = 7;               // Pin DS18B20
const int pin_przek = 5;              // Przekaźnik grzałki
const int pwmPin = 3;                 // Wyjście PWM

float temperatura[]   = {40.0,50.0,60.0,35.0};
unsigned int sekundnik[] = {13,14,15,16};
byte wentylator[]    = {10,20,100,23};
float histereza = 2.0;                // Bufor ±2°C

LiquidCrystal_I2C lcd(0x27, 20, 4);   // LCD 20×4, adres 0x27
OneWire oneWire(nr_pinu);
DallasTemperature sensor(&oneWire);
    

void setup() {
  // 1) Pierwsze wartości
  czas                = sekundnik[0];
  wentylator_aktualny = wentylator[0];
  temperatura_zadana  = temperatura[0];

  // 2) Timer1 – CTC 1 Hz
  cli();
  TCCR1A = 0; TCCR1B = 0; TCNT1 = 0;
  OCR1A = 62499;                  // 16MHz/256/1Hz – 1
  TCCR1B |= (1 << WGM12) | (1 << CS12);
  TIMSK1 |= (1 << OCIE1A);
  sei();

  // 3) LCD i sensor
  lcd.init(); lcd.backlight();
  sensor.begin();
  Serial.begin(9600);

  // 4) Przycisk PCINT na pinie 2
  pinMode(2, INPUT_PULLUP);
  sbi(PCICR, PCIE2);
  sbi(PCMSK2, PCINT18);

  // 5) Wyjścia
  pinMode(pin_przek, OUTPUT);
  digitalWrite(pin_przek, grzanie);
  pinMode(pwmPin, OUTPUT);
}
    

void loop() {
  // A) Odczyt temperatury
  sensor.requestTemperatures();
  temperatura_aktualna = sensor.getTempCByIndex(0);

  // B) Wyświetlanie (auto vs ręczne)
  if (tryb == 0)
    wyswietlanie_trybu(0, temperatura_aktualna, czas, wentylator_aktualny);
  else
    wyswietlanie_trybu(tryb,
      temperatura[tryb-1],
      sekundnik[tryb-1],
      wentylator[tryb-1]);

  // C) Histereza grzałki
  if (temperatura_aktualna < temperatura_zadana - histereza && !grzanie)
    grzanie = 1;
  else if (temperatura_aktualna > temperatura_zadana + histereza && grzanie)
    grzanie = 0;
  digitalWrite(pin_przek, grzanie);

  // D) PWM wentylatora
  analogWrite(pwmPin, (wentylator_aktualny * 255) / 100);
}
    

ISR(PCINT2_vect) {
  boolean stan1 = !bitRead(PIND, 2);
  if (stan1 != poprzedni_stan1) {
    if (stan1 == LOW && millis() - ostatni_czas1 > opoznienie) {
      tryb++;
      if (tryb > 4) tryb = 0;
    }
    if (stan1 == HIGH) ostatni_czas1 = millis();
  }
  poprzedni_stan1 = stan1;
}
    

ISR(TIMER1_COMPA_vect) {
  czas--;
  if (czas < 0) {
    etap++;
    if (etap <= 4) {
      int i = etap - 1;
      czas                = sekundnik[i];
      wentylator_aktualny = wentylator[i];
      temperatura_zadana  = temperatura[i];
    } else { // etap 5 = KONIEC
      czas                = 0;
      wentylator_aktualny = 0;
      temperatura_zadana  = 0;
    }
  }
}
    

void wyswietlanie_trybu(byte tryb_f, float temp, unsigned long sekundy, byte went) {
  lcd.setCursor(0, 0);
  if (tryb_f) {
    lcd.print("   Ust. Etap_"); lcd.print(tryb_f); lcd.print("  ");
  } else {
    lcd.print("Proces: ");
    if (etap < 5) {
      lcd.print("Etap_"); lcd.print(etap);
    } else {
      lcd.print("KONIEC");
    }
  }

  lcd.setCursor(2, 1);
  lcd.print("Temp: ");
  lcd.print(temp + 0.05, 1); lcd.write(0b11011111); lcd.print("C   ");

  lcd.setCursor(2, 2);
  lcd.print("Czas: "); lcd.print(sekundy); lcd.print("s   ");

  lcd.setCursor(2, 3);
  lcd.print("Went: "); lcd.print(went); lcd.print("%  ");
}