Контроллер для сауны

[wowa]

Есть идея сконструировать термостат с регулировкой установленной температуры, часовым включением и таймером выключения. Железо уже скомплектовал. Все более мене действующие скечы есть, но вот их собрать в единое- это уже выше крыши, два месяца уже на это дело потратил, пока только термостат и тот примитивный без проверки датчика, а это не безопасно.
Всё должно работать примерно так:
Термостат регулирует температуру сауны.
Контроллер на основе Arduino, силовая часть регулируется через SSR. Часы реального времени на DS1307 они на дисплее LCD16х2 показывает текущее время, время установленное на включение печки сауны (функция будильника).
Доп функция регулировка оборотами вытяжки: при пользованием сауны обороты минимальные (чтобы не было сквозняка), при сушке максимальные.
Датчики температуры на DS18B20- два для самоконтроля сравнения показаний при ошибке отрубается печка.
На DS1307 или Arduine (сейчас Arduina считает циклы) должна быть реализована ещё одна защитная ф-я когда включается тэны запускается внутренний таймер на 4 часа (например) по истечении отключает тэны.
Вот такая сказка.
Этот термостат (без вентилятора ) подойдет и для управления бойлером для нагрева воды, и регулировки климата в помещении (в доме) и т.д.
Я могу если интересно, выкладывать схемы и другую инфу которую набрал, также куски скеча и с ним как раз нужна помощь.

[askar90]

выкладывай. очень интересно !

[wowa]

Сообщение от askar90

выкладывай. очень интересно !

ну выложил и шо?

[SilverSwift]

Контроллер не может быть на основе Arduino, Arduino это и есть контроллер на основе чипа Atmega. Не придираюсь, объясняю

Подцепить дисплей и организовать на него вывод не проблема, обращаться к часам тоже, для регулировки оборотов вытяжки нужна одна нога с ШИМ, датчики температуры и потенцимер для регулировки оборотов это работа с аналоговыми входами. Тэны это цифровой вывод. В общем нетривиальных задач нет... Мощностей любой ардуины должно хватить. Простой путь разработки заключается в отладке отдельных модулей и потом объединения их в одну прогу. Если есть желание делать самостоятельно и разбираться задавайте вопросы более конкретные типа есть код, надо то-то, но не получается то-то.


Естественно все это железо должно подключаться не напрямую к ардуине, нужны релюшки, шим регуляторы, питание. Сделать схемотехнику по-человечески на коленке и на скрутках не получится. Тем более, что работать все это будет во влажной среде и на больших токах. Может и убить. Плюс вести отладку на таком железе я бы не стал, оборудование не дешевое, опять же токи большие, защиты от перегрузов и переполюсовок наверняка нет, обидно будет из-за опечатки попасть на деньги или устроить пожар. Короче продумать и проработать надо все вплоть до гидроизолированных корпусов Ну и ответы будут более информативными если вопросы будут более предметными. Успехов!

[wowa]

Спасибо за поддержку
"Контроллер не может быть на основе Arduino, Arduino это и есть контроллер на основе чипа Atmega. " Принимаю критику, от этого проект не станет проще, а совокупность "контроллера" можно и присвоить и пускателю с биметаллической пластине в цепи...
Налаживал коды пока нет особенно что показать, а тем более все строчки без комментариев, отдельные части программного стека разделял для лучшей читаемости. Управлять контроллер будет стандартной "печкой" типа Harvia или Nordic и т.п. но ихние терморегуляторы - примитивные, а те которые по круче уже с $300 начинается. Значит так берём "печку" без пульта.
На счёт безопасности. Конечно это параллельно и в моём проекте тому есть место.
На счёт надёжности. Силовая часть и пульт управления за пределами сауны. Внутри только тены и термодатчики.
Для начала приведу схему. Пока эскиз для обкатки идеи. Пока без вентилятора. Забаламутила теория по димированию и регулировке оборотов.
Два термодатчика для исключения ошибок и перегрева тэнов. Обороты вентилятора управляется тоже кнопками

[wowa]

Функция Alarm выполняет функцию включения печки по установленному времени. Таймер ведёт автоматический отсчёт времени и отключает печку по истечении программно заданного времени не зависимо от пользователя. Таймер запускается по истечении установленного времени Alarm, или нажатии кнопки START. При нажатии на STOP всё отрубается. Скечь работает только от части, таймер пока не знаю как описать.

#include <Wire.h>
#include <RTClib.h>
#include <LiquidCrystal_I2C.h>

RTC_DS1307 RTC;
DateTime now;
LiquidCrystal_I2C lcd(0x20,16,2);

// define variables
int lcd_key = 0;
int adc_key_in = 0;
int lastHour = 0;
int lastMinute = 0;
int menuOptions = 3;
int menuOption = 0;
int alarmHours = 0;
int alarmMinutes = 0;
bool alarmSet = 0;
bool resetClock = false;
boolean relayStatus1=LOW; //

// define constants
//
const int pirPin = 7;
#define RELAY_PIN 11 // 
#define btnRIGHT  0
#define btnUP     1
#define btnDOWN   2
#define btnLEFT   3
#define btnSELECT 4
#define btnNONE   5
#define beeper A1
#define shortBeep 100
#define longBeep  500
uint8_t laikrodis[8] = {0xe, 0x15, 0x1d, 0x11, 0xe, 0x0, 0, 0}; //
uint8_t zadint[8] = {0x11, 0x1f, 0xe, 0x4, 0xe, 0x1f, 0x1f, 0x0}; // 

//////////////////////////////////////////////////////////////////////////
void setup () {
  
  lcd.init();   // initialize the lcd
  lcd.backlight(); //  
   pinMode(RELAY_PIN,OUTPUT);//
  digitalWrite(RELAY_PIN,LOW);
  pinMode(beeper, OUTPUT);
  digitalWrite(beeper, LOW);  
  pinMode(pirPin, INPUT);  
  Wire.begin();
  RTC.begin();
 lcd.createChar(3, laikrodis);
 lcd.createChar(4, zadint);
}

///////////////////////////////////////////////////////////////////////
void loop () {
  now = RTC.now();
  digitalClockDisplay( ); // update clock
  for (int i = 0; i < 10000; i++)
  {
    button_loop(); //check for button pushed
   }
  }

//////////////////////////////////////////////////////////////////////
void printDigits(byte digits)
{
  // utility function for digital clock display: prints preceding colon and leading 0

 lcd.print(":");
  if(digits < 10)
    lcd.print('0');
  lcd.print(digits,DEC);
}

void digitalClockDisplay()
{
   if (now.minute() != lastMinute || resetClock == true)
  {
    if(now.hour() < 10)
    lcd.setCursor(5,1);                  /////////////
    lcdClear();
    lcd.write(3);
    lcd.print(now.hour(), DEC);
    printDigits(now.minute());
     
      // Added alarm set indicator
      if (alarmSet)
     lcd.write(4);
    }
  resetClock = false;

  lastHour = now.hour();
  lastMinute = now.minute();

  //check for alarm
  if (alarmSet)
  {
    
    if (alarmHours == lastHour && alarmMinutes == lastMinute)
    {
      //sound alarm
      setOffAlarm();
    } 
  }
}

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

void button_loop()
{
  int button = read_LCD_buttons();
  if (button == btnSELECT)
  {
    timedBeep(shortBeep,1); 
    selectMenu();
  }
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////

void selectMenu()
{
  int button = 0; 
  menuOption = 1;
  lcdClear();
  lcd.print("Minute Timer");  

  while (menuOption <= menuOptions)
  {
    button = read_LCD_buttons();
    if (button == btnSELECT)
    {
      timedBeep(shortBeep,1);   
      menuOption++;

      if (menuOption == 2)
      {
        lcdClear();
        // clearAlarm feature
        lcd.print("Set/Clear START");            
      }
      if (menuOption == 3)
      {
        lcdClear();
        lcd.print("Set time");            
      }
    } 

    if (button == btnLEFT)
    {
      if (menuOption == 1)
      {
        timedBeep(shortBeep,1);
        minuteTimer();
        return;
      }
      if (menuOption == 2)
      {
        timedBeep(shortBeep,1);
        // clearAlarm feature
        //check for existing alarm
        if (alarmSet)
        {
          clearAlarm();
        }
        else
        {
          setAlarm();
        }
        return;
      }
      if (menuOption == 3)
      {
        timedBeep(shortBeep,1);
        // set Time feature
        setDateTime();
        return;
      } 
    }
  }
}  
//////////////////////////////////////////////////////////////////

// clearAlarm feature
void clearAlarm()
{
  int button = 0;
  bool clearIt = true;
  lcdClear();
  lcd.print("START Set For");
  lcd.setCursor(8,0);
  lcd.print(alarmHours);   
  lcd.print(":");
  lcd.print(alarmMinutes);
  lcd.print(" ");
    delay(2000);
  lcdClear();
  lcd.print("Clear START?");
  lcd.setCursor(8,0);
  lcd.print("Yes");  

  while (button != btnSELECT)
  {
    button = read_LCD_buttons();
    if (button == btnUP)
    {
      timedBeep(shortBeep,1);
      clearIt = !clearIt;
    }
    if (button == btnDOWN)
    {
      timedBeep(shortBeep,1);
      clearIt = !clearIt;
    }
    if (button == btnRIGHT)
    {
      timedBeep(shortBeep,1);
      alarmSet = !clearIt;
      if (clearIt)
      {
        lcdClear();
        timedBeep(shortBeep,2);
        lcd.print("Alarm Cleared!");
        delay(2000);
      }
      return; 
    }
    lcd.setCursor(8,0);
    if (clearIt)
    {
      lcd.print("Yes"); 
    }
    else{
      lcd.print("No ");
    }
  }   
}
////////////////////////////////////////////////////////////////////////

void minuteTimer()
{
  // maxCount to getTimerMinutes
  int timerMinutes = getTimerMinutes("Set Minutes", 0, 60);
  if (timerMinutes > 0)
  {
    //timedCountDown(timerMinutes*60, "Minute Timer");
    timedCountDown(timerMinutes*60, 0);
  }
  else
  {
    timerCancelled("Timer");       
  }
  return;
}
///////////////////////////////////////////////////////////////////////

void setAlarm()
{
  int button = 0;

  alarmHours = getTimerMinutes("Set Alarm Hour", alarmHours, 12);  
 
 if (alarmHours > 0 && alarmHours < 13)
  {
 alarmMinutes = getTimerMinutes("Set Minutes", alarmMinutes, 59);
    
  if (alarmMinutes < 60)
    {
      lcdClear();
      lcd.setCursor(8,0);
      //display alarm time
      lcd.print(alarmHours);       
      lcd.print(":");
      if (alarmMinutes < 10)
        lcd.print("0");
      lcd.print(alarmMinutes);
      lcd.setCursor(6,1);
    
      button = 6;
      while (button != btnSELECT && button != btnRIGHT)
      {
        button = read_LCD_buttons();
        if (button == btnUP || button == btnDOWN)
        {
          timedBeep(shortBeep,1);
            lcd.setCursor(6,1);  
        }
      }
      if (button == btnRIGHT)
      {
        timedBeep(shortBeep,1);
        alarmSet = true;          
        lcd.setCursor(0,0);
        lcd.print("Alarm Set for");
        delay(1000);
        return;       
      }
      else
      {
        timerCancelled("Alarm");
        return;  
      }   
    }
    else
    {
      timerCancelled("Alarm");     
    }    
  }     
  else
  {
    timerCancelled("Alarm");       
  }
}
///////////////////////////////////////////////////////////////////////

void setDateTime()
{
  int button = 0;
    {
      {
           {        
        int thisHour = lastHour;
        // default hour settings on set /time
        if (thisHour > 23) 
        {
          thisHour -= 23;
          }
        
        int setHour = getTimerMinutes("Set Hour", thisHour, 12);
        if (setHour > 0 && setHour < 13)
        {
          //get minutes
          
          int setMinute = getTimerMinutes("Set Minute", lastMinute, 59);
          if (setMinute < 60)
          {
           
            lcdClear();
              
            lcd.setCursor(8,0);
            lcd.print(setHour);       
            lcd.print(":");
            if (setMinute < 10)
              lcd.print("0");
            lcd.print(setMinute);
            lcd.setCursor(6,1);           
            button = 6;
            while (button != btnSELECT && button != btnRIGHT)
            {
              button = read_LCD_buttons();
              if (button == btnUP || button == btnDOWN)
              {
                timedBeep(shortBeep,1);

                 lcd.setCursor(6,1);
              }
            }
            if (button == btnRIGHT)
            {
              timedBeep(shortBeep,1);
              lcdClear(); //****************

              RTC.adjust(DateTime(0,0,0,setHour,setMinute));
              lcd.setCursor(0,0);
              lcd.print("Saving...     ");
              delay(1000);
              return;       
            }
            else
            {
              timerCancelled("");
              return;  
            }  
          }
          else
          {
            timerCancelled("");     
          }    
        }     
        else
        {
          timerCancelled("");       
        }
        }
       }
     }
   }

// read the buttons
int read_LCD_buttons()
{
  adc_key_in = analogRead(0);      // read the value from the sensor
  // my buttons when read are centered at these valies: 0, 144, 329, 504, 741
  // we add approx 50 to those values and check to see if we are close
  if (adc_key_in > 1000) return btnNONE; // We make this the 1st option for speed reasons since it will be the most likely result
  if (adc_key_in < 50)   return btnRIGHT; 
  if (adc_key_in < 195)  return btnUP;
  if (adc_key_in < 380)  return btnDOWN;
  if (adc_key_in < 555)  return btnLEFT;
  if (adc_key_in < 790)  return btnSELECT;  
  return btnNONE;  // when all others fail, return this...
}
///////////////////////////////////////////////////////////////////////

void timedCountDown(int secondCount, char countLabel[])
{
  long seconds = 0;
  long minutes = 0; 

  lcdClear();
  lcd.print(countLabel);
  for (int i = secondCount; i >= 0; i--)
  {
    seconds = i;
    minutes = i / 60;
    if (minutes > 0)
    {
      seconds = seconds - (minutes * 60);  
    }     

    if (minutes > 0)
    {
      lcd.setCursor(12,0);
      lcd.print(minutes);
      lcd.print(" min ");
    }
    else
    {
      lcd.setCursor(12,0);
    }
    if (seconds < 10) lcd.print("0");
    lcd.print(seconds);
    
    if (seconds > 0) delay(1000); 
    if (read_LCD_buttons() == btnSELECT) //cancel
    {
      timerCancelled("Timer");
      i = 0;
      return;
    }
  }
  lcd.setCursor(6,1);
  timedBeep(longBeep,3);
}

//  maxCount to getTimerMinutes
int getTimerMinutes(char timerText[], int STARTNum, int maxCount)
{
  int minutes = STARTNum;
  int button = 0;
  lcdClear();
  lcd.print(timerText);
  lcd.setCursor(12,0);
  lcd.print(minutes);   

  while (button != btnSELECT)
  {
    button = read_LCD_buttons();
    
    // maxCount to getTimerMinutes
    if (button == btnLEFT)
    {
      if ((minutes + 10) <= maxCount)
      {
        timedBeep(shortBeep,1);
        minutes = minutes + 10;
      }
      else
      {
        timedBeep(shortBeep,2); 
      }
    }
    // maxCount to getTimerMinutes
    if (button == btnUP)
    {
      if (minutes < maxCount)
      {
        timedBeep(shortBeep,1);
        minutes++;
      }
      else
      {
        timedBeep(shortBeep,2); 
      }
    }
    if (button == btnDOWN)
    {
      if (minutes > 0)
      {
        timedBeep(shortBeep,1);
        minutes--;
      }
      else
      {
        timedBeep(shortBeep,2); 
      }   
    } 
    if (button == btnRIGHT)
    {
      timedBeep(shortBeep,1);
      return minutes; 
    }
      lcd.setCursor(12,0);
      lcd.print(minutes); 
      lcd.print("   ");
  }
  return 0;
}
////////////////////////////////////////////////////////////////////

void timedBeep(int beepTime, int beepCount)
{
  for (int i = 0; i < beepCount; i ++)
  {
    digitalWrite(beeper, HIGH);
    delay(beepTime);
    digitalWrite(beeper, LOW);
    delay(beepTime);
  }
}

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

void lcdClear(){
  // default hour settings on set time
  resetClock = true;
  lcd.clear();
  lcd.begin(16,2);
  lcd.setCursor(0,0); 
}
///////////////////////////////////////////////

void timerCancelled(char message[])
{
  lcdClear();
  lcd.print(message);
  lcd.print(" Cancelled");
  timedBeep(shortBeep,3);    
}

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

void setOffAlarm()
{
  int button = 0;
  int i = 0;
  Serial.println(i);
  lcd.backlight(); // turn backlight on
  while (button != btnSELECT)
  {
    button = read_LCD_buttons();
    lcdClear();
    i++;
    if (i > 50)
    {
      lcdClear();
      lcd.setCursor(0,1);
      lcd.print("Power ON");      
      i = 0;
      timedBeep(shortBeep,3);
     digitalWrite(RELAY_PIN,HIGH);
    }

  }     
  timerCancelled("Alarm"); 
  alarmSet = false;  
}

[wowa]

Скеч терморегулятора рабочий пока что на столе:

#include*<LiquidCrystal_I2C.h>
#include*<Wire.h>
#include*<DallasTemperature.h>
#include*<OneWire.h>
#include*<EEPROM.h>  //Заданная температура будет храниться по адресу 0
#define*RELAY_PIN*11*// //Реле подключено к пину D11

#define*Sauna*8*//Sauna sens in
#define*KonTS*9*//Sauna control sens in


******OneWire Sauna_T(Sauna);// 
******OneWire KonTS_T(KonTS); //k
******DallasTemperature SaunaSensor(&Sauna_T);
******DallasTemperature KonTSSensor(&KonTS_T);
*****
******DeviceAddress Sauna_Sensor_Address;
******DeviceAddress KonTS_Sensor_Address;
******
boolean relayStatus1=LOW; //

int temp1=0; // 
int temp1k=0; // 
int setTmp=0; // 

long previousMillis1 = 0;// //Объявим переменные для задания задержки
long interval1 = 1000; // интервал опроса датчиков температуры

uint8_t*heat[8]*=*{0x4,*0xe,*0x1f,*0x4,*0x4,*0x4,*0x4,*0x0};*//
uint8_t*symb[8]*=*{0xc,0x12,0x12,0xc,0x0,0x0,0x0};*// 

//Аналоговая*клавиатура*подключена*к*пину*A0
#define*KEYPAD_PIN*A0*//Определим значения на аналоговом входе для клавиатуры 

#define*ButtonRight_LOW*0
#define*ButtonRight_HIGH*50
#define*ButtonUp_LOW*90
#define*ButtonUp_HIGH*160
#define*ButtonDown_LOW*200
#define*ButtonDown_HIGH*350
#define*ButtonLeft_LOW*400
#define*ButtonLeft_HIGH*550
#define*ButtonSelect_LOW*650
#define*ButtonSelect_HIGH*850

LiquidCrystal_I2C lcd(0x20,16,2);  // set the LCD address to 0x20 for a LCD16x2
/////////////////////////////////////////////////////////////////////////////////
void setup() {
**pinMode(RELAY_PIN,OUTPUT);//
**digitalWrite(RELAY_PIN,LOW);
**setTmp*=*EEPROM.read(0);//
***SaunaSensor.begin();
***SaunaSensor.getAddress(Sauna_Sensor_Address, 0);
****SaunaSensor.setResolution(12); 
////////////////////////////////////////////////////////////
***KonTSSensor.begin();
***KonTSSensor.getAddress(KonTS_Sensor_Address, 1);
***KonTSSensor.setResolution(12); 
////////////////////////////////////////////////////////////////

***lcd.init();   // initialize the lcd
***lcd.backlight(); 
***lcd.clear();
***lcd.createChar(1, heat);
***lcd.createChar(2, symb);
***lcd.setCursor(0, 0);
***lcd.print("Sauna controller");
***lcd.setCursor(0, 1);
***lcd.print("      v1.0      ");
**delay(2000);
***lcd.clear();

//
**lcd.setCursor(0, 0);
**lcd.print(" Set Temp: ");
**lcd.setCursor(7, 1);
**lcd.print(setTmp);
**lcd.setCursor(9, 1);
**lcd.write(2);
**lcd.print("C");
**delay(4000);
**lcd.begin(16, 2);//
**lcd.clear();
}

//Определим*функцию*для*опроса*аналоговой*клавиатуры
//Функция*опроса*клавиатуры,*принимает*адрес*пина,*к*которому*
//подключена*клавиатура,*и*возвращает*код*клавиши:
//*1*-*UP
//*2*-*DOWN
//*3*-*LEFT
//*4*-*RIGHT
//*5*-*SELECT

int ReadKey(int keyPin)
{
*int KeyNum=0;
*int KeyValue1=0;
*int KeyValue2=0;

//Читаем*в*цикле*аналоговый*вход,*для*подавления*дребезга*
//и*нестабильности*читаем*по*два*раза*подряд,*пока*значения*
//не*будут*равны.
//Если*значения*равны*1023*–*значит*не*была*нажата*ни**одна*клавиша.

do {
KeyValue1=analogRead(keyPin);
*KeyValue2=analogRead(keyPin);
*}*while (KeyValue1==KeyValue2&&KeyValue2!=1023);

//Интерпретируем*полученное*значение*и*определяем*код*нажатой*клавиши
*if (KeyValue2<ButtonUp_HIGH&&KeyValue2>ButtonUp_LOW) {KeyNum=1;}//Up
*if (KeyValue2<ButtonDown_HIGH&&KeyValue2>ButtonDown_LOW) {KeyNum=2;}//Down
*if (KeyValue2<ButtonLeft_HIGH&&KeyValue2>ButtonLeft_LOW) {KeyNum=3;}//Left
*if (KeyValue2<ButtonRight_HIGH&&KeyValue2>ButtonRight_LOW) {KeyNum=4;}//Right
*if (KeyValue2<ButtonSelect_HIGH&&KeyValue2>ButtonSelect_LOW) {KeyNum=5;}//Select
return KeyNum;// //Возвращаем код нажатой клавиши 
return KeyNum;
}
//Определим*процедуру*редактирования*заданной*температуры
//Вызывается*по*нажатию*клавиши*Select,*отображает*на*дисплее*
//заданную*температуру*и*позволяет*изменять*ее*клавишами*Up*и*Down
/////////////////////////////////////////////////////////////////////////////////
void setTemperature() {
**int keyCode=0;

//выводим*на*дисплей*заданное*значение*температуры**
**lcd.clear();
**lcd.begin(16,2);
**lcd.setCursor(0, 0);
**lcd.print(" Set temperature ");
**lcd.setCursor(7, 1);
**lcd.print(setTmp);

//Опрашиваем*клавиатуру,*если*нажата*клавиша*Up*увеличиваем*
//значение*на*1,*если*Down*–*уменьшаем*на*1
//Если*нажаты*клавиши*Select*или*Right*–*цикл*опроса*прерывается
//Задержки*введены*для*борьбы*с*дребезгом,*если*клавиши*срабатывают*
//четко*–*можно*уменьшить*время*задержек*или*вообще*их*убрать
do {
**keyCode=ReadKey(KEYPAD_PIN);
**if (keyCode==1){setTmp++;delay(200);lcd.setCursor(7, 1);lcd.print(setTmp);}
**if (keyCode==2){setTmp--;delay(200);lcd.setCursor(7, 1);lcd.print(setTmp);}
}*while (keyCode!=5 && keyCode!=4);
**delay(200);

//По*клавише*Select*–*сохраняем*в*EEPROM*измененное*значение
//По*клавише*Right*–*восстанавливаем*старое*значение
if (keyCode==5) {EEPROM.write(0, setTmp);}
if (keyCode==4) {setTmp = EEPROM.read(0);}
}
///////////////////////////////////////////////////////////////////////////////
void loop() {

//Модуль*опроса*датчиков*и*получения*сведений*о*температуре
//Вызывается*1*раз*в*секунду
**unsigned long currentMillis1 = millis();
if(currentMillis1 - previousMillis1 > interval1) {
****previousMillis1*=*currentMillis1;**

//Запуск*процедуры*измерения*температуры
**SaunaSensor.setWaitForConversion(false);
**SaunaSensor.requestTemperatures();
**SaunaSensor.setWaitForConversion(true);
/////////////////////////////////////////////////////////////////////////////
KonTSSensor.setWaitForConversion(false);
**KonTSSensor.requestTemperatures();
**KonTSSensor.setWaitForConversion(true);
////////////////////////////////////////////////////////////////////////////
//Считывание*значения*температуры
**SaunaSensor.getAddress(Sauna_Sensor_Address, 0);
**temp1=SaunaSensor.getTempC(Sauna_Sensor_Address);
/////////////////////////////////////////////////////////////////////////////////////////////////
KonTSSensor.getAddress(KonTS_Sensor_Address, 1);
**temp1k=KonTSSensor.getTempC(KonTS_Sensor_Address);
//////////////////////////////////////////////////////////////////////////////////////////////////
//*Вывод*текущего*значения*температуры*на*дисплей
lcd.clear();
**lcd.setCursor(0, 1);
**lcd.print("SAUNA T: ");
**lcd.setCursor(10, 1);
**lcd.print(temp1);
**lcd.setCursor(13, 1);
**lcd.write(2);
**lcd.print("C");
}
***lcd.setCursor(15, 1);    
***if (relayStatus1==HIGH) //power on?
***{lcd.write(1);}
//////////////////////////////////////////////////////////////////////////////////////////////////////////

if ((temp1-temp1k)>0||(temp1-temp1k)<0){
lcd.clear();
lcd.print("Error");//error sens
delay(2000);
digitalWrite(RELAY_PIN,LOW); // relay power off
}*
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
//Проверка*условия*включения/выключения*нагревателя
if (temp1<setTmp&&relayStatus1==LOW)
{relayStatus1=HIGH; digitalWrite(RELAY_PIN,HIGH);}
if (temp1>setTmp&&relayStatus1==HIGH)
{relayStatus1=LOW; digitalWrite(RELAY_PIN,LOW);}

int Feature = ReadKey(KEYPAD_PIN);// 

//Включение*подсветки
if (Feature==1 ) 
{lcd.backlight();} 

//Отключение*подсветки
if (Feature==2 ) 
{lcd.noBacklight();} 

*//Переход к редактированию заданной температуры
if (Feature==5 ) 
{delay(200);setTemperature();}
}

[Admin]

Я думаю что полезно и познавательно, для других пользователей

[wowa]

Сообщение от Admin

Я думаю что полезно и познавательно, для других пользователей

Полезно- когда толково, а здесь пока есть где повалятся. Если терморегулятор работает, то с часами запутался. Будильник можно установить но как каждый раз запускать таймер, как то светлые мысли в голову не приходят. Как уже писал выше должна быть реализована ещё одна защитная ф-я когда включается тэны ( при срабатывании будильника или при нажатии кнопки СТАРТ) запускается внутренний таймер на 4 часа (например) по истечении отключает тэны.
Ну и конечно самое главное слить эти два скеча во единое.
Третий модуль регулятор вентилятора. Решил отказаться от всеми упрекаемой схемы на симисторе из за шума, гармоник, перегрева. Пошёл по более сложному и дорогому пути на IGBT. Не знаю пока на сколько она рабочая эта схема, жду деталей в декабре, за это время надо написать скеч для управления ШИМ 16кГц при помощи кнопок up/down и видеть на LCD градацию от 0 до 10 (например), с нижнем порогом оборотов где- то 70%, а то не долго проживёт моторчик.

Сообщение от mebitek

Покопайся здесь, может что нужное найдёшь:
http://www.cyber-place.ru/showthread.php?t=621

Спасибо за инфу но там пока без описания и с худыми коментами сложновато.
Вот схема регулятора оборотов, на сколько она правильная, тут нужна или практика или светлая голова. Стоимость деталей где то 20 американцев.